ViewModel旋转屏幕仍然保持存在原理

于 2023-06-11 12:04:05 发布
阅读量208 收藏 1
点赞数
文章标签： android kotlin
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40941027/article/details/131151898
版权

目录

2022/08/21

Activity创建ViewModel

  • 创建ViewModel

    // MyActivity#onCreate()

val mainViewModel = 
            [V1]   ViewModelProvider(this)
              [V2]       .get(MainViewModel::class.java)

  • [V1]

    ViewModelProvider构造函数

    // androidx.lifecycle.ViewModelProvider#get(java.lang.Class<T>)
    public constructor(
        owner: ViewModelStoreOwner
    ) : this(owner.viewModelStore, defaultFactory(owner), defaultCreationExtras(owner))

    this指MyActivity，即MyActivity应该是[I]ViewModelStoreOwner类型

    MyActivity继承[C]ComponentActivity]，ComponentActivity实现了[I]ViewModelStoreOwner接口

    // CompnentActivity
public class ComponentActivity extends androidx.core.app.ComponentActivity implements
        // ...
        ViewModelStoreOwner,
        // ... {

    this(owner.viewModelStore, defaultFactory(owner), defaultCreationExtras(owner)) ，这里使用 owner.viewModelStore从ViewModelStoreOwner中取出[OC]ViewModelStore]

    // ViewModelStoreOwner
interface ViewModelStoreOwner {

    /**
     * The owned [ViewModelStore]
     */
    val viewModelStore: ViewModelStore
}

    然后调用下面的构造函数

    // ViewModelStoreOwner

/**
 * Creates a ViewModelProvider
 *
 * @param store `ViewModelStore` where ViewModels will be stored.
 * @param factory factory a `Factory` which will be used to instantiate new `ViewModels`
 * @param defaultCreationExtras extras to pass to a factory
 */
@JvmOverloads
constructor(
    private val store: ViewModelStore,
    private val factory: Factory,
    private val defaultCreationExtras: CreationExtras = CreationExtras.Empty,
) {

  • [V2]

    调用了get方法⬇️

    // androidx.lifecycle.ViewModelProvider#get(java.lang.Class<T>)
    @MainThread
    public open operator fun <T : ViewModel> get(modelClass: Class<T>): T {
        val canonicalName = modelClass.canonicalName
            ?: throw IllegalArgumentException("Local and anonymous classes can not be ViewModels")
   [W1]  return get("$DEFAULT_KEY:$canonicalName", modelClass)
    }

  • [W1]

    // androidx.lifecycle.ViewModelProvider#get(java.lang.String, java.lang.Class<T>)
    @MainThread
    public open operator fun <T : ViewModel> get(key: String, modelClass: Class<T>): T {
    [X1]val viewModel = store[key]
    [X1]if (modelClass.isInstance(viewModel)) {
            ....
    [X1]    return viewModel as T
        ....
    [X2]return try {
    [X2]     factory.create(modelClass, extras)
    [X2] catch (e: AbstractMethodError) {
    [X2]    factory.create(modelClass)
    [X2]}.also { store.put(key, it) }
    }

  • [X1]⬅️[W1]

    从store([OC]ViewModelStore)中能找到viewmodel则直接返回

  • [X2]⬅️[W1]

    store中找不到则需要新创建一个viewmodel并放入store，这里说明只要使用同一个ViewModelStore获取ViewModel则不同地方获取到的都是同一个ViewModel

    [OC]ViewModelStore看起来是个Map，事实上他的实现就是维护一个map，放出get和put方法

    open class ViewModelStore {

    private val map = mutableMapOf<String, ViewModel>()
    ...

    fun put(key: String, viewModel: ViewModel) {
    }

    operator fun get(key: String): ViewModel? {
        return map[key]
    }
    ...
}

总结上面，Activity在onCreate时创建viewModel，Activity是一个ViewModelStoreOwner其中有一个ViewModelStore其中维护一个map，ViewModelProvier作为一个工具类在使用默认的/我们提供的Factory（为了适配构造函数有参的ViewModel）创建ViewModel的同时会将其存入这个map。

所以，在relaunch过程中，销毁旧的Activity中的mViewModelStore然后将其赋值新的Activity的mViewModelStore就能实现配置变更viewModel不变更的效果。

Activity重建ViewModel保持存在的实现

relaunch之后新的Activity获取之前的viewModel

viewModel存在ViewModelStore中，说明ViewModelStore在Activity重建的过程中能保持存在，看下[C]ComponentActivity如何如何获取[OC]ViewModelStore的

    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.");
        }
   [T1] ensureViewModelStore();
        return mViewModelStore;
    }

  • [T1]

    在getViewModelStore()方法中调用了ensureViewModelStore()确保mViewModelStore不为空

        @SuppressWarnings("WeakerAccess") /* synthetic access */
    void ensureViewModelStore() {
        if (mViewModelStore == null) {
        [U1] NonConfigurationInstances nc =
                    (NonConfigurationInstances) getLastNonConfigurationInstance();
            if (nc != null) {
                // Restore the ViewModelStore from NonConfigurationInstances
        [U2]    mViewModelStore = nc.viewModelStore;
            }
            if (mViewModelStore == null) {
                mViewModelStore = new ViewModelStore();
            }
        }
    }

  • [U1]⬅️[T1]

    // Activity

    @Nullable
    public Object getLastNonConfigurationInstance() {
        return mLastNonConfigurationInstances != null
                ? mLastNonConfigurationInstances.activity : null;
    }

    Activirty.mLastNonConfigurationInstances类型为[C]Activity.NonConfigurationInstances

    // android.app.Activity.NonConfigurationInstances
    static final class NonConfigurationInstances {
        Object activity;
        ....
    }

    mLastNonConfigurationInstances.activity在[U1]⬅️[T1]处被强转为[C]ComponentActivity.NonConfigurationInstances

    // androidx.activity.ComponentActivity.NonConfigurationInstances
    static final class NonConfigurationInstances {
        Object custom;
        ViewModelStore viewModelStore;
    }

  • [U2]⬅️[T1]

    如果[U1]获取的nc不为空，则将mViewModelStore赋值为nc.viewModelStore 即Activity.mLastNonConfigurationInstances.activity.viewModelStore

    所以想要保存给新Activity使用原来的viewModel，重点就是要在relaunch过程中保存旧的Activity.mLastNonConfigurationInstances然后再赋值给新Activity.mLastNonConfigurationInstances

relaunch过程中保存旧Activity的viewModel

设备变更，系统调用AMS的updateConfiguration 方法

ActivityManagerService.java - Android Code Search

// ActivityManagerService
    @Override
    public boolean updateConfiguration(Configuration values) {
        return mActivityTaskManager.updateConfiguration(values);
    }

// ActivityTaskManagerService
    @Override
    public boolean updateConfiguration(Configuration values) {
           ....
                updateConfigurationLocked(values, null, false, false /* persistent */,
           ....
    }

// ActivityTaskManagerService
    boolean updateConfigurationLocked(Configuration values, ActivityRecord starting,
            boolean initLocale, boolean persistent, int userId, boolean deferResume,
            ActivityTaskManagerService.UpdateConfigurationResult result) {
            ....
            「I1」  changes = updateGlobalConfigurationLocked(values, initLocale, persistent, userId);
            ....
            「I2」 kept = ensureConfigAndVisibilityAfterUpdate(starting, changes);
            ....
    }

  • 「I1」

    updateGlobalConfigurationLocked 更新当前配置信息

  • 「I2」

    ensureConfigAndVisibilityAfterUpdate 确保给定的activity更新使用的配置

    这里starting传入的是null，需要ensureConfigAndVisibilityAfterUpdate中自己获取

    // ActivityTaskManagerService
    boolean ensureConfigAndVisibilityAfterUpdate(ActivityRecord starting, int changes) {
        boolean kept = true;
     「J1」   final Task mainRootTask = mRootWindowContainer.getTopDisplayFocusedRootTask();
        ....
             「J2」 starting = mainRootTask.topRunningActivity();
        ....
             「J3」 kept = starting.ensureActivityConfiguration(changes,
        ....
    }

  • 「J1」⬅️「I2」

    获取根窗口容器中当前具有焦点的顶级任务（root task）

  • 「J2」⬅️「I2」

    获取顶级任务（root task）中当前正在运行的顶级Activity（top running Activity）的ActivityRecord赋值给starting

  • 「J3」⬅️「I2」

    ActivityRecord对应的Activity更新Configuration

    // com.android.server.wm.ActivityRecord#ensureActivityConfiguration(int, boolean)
    boolean ensureActivityConfiguration(int globalChanges, boolean preserveWindow) {
        return ensureActivityConfiguration(globalChanges, preserveWindow,
                false /* ignoreVisibility */);
    }


    // com.android.server.wm.ActivityRecord#ensureActivityConfiguration(int, boolean, boolean)
    boolean ensureActivityConfiguration(int globalChanges, boolean preserveWindow,
            boolean ignoreVisibility) {
            ....
                relaunchActivityLocked(preserveWindow);
            ....
    }

     // com.android.server.wm.ActivityRecord#relaunchActivityLocked
    void relaunchActivityLocked(boolean preserveWindow) {
            ....
       「K2」  final ClientTransactionItem callbackItem = ActivityRelaunchItem.obtain(pendingResults,
            ....
       「K1」  final ClientTransaction transaction = ClientTransaction.obtain(app.getThread(), token);
       「K2」  transaction.addCallback(callbackItem);
            ....
       「K3」  mAtmService.getLifecycleManager().scheduleTransaction(transaction);
            ....
    }

  • 「K1」⬅️「J3」

    token来自[C]ActivityRecord继承的[C]WindowToken中的token

    class WindowToken extends WindowContainer<WindowState> {
    private static final String TAG = TAG_WITH_CLASS_NAME ? "WindowToken" : TAG_WM;

    /** The actual token */
    final IBinder token;

    /** The type of window this token is for, as per {@link WindowManager.LayoutParams} */
    final int windowType;

     // ClientTransaction
    /** Obtain an instance initialized with provided params. */
    public static ClientTransaction obtain(IApplicationThread client, IBinder activityToken) {
        ClientTransaction instance = ObjectPool.obtain(ClientTransaction.class);
        if (instance == null) {
            instance = new ClientTransaction();
        }
        instance.mClient = client;
        instance.mActivityToken = activityToken;

        return instance;
    }

    将transaction.mActivityToken设置为ActivityRecord.token

  • 「K2」⬅️「J3」

    给transaction放入callback：[C]ActivityRelaunchItem

  • 「K3」⬅️「J3」

    执行transaction

    // com.android.server.wm.ClientLifecycleManager#scheduleTransaction(ClientTransaction)
    void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
        ....
        transaction.schedule();
        ....
    }

    // ClientTransaction
    public void schedule() throws RemoteException {
   「L1」  mClient.scheduleTransaction(this);
    }

  • 「L1」⬅️「K3」

    [C]ClientTransaction使用mClient执行自己

    • mClient是什么? 
      // ClientTransaction
    /** Target client. */
    private IApplicationThread mClient;
      这里是使用AIDL(基于Binder)进行进程间通信，对应文件IApplicationThread.aidl⬇️
      oneway interface IApplicationThread {
    ....
    void scheduleTransaction(in ClientTransaction transaction);
      这里mClient是客户端，对应的客户端为[c]ApplicationThread
          private class ApplicationThread extends IApplicationThread.Stub {

  • 「M1」⬅️「L1」

    所以下面从 android.app.ActivityThread.ApplicationThread#scheduleTransaction方法继续

    // android.app.ActivityThread.ApplicationThread#scheduleTransaction
        @Override
        public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
            ActivityThread.this.scheduleTransaction(transaction);
        }

    这里scheduleTransaction是调用的ActivityThread的基类ClientTransactonHandler中的scheduleTransaction方法

    // android.app.ClientTransactionHandler#scheduleTransaction
    void scheduleTransaction(ClientTransaction transaction) {
 「N1」  transaction.preExecute(this);
 「N2」  sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
    }

  • 「N1」⬅️「M1」

    为后面transaction的执行做些准备，这里this传入的是[C]ActivityThread

        public void preExecute(android.app.ClientTransactionHandler clientTransactionHandler) {
        if (mActivityCallbacks != null) {
            ....
            for (int i = 0; i < size; ++i) {
            「O1」  mActivityCallbacks.get(i).preExecute(clientTransactionHandler, mActivityToken);
            ....
    }

  • 「O1」⬅️「N1」

    执行每个callback的preExecute方法，callback只有一个之前在「K2」处放入的ActivityRelaunchItem

     // android.app.servertransaction.ActivityRelaunchItem#preExecute
    public void preExecute(ClientTransactionHandler client, IBinder token) {
    「P1」 mActivityClientRecord = client.prepareRelaunchActivity(token, mPendingResults,
                mPendingNewIntents, mConfigChanges, mConfig, mPreserveWindow);
    }

  • 「P1」⬅️ 「O1」

    从ActivityThread(即client)获取要relaunch的ActivityRecord存入ActivityRelaunchItem.mActivityClientRecord

        @Override
    public ActivityClientRecord prepareRelaunchActivity(IBinder token,
            List<ResultInfo> pendingResults, List<ReferrerIntent> pendingNewIntents,
            int configChanges, MergedConfiguration config, boolean preserveWindow) {
    「Q1」     ....

    「Q2」     target = new ActivityClientRecord();
    「Q2」     target.token = token;
                ....
    「Q3」     mRelaunchingActivities.add(target);
                ....

        return ....target....;
    }

  • 「Q1」⬅️「P1」

    检查是否目标activity是否已经正在relaunch了，如果是则返回

  • 「Q2」⬅️「P1」

    目标activity没有已经正在relaunch（这里认为是没有，这个判断只是为了防止relaunch正在relaunch的activity），则构造一个[sC]ActivityClientRecord记录要relaunch的Activity的token等信息

  • 「Q3」⬅️「P1」使用ActivityThread.mRelaunchingActivities记录所有要准备重启的ActivityClientRecord

    +-----------------------------------------------------+
|                                                     |
|                 ActivityThread                      |
|                                                     |
|       +-----------------------------------+         |
|       |    mRelaunchingActivities         |         |
|       |                                   |         |
|       |   +------------------------+      |         |
|       |   | ActivityClientRecord   |      |         |
|       |   +------------------------+      |         |
|       |                                   |         |
|       |   +------------------------+      |         |
|       |   | ActivityClientRecord   |      |         |
|       |   +------------------------+      |         |
|       |                                   |         |
|       |           ....                    |         |
|       |                                   |         |
|       |                                   |         |
|       +-----------------------------------+         |
|                                                     |
+-----------------------------------------------------+

  • 「N2」⬅️「M1」

    这里使用Handler去真正执行transaction，obj传入的就是transaction

    // android.app.ClientTransactionHandler#sendMessage
    abstract void sendMessage(int what, Object obj);

    // android.app.ActivityThread#sendMessage(int, java.lang.Object)
    void sendMessage(int what, Object obj) {
        sendMessage(what, obj, 0, 0, false);
    }

    ⬇️构造Message

    // android.app.ActivityThread#sendMessage(int, java.lang.Object, int, int, boolean)
    private void sendMessage(int what, Object obj, int arg1, int arg2, boolean async) {
        ....
        msg.what = what;
        msg.obj = obj;
        ....
        mH.sendMessage(msg);
    }

    ⬇️handler：ActivityThread.H 收到消息并处理

    // android.app.ActivityThread.H#handleMessage
        public void handleMessage(Message msg) {
            ...
             switch (msg.what) {
                ...
                case EXECUTE_TRANSACTION:
              「R1」  final ClientTransaction transaction = (ClientTransaction) msg.obj;
              「R2」  mTransactionExecutor.execute(transaction);
                    ....

  • 「R1」⬅️「N2」从message中取出transaction

  • 「R2」⬅️「N2」交给mTransactionExecutor执行

    mTransactionHandler 是谁？是[C]ActivityThread，从TransactionExecutor的构造函数⬇️中可以看出

    // ActivityThread
    private final TransactionExecutor mTransactionExecutor = new TransactionExecutor(this);


        /** Initialize an instance with transaction handler, that will execute all requested actions. */
    public TransactionExecutor(ClientTransactionHandler clientTransactionHandler) {
        mTransactionHandler = clientTransactionHandler;
    }

    TransactionExecutor.mTransactionHandler是对持有该TransactionExecutor的ActivityThread的引用

    +-------------------------------------------------------------------------------------+
|                                    ActivityThread <-------+                         |
|                                                           |                         |
|                                                           |                         |
|      +-----------------------------------------------------------------+            |
|      |  mTransactionExecutor: TransactionExecutor         |            |            |
|      |                                                    |            |            |
|      |                                                    |            |            |
|      |  +-------------------------------------------------+---------+  |            |
|      |  |   mTransactionHandler: ClientTransactionHandler           |  |            |
|      |  |                                                           |  |            |
|      |  |                                                           |  |            |
|      |  +-----------------------------------------------------------+  |            |
|      |                                                                 |            |
|      |                                                                 |            |
|      +-----------------------------------------------------------------+            |
|                                                                                     |
+-------------------------------------------------------------------------------------+


    // android.app.servertransaction.TransactionExecutor#execute
    public void execute(ClientTransaction transaction) {
        ....
        executeCallbacks(transaction);
        ....
    }

    // android.app.servertransaction.TransactionExecutor#executeCallbacks
    public void executeCallbacks(ClientTransaction transaction) {
        final List<ClientTransactionItem> callbacks = transaction.getCallbacks();
        ....
  「S1」 final IBinder token = transaction.getActivityToken();
        ....
        for (int i = 0; i < size; ++i) {
            final ClientTransactionItem item = callbacks.get(i);
            ....
    「S2」  item.execute(mTransactionHandler, token, mPendingActions);
            ....
    }

  • 「S1」⬅️「R2」

    从transaction中获取activityToken「K1」⬅️「J3」

  • 「S2」⬅️「R2」

    callback（为ActivityRelaunchItem）执行，execute方法来自ActivityRelaunchItem 实现的接口BaseClientRequest的execute方法

    至于mTransactionHandler是谁，在「R2」已经解释

    execute方法来自ActivityRelaunchItem实现的接口BaseClientRequest中的execute方法⬇️

    public interface BaseClientRequest extends ObjectPoolItem {

    ....
    void execute(ClientTransactionHandler client, IBinder token,
            PendingTransactionActions pendingActions);
    ....

}

    ActivityRelaunchItem和BaseClientRequest的关系⬇️

    public abstract class ClientTransactionItem implements BaseClientRequest

    public abstract class ActivityTransactionItem extends ClientTransactionItem

    public class ActivityRelaunchItem extends ActivityTransactionItem
    implements
    ClientTransactionItem
    ActivityTransactionItem
    ActivityRelaunchItem
    «interface»
    BaseClientRequest
    +execute(ClientTransactionHandler client, IBinder token,PendingTransactionActions pendingActions)

    该execute方法由[C]ActivityRelaunchItem的基类ActivityTransactionItem实现

    // ActivityTransactionItem
    public final void execute(ClientTransactionHandler client, IBinder token,
            PendingTransactionActions pendingActions) {
   「A1」  final ActivityClientRecord r = getActivityClientRecord(client, token);

   「A2」  execute(client, r, pendingActions);
    }

  • 「A1」根据token获取ActivityClientRecord

    // ActivityTransactionItem
    @NonNull ActivityClientRecord getActivityClientRecord(
            @NonNull ClientTransactionHandler client, IBinder token) {
        final ActivityClientRecord r = client.getActivityClient(token);
        ....
        return r;
    }

    client是 TransactionExecutor.mTransactionHandler，也就是持有TransactionExecutor的ActivityThread

    // ActivityThread 
    @Override
    public ActivityClientRecord getActivityClient(IBinder token) {
        return mActivities.get(token);
    }

  • 「A2」继续执行 ⬇️

    // ActivityRelaunchItem
    @Override
    public void execute(ClientTransactionHandler client, ActivityClientRecord r,
            PendingTransactionActions pendingActions) {
        ....
  「B1」  client.handleRelaunchActivity(mActivityClientRecord, pendingActions);
    }

  • 「B1」mActivityClientRecord从哪里来？之前🔗「P1」⬅️ 「O1」

    // ActivityThread
    @Override
    public void handleRelaunchActivity(ActivityClientRecord tmp,
            PendingTransactionActions pendingActions) {
        ...
    「C1」 ActivityClientRecord r = mActivities.get(tmp.token);
        ...
    「C2」handleRelaunchActivityInner(r, configChanges, tmp.pendingResults, tmp.pendingIntents,
                pendingActions, tmp.startsNotResumed, tmp.overrideConfig, "handleRelaunchActivity");
        ...
    }

  • 「C1」⬅️「B1」

    这里从mActivities中根据token获取[sC]ActivityClientRecord

    +----------------------------------------------------------------+
|   ActivityThread                                               |
|                                                                |
|                                                                |
|    +------------------------------------------------------+    |
|    |  mActivities                                         |    |
|    |             +--------------------------------------+ |    |
|    |             |      +---------------+               | |    |
|    |             |      |    Activity   |               | |    |
|    |             |      +---------------+               | |    |
|    |             |                                      | |    |
|    |             |   +-------------------------------+  | |    |
|    |             |   | lastNonConfigurationInstances |  | |    |
|    |             |   +-------------------------------+  | |    |
|    |             |                                      | |    |
|    |             +--------------------------------------+ |    |
|    |             +--------------------------------------+ |    |
|    |             |                                      | |    |
|    |             |                                      | |    |
|    |             +--------------------------------------+ |    |
|    |             +--------------------------------------+ |    |
|    |             |                                      | |    |
|    |             |                                      | |    |
|    |             +--------------------------------------+ |    |
|    |                                                      |    |
|    |                           ...                        |    |
|    |                                                      |    |
|    +------------------------------------------------------+    |
+----------------------------------------------------------------+

  • 「C2」⬅️「B1」

    传递r给

    // ActivityThread
    private void handleRelaunchActivityInner(ActivityClientRecord r, int configChanges,
            List<ResultInfo> pendingResults, List<ReferrerIntent> pendingIntents,
            PendingTransactionActions pendingActions, boolean startsNotResumed,
            Configuration overrideConfig, String reason) {
        ...
「D1」        handleDestroyActivity(r, false, configChanges, true, reason);
        ...
「D2」        handleLaunchActivity(r, pendingActions, customIntent);
    }

  • 「D1」⬅️「C2」

    ⬇️Destroy原来的Activity，其中getNonConfigInstance传入了true

    // ActivityThread
    @Override
    public void handleDestroyActivity(ActivityClientRecord r, boolean finishing, int configChanges,
            boolean getNonConfigInstance, String reason) {
        performDestroyActivity(r, finishing, configChanges, getNonConfigInstance, reason);
        ...
    }

    ⬇️将原来的activity的nonConfigurationInstances存入ActivityRecord.lastNonConfigurationInstances

    // ActivityThread
    /** Core implementation of activity destroy call. */
    void performDestroyActivity(ActivityClientRecord r, boolean finishing,
            int configChanges, boolean getNonConfigInstance, String reason) {
        ...
    「E1」 if (getNonConfigInstance) {
            ....
            「E2」  r.lastNonConfigurationInstances = r.activity.retainNonConfigurationInstances();
            ....

  • 「E1」这里如果是getNonConfigInstance为true（前面传的是true），

  • 「E2」

    则️将[sC]ActivityClientRecord中放入Java 代码块的结果，其中就包含viewModelStore

     // Activity
    NonConfigurationInstances retainNonConfigurationInstances() {
「F1」 Object activity = onRetainNonConfigurationInstance();
        ...
        NonConfigurationInstances nci = new NonConfigurationInstances();
        nci.activity = activity;
        ....
        return nci;
    }

  • 「F1」Activity默认实现中只返回了null，但是[C]ComponentActivity重写了这个方法⬇️

     // ComponentActivity
    public final Object onRetainNonConfigurationInstance() {
        // Maintain backward compatibility.
「G1」  Object custom = onRetainCustomNonConfigurationInstance();

        ViewModelStore viewModelStore = mViewModelStore;
「G2」  if (viewModelStore == null) {
            ....
        }
        ....

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

  • 「G1」我们可以通过重写onRetainCustomNonConfigurationInstance()创建custom即自定义的在configuration改变后仍然想要保存的数据。

  • 「G2」这里当viewModelStore为空的时候会查看[C]ComponentActivity.NonConfigurationInstances中是否有viewModelStore，这里对应从来没有地方调用过getViewModelStore，也就不会初始化ComponentActivity.mVieModelStore，但是我们这里情况是之前有创建viewmodel，this(owner.viewModelStore, defaultFactory(owner), defaultCreationExtras(owner)) ，这里使用 owner.viewModelStore从ViewModelStoreOwner中取出[OC]ViewModelStore调用过，所有不会走到viewModelStore == null的分支

  • 「G3」这里创建了[C]ComponentActivity.NonConfigurationInstances存入 custom和viewModelStore并返回。

  • 「D2」⬅️「C2」执行LaunchActivity

    // android.app.ActivityThread#handleLaunchActivity
    public Activity handleLaunchActivity(ActivityClientRecord r,
            PendingTransactionActions pendingActions, Intent customIntent) {
        ....
        final Activity a = performLaunchActivity(r, customIntent);
        ....
        return a;
    }

    // android.app.ActivityThread#performLaunchActivity
    private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {
        ....
        Activity activity = null;
        try {
            java.lang.ClassLoader cl = appContext.getClassLoader();
      「H1」 activity = mInstrumentation.newActivity(
                    cl, component.getClassName(), r.intent);
            ....

        try {
            ....
            if (activity != null) {
                ....
        「H2」   activity.attach(appContext, this, getInstrumentation(), r.token,
                        r.ident, app, r.intent, r.activityInfo, title, r.parent,
                        r.embeddedID, r.lastNonConfigurationInstances, config,
                        r.referrer, r.voiceInteractor, window, r.activityConfigCallback,
                        r.assistToken, r.shareableActivityToken);
        ....
        return activity;
    }

  • 「H1」

    实例化一个Activity

  • 「H2」

    使用原来的ActivityRecord给Activity设置参数，其中第12个参数就是在「E2」处保存的lastNonConfigurationInstances，其中就有viewModel

    这里就回答了上面[U2]处的问题，串起来了

reference

lancerXXXX
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【Android进阶】4、用 ViewModel 和 onSaveInstanceState 实现旋转屏幕时 UI 状态的保存和恢复
呆呆的猫的博客
09-14 548
因为ViewModel生命周期 长于 Activity, 故只能短生命周期的Activity 引用 长周期的ViewModel, 而不能反向(否则当某对象引用了即将被销毁的对象时, 会阻止系统gc回收, 就会导致内存泄露)应用进程被销毁后，进程内存里存储的所有对象自然也就随之被销毁了。但是，停止的activity被“杀死”是很正常的事，例如，用户按了主屏幕键，然后播放视频或玩起游戏。每个应用都有自己的进程（更具体地讲，是一个Linux进程），其包含一个执行UI工作的单线程，以及保存对象的一小块内存。
Jetpack架构组件-ViewModel的使用及原理
03-01
Jetpack 架构组件-ViewModel 的使用及原理 Jetpack 架构组件-ViewModel 是 Android 架构组件的一部分，主要用于存储和管理视图相关的数据。ViewModel 顾名思义，是以感知生命周期的形式来存储和管理视图相关的数据...
Android使用ViewModel防止屏幕旋转数据丢失教程
Mero技术博客
05-22 421
2.更新数据，加上这句旋转屏幕的时候会自动进入到匿名observer的回调函数onChanged(）中。第一步：创建ViewModel对象，继承ViewModel子类AndroidViewModel。假如我现在要保存旋转时候的recyclerview里的所有item数据，我该如何做呢？第二步：在Fragment的onCreateView中创建观察者，并且更新数据。由于比较忙，简单记录下个人的ViewModel保存数据使用教程。可以看到有进入到onChanged函数中，此时可以随便更新你的UI。
揭秘ViewModel怎样在屏幕旋转时保存数据
小小马King
09-08 1183
ViewModel的作用及怎样使用 ViewModel使用在MVVM框架中，结合LiveData实现View层和控制层解耦。ViewModel类旨在以注重生命周期的方式存储和管理界面相关的数据，ViewModel作为一个类保存着LiveData类型的数据，这样做的好处在于当Activity因为配置的改变（如屏幕旋转）而重新创建时，界面中所持有的数据能够不被销毁。 对于简单的数据，Activity可以从onCreate()中利用Bundle对象恢复数据，但此方法仅适合可以序列化再反序列化的少量数据， 而不.
android 旋转屏幕 view的调整,Android ViewModel在屏幕旋转时重新创建
weixin_35399228的博客
05-27 377
是的@tomwyr，这是一个来自android框架的bug . Bug details该修复程序在28.0.0-alpha3和AndroidX 1.0.0-alpha3中可用但如果您现在不想更新到上面的版本，那么您可以像这样解决( I know this is a bad solution but I didn't see any other good way )在您的活动中覆盖 onDestr...
view controller 屏幕旋转的总结
gaoyp的专栏
05-19 564
影响当前VC方向的因素有以下几个：1、设备的当前方向。2、Application支持的方向。   可以在info.plist中设置，   在应用启动后，AppDelegate的supportedInterfaceOrientations方法   可以覆盖info.plist中的设置。3、root vc的shouldAutorotate:此方向的含义是指出在设备旋转时，vc是否也跟着旋转。默认是YE...
ViewModel使用基础
02-17
ViewModel使用基础
DataContext 绑定 ViewModel
最新发布
10-21
DataContext 绑定 ViewModel
解决android viewmodel 数据刷新异常的问题
08-19
解决 Android ViewModel 数据刷新异常的问题 Android ViewModel 是 Android 架构组件的一部分，用于存储和管理用户界面相关的数据。然而，在使用 ViewModel 时，可能会遇到数据刷新异常的问题。本文将介绍解决 ...
ViewModel的具体用法
12-27
ViewModel的用法详解，Android开源库JetPack的用法详解
ViewModel:Android体系结构组件-ViewModel示例
05-14
Android体系结构组件：具有联网（改造）示例的ViewModel 待定： 教程文献资料
Viewmodel
03-28
视图模型
ViewModel + LiveData + DataBinding 综合使用示例
04-27
【Jetpack】ViewModel + LiveData + DataBinding 综合使用 ( 核心要点说明 | 组合方式 | 代码示例 ) 博客地址 : https://hanshuliang.blog.csdn.net/article/details/130401679 一、ViewModel + LiveData + ...
Android-ViewModel和LiveData使用详解
08-19
主要介绍了Android-ViewModel和LiveData使用详解，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
ExtJS全局路由+ViewModel
05-11
ExtJS viewmport指定路由，全局配置+ViewModel切换变量
Android jetpack viewModel 屏幕旋转数据如何保存。
丿灬安之若死
05-18 504
解决的问题 瞬态数据的丢失。 异步调用的内存泄露 类膨胀提高维护难度和测试难度。 参考：2021年最全面的Jetpack系统学习课程，看他就够了，更新中_哔哩哔哩_bilibili
ViewModel如何实现手机翻转后仍然能够保存数据
BoldFruit的博客
12-03 668
前言 我们使用mvvm框架时，ViewModel常常用来保存我们的数据，这样做的好处在于当Activity因为配置的改变（如常见的屏幕翻转）而重新创建时，我们的放在ViewModel中的数据仍然能够不被销毁。这样做的好处在于我们不必像以前在OnSaveInstanceState中保存可能因为配置改变而被销毁的变量，然后再在OnCreate中恢复数据。 本片文章我将从源码的角度分析一下Android是如何实现ViewModel在配置改变时不被重建的原理。 代码分析 下面是我们常用的创建ViewModel的方法
【WPF】修改数据层ViewModel后，UI界面未同步更新
weixin_33981932的博客
09-30 2553
界面：WPF（MVVM）中将集合类控件ItemsControl的ItemsSource绑定到了ViewModel中的ObservableCollection列表，ItemsControl.ItemTemplate模板中是一个Image图片控件。 问题：当数据层发生改变，例如列表新增一个元素后，若之后执行的代码想要立即获取到新增图片Image，会发现此时的UI层还未同步更新，不能获取新增的Image...
横竖屏切换时，activity数据保存问题
w1142203475的博客
05-04 259
1. onSaveInstanceState简介 如果系统由于系统约束（而不是正常的应用程序行为）而破坏了Activity，那么尽管实际 Activity实例已经消失，但是系统还是会记住它已经存在，这样如果用户导航回到它，系统会创建一个新的实例的Activity使用一组保存的数据来描述Activity在被销毁时的状态。系统用于恢复以前状态的已保存数据称为“实例状态”，是存储在Bundle对象中的键值对的集合。1.1 onSaveInstanceState简介 a. onSaveInstanceState(B
android屏幕旋转 多个fragment 恢复 viewmodel
05-12
当Android屏幕旋转时，活动将重新创建并重新启动。在这个过程中，任何与视图相关的数据都将丢失。如果您有多个片段，视图模型则可能会丢失。为了恢复视图模型并确保数据的持久性，您必须按照以下步骤进行操作： 第...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值