1
2
3
4
5
6
7
8

@CallSuper
override fun onSaveInstanceState(outState: Bundle) {
    if (lifecycle is LifecycleRegistry) {
        (lifecycle as LifecycleRegistry).currentState = Lifecycle.State.CREATED
    }
    super.onSaveInstanceState(outState)
    savedStateRegistryController.performSave(outState)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

    /**
     * An interface for an owner of this [SavedStateRegistry] to perform state saving, it will call
     * all registered providers and merge with unconsumed state.
     *
     * @param outBundle SavedState in which to place a saved state
     */
    @MainThread
    internal fun performSave(outBundle: SavedState) {
        val inState = savedState {
            restoredState?.let { putAll(it) }
            synchronized(lock) {
                for ((key, provider) in keyToProviders) {
                    putSavedState(key, provider.saveState())
                }
            }
        }

        if (inState.read { !isEmpty() }) {
            outBundle.write { putSavedState(SAVED_COMPONENTS_KEY, inState) }
        }
    }

1
2
3
4
5

getSavedStateRegistry().registerSavedStateProvider(LIFECYCLE_TAG, () -> {
    markFragmentsCreated();
    mFragmentLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_STOP);
    return new Bundle();
});

1
2
3
4
5
6

SavedStateRegistry registry =
                    ((SavedStateRegistryOwner) mHost).getSavedStateRegistry();
registry.registerSavedStateProvider(SAVED_STATE_KEY, () -> {
        return saveAllStateInternal();
    }
);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

# FragmentStateManager.java
    @NonNull
    Bundle saveState() {
        Bundle stateBundle = new Bundle();
        if (mFragment.mState == Fragment.INITIALIZING) {
            // We never even got to ATTACHED, but we could still have some state
            // set by setInitialSavedState so we'll add that to our initial Bundle
            if (mFragment.mSavedFragmentState != null) {
                stateBundle.putAll(mFragment.mSavedFragmentState);
            }
        }

        // Save the library state associated with the Fragment
        FragmentState fs = new FragmentState(mFragment);
        stateBundle.putParcelable(FRAGMENT_STATE_KEY, fs);

        // Save the user state associated with the Fragment
        if (mFragment.mState > Fragment.INITIALIZING) {
            Bundle savedInstanceState = new Bundle();
            mFragment.performSaveInstanceState(savedInstanceState);
            if (!savedInstanceState.isEmpty()) {
                stateBundle.putBundle(SAVED_INSTANCE_STATE_KEY, savedInstanceState);
            }
            mDispatcher.dispatchOnFragmentSaveInstanceState(mFragment, savedInstanceState, false);

            Bundle savedStateRegistryState = new Bundle();
            mFragment.mSavedStateRegistryController.performSave(savedStateRegistryState);
            if (!savedStateRegistryState.isEmpty()) {
                stateBundle.putBundle(REGISTRY_STATE_KEY, savedStateRegistryState);
            }

            Bundle childFragmentManagerState =
                    mFragment.mChildFragmentManager.saveAllStateInternal();
            if (!childFragmentManagerState.isEmpty()) {
                stateBundle.putBundle(CHILD_FRAGMENT_MANAGER_KEY, childFragmentManagerState);
            }

            if (mFragment.mView != null) {
                saveViewState();
            }
            if (mFragment.mSavedViewState != null) {
                stateBundle.putSparseParcelableArray(VIEW_STATE_KEY, mFragment.mSavedViewState);
            }
            if (mFragment.mSavedViewRegistryState != null) {
                stateBundle.putBundle(VIEW_REGISTRY_STATE_KEY, mFragment.mSavedViewRegistryState);
            }
        }

        if (mFragment.mArguments != null) {
            stateBundle.putBundle(ARGUMENTS_KEY, mFragment.mArguments);
        }
        return stateBundle;
    }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

// FragmentStateManager.java
    /**
     * Recreate a FragmentStateManager from a FragmentState instance, instantiating
     * a new Fragment from the {@link FragmentFactory}.
     *
     * @param dispatcher Dispatcher for any lifecycle callbacks triggered by this class
     * @param fragmentStore FragmentStore handling all Fragments
     * @param classLoader ClassLoader used to instantiate the Fragment
     * @param fragmentFactory FragmentFactory used to instantiate the Fragment
     * @param state Bundle used to restore the state correctly
     */
    @SuppressWarnings("deprecation")
    FragmentStateManager(@NonNull FragmentLifecycleCallbacksDispatcher dispatcher,
            @NonNull FragmentStore fragmentStore,
            @NonNull ClassLoader classLoader,
            @NonNull FragmentFactory fragmentFactory,
            @NonNull Bundle state) {
        mDispatcher = dispatcher;
        mFragmentStore = fragmentStore;

        // Instantiate the fragment's library states in FragmentState
        FragmentState fs = state.getParcelable(FRAGMENT_STATE_KEY);
        mFragment = fs.instantiate(fragmentFactory, classLoader);
        mFragment.mSavedFragmentState = state;

        // Instantiate the fragment's arguments
        Bundle arguments = state.getBundle(ARGUMENTS_KEY);
        if (arguments != null) {
            arguments.setClassLoader(classLoader);
        }
        mFragment.setArguments(arguments);

        if (FragmentManager.isLoggingEnabled(Log.VERBOSE)) {
            Log.v(TAG, "Instantiated fragment " + mFragment);
        }
    }

// FragmentState.java
    /**
     * Instantiates the Fragment from this state.
     */
    @NonNull
    @SuppressWarnings("deprecation")
    Fragment instantiate(@NonNull FragmentFactory fragmentFactory,
            @NonNull ClassLoader classLoader) {
        Fragment fragment = fragmentFactory.instantiate(classLoader, mClassName);
        fragment.mWho = mWho;
        fragment.mFromLayout = mFromLayout;
        fragment.mRestored = true;
        fragment.mFragmentId = mFragmentId;
        fragment.mContainerId = mContainerId;
        fragment.mTag = mTag;
        fragment.mRetainInstance = mRetainInstance;
        fragment.mRemoving = mRemoving;
        fragment.mDetached = mDetached;
        fragment.mHidden = mHidden;
        fragment.mMaxState = Lifecycle.State.values()[mMaxLifecycleState];
        fragment.mTargetWho = mTargetWho;
        fragment.mTargetRequestCode = mTargetRequestCode;
        fragment.mUserVisibleHint = mUserVisibleHint;
        return fragment;
    }

    // FragmentFactory.java
        /**
     * Create a new instance of a Fragment with the given class name. This uses
     * {@link #loadFragmentClass(ClassLoader, String)} and the empty
     * constructor of the resulting Class by default.
     *
     * @param classLoader The default classloader to use for instantiation
     * @param className The class name of the fragment to instantiate.
     * @return Returns a new fragment instance.
     * @throws Fragment.InstantiationException If there is a failure in instantiating
     * the given fragment class.  This is a runtime exception; it is not
     * normally expected to happen.
     */
    @NonNull
    public Fragment instantiate(@NonNull ClassLoader classLoader, @NonNull String className) {
        try {
            Class<? extends Fragment> cls = loadFragmentClass(classLoader, className);
            return cls.getConstructor().newInstance();
        } catch (java.lang.InstantiationException e) {
            throw new Fragment.InstantiationException("Unable to instantiate fragment " + className
                    + ": make sure class name exists, is public, and has an"
                    + " empty constructor that is public", e);
        } catch (IllegalAccessException e) {
            throw new Fragment.InstantiationException("Unable to instantiate fragment " + className
                    + ": make sure class name exists, is public, and has an"
                    + " empty constructor that is public", e);
        } catch (NoSuchMethodException e) {
            throw new Fragment.InstantiationException("Unable to instantiate fragment " + className
                    + ": could not find Fragment constructor", e);
        } catch (InvocationTargetException e) {
            throw new Fragment.InstantiationException("Unable to instantiate fragment " + className
                    + ": calling Fragment constructor caused an exception", e);
        }
    }