关于android：一劳永逸，如何在后台堆栈中正确保存Fragments的实例状态？

Once for all, how to correctly save instance state of Fragments in back stack?

我在SO上发现了许多类似问题的实例，但遗憾的是没有答案符合我的要求。

我有纵向和横向的不同布局，我正在使用后台堆栈，这两个都阻止我使用配置更改例程使用setRetainState()和技巧。

我在TextViews中向用户显示某些信息，这些信息不会保存在默认处理程序中。仅使用活动编写我的应用程序时，以下工作正常：

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

TextView vstup;

@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.whatever);
vstup = (TextView)findViewById(R.id.whatever);
/* (...) */
}

@Override
public void onSaveInstanceState(Bundle state) {
super.onSaveInstanceState(state);
state.putCharSequence(App.VSTUP, vstup.getText());
}

@Override
public void onRestoreInstanceState(Bundle state) {
super.onRestoreInstanceState(state);
vstup.setText(state.getCharSequence(App.VSTUP));
}

使用Fragment s，这仅适用于非常特定的情况。具体来说，可怕的破坏是替换片段，将其放入后栈，然后在显示新片段时旋转屏幕。根据我的理解，旧片段在被替换时不会接收到对onSaveInstanceState()的调用，但保持某种方式与Activity相关联，并且此方法稍后在其View不再存在时调用，因此寻找任何我的TextView s结果为NullPointerException。

另外，我发现保持对TextViews的引用对于Fragment来说并不是一个好主意，即使它与Activity一样正常。在这种情况下，onSaveInstanceState()实际上保存了状态但是如果我在隐藏片段时旋转屏幕两次，则问题会重新出现，因为在新实例中不会调用onCreateView()。

我想把onDestroyView()中的状态保存到某个Bundle类型的成员元素中(它实际上是更多数据，而不仅仅是一个TextView)并将其保存在onSaveInstanceState()中，但还有其他缺点。首先，如果当前显示片段，则调用这两个函数的顺序是相反的，因此我需要考虑两种不同的情况。必须有一个更清洁，更正确的解决方案！

相关讨论

要正确保存Fragment的实例状态，您应该执行以下操作：

1.在片段中，通过覆盖onSaveInstanceState()保存实例状态并在onActivityCreated()中恢复：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

@Override
public void onActivityCreated(Bundle savedInstanceState) {
super.onActivityCreated(savedInstanceState);
...
if (savedInstanceState != null) {
//Restore the fragment's state here
}
}
...
@Override
public void onSaveInstanceState(Bundle outState) {
super.onSaveInstanceState(outState);

//Save the fragment's state here
}

2.重要的是，在活动中，您必须将片段的实例保存在onSaveInstanceState()中并在onCreate()中恢复。

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

public void onCreate(Bundle savedInstanceState) {
...
if (savedInstanceState != null) {
//Restore the fragment's instance
mContent = getSupportFragmentManager().getFragment(savedInstanceState,"myFragmentName");
...
}
...
}

@Override
protected void onSaveInstanceState(Bundle outState) {
super.onSaveInstanceState(outState);

//Save the fragment's instance
getSupportFragmentManager().putFragment(outState,"myFragmentName", mContent);
}

希望这可以帮助。

相关讨论

这对我来说非常合适！没有变通方法，没有黑客攻击，只是这样才有意义。谢谢你，成功搜索了几个小时。在片段中保存值的SaveInstanceState()，然后将片段保存在包含片段的Activity中，然后恢复:)
什么是mContent？
@wizurd mContent是一个Fragment，它引用了活动中当前片段的实例。
如果您有可能存在或不存在的片段(创建，销毁或由用户操作替换)，您可以在Activity的onCreate，if(savedInstanceState != null)中执行此操作：if(savedInstanceState.containsKey(FRAG_TAG))){ frag1 = (FragOne)getFragmentManager().getFragment(savedInstanceState, FRAG_TAG);
可能必须从getFragment()，即mContent = (ContentFragment)getSupportFragmentManager().getFragment(savedInstanceState,"mContent");投出回报
在方向改变之后，它不存储后堆栈中的片段
你能解释一下这将如何保存后端堆栈中片段的实例状态吗？这就是OP所要求的。
有人可以解释这个答案与保存在backstack中的片段状态有什么关系？
这与问题无关，当片段被放到backstack时不会调用onSaveInstance
为什么我们需要在activity的onSaveInstanceState和onCreate中工作？将片段调用super将不会自动执行。
@ThanhHH在mContent中恢复片段实例后，mContent在哪里进一步使用？
你不应该调用super.onSaveInstanceState(outState);用你的商店参数更新你的州后？
如果正确创建片段，则不需要这样做。当savedInstanceState为null时，应创建片段。否则，您将恢复片段，但它将被替换为一个全新的片段
只有第二点足以保存片段状态。
感谢您提及putFragment和getFragment一千次。那些方法还不够出名！
但是如果你在viewpager中使用它会怎么样呢
我认为片段的变量应该在onCreate中恢复而不是在onActivityCreated中恢复。事实上，有些情况下没有调用onActivityCreated(即片段被恢复但是在BackStack中)但你需要正确恢复你的vars。
是不是setRetainInstance(true)保存片段实例状态？是否需要为片段调用onSaveInstanceState？
是否有理由使用Activity的onCreate()而不是onRestoreInstanceState()？
我不认为你需要＃2来保存片段中的基本数据。请参阅链接inthecheesefactory.com/blog/…
@OliverDixon stackoverflow.com/a/29288093/421467
很好的答案。坚持这么久。谢谢
当我这样做时，我得到java.lang.RuntimeException: Unable to start activity ComponentInfo{my.app/my.app.MyActivity}: java.lang.IllegalStateException: Fragment no longer exists for key myFragmentName: index 0。我该如何解决这个问题？
你可以编辑和清除mContent
为什么onActivityCreated而不是onCreate？

这就是我现在使用的方式......它非常复杂但至少它可以处理所有可能的情况。如果有人有兴趣。

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

public final class MyFragment extends Fragment {
private TextView vstup;
private Bundle savedState = null;

@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
View v = inflater.inflate(R.layout.whatever, null);
vstup = (TextView)v.findViewById(R.id.whatever);

/* (...) */

/* If the Fragment was destroyed inbetween (screen rotation), we need to recover the savedState first */
/* However, if it was not, it stays in the instance from the last onDestroyView() and we don't want to overwrite it */
if(savedInstanceState != null && savedState == null) {
savedState = savedInstanceState.getBundle(App.STAV);
}
if(savedState != null) {
vstup.setText(savedState.getCharSequence(App.VSTUP));
}
savedState = null;

return v;
}

@Override
public void onDestroyView() {
super.onDestroyView();
savedState = saveState(); /* vstup defined here for sure */
vstup = null;
}

private Bundle saveState() { /* called either from onDestroyView() or onSaveInstanceState() */
Bundle state = new Bundle();
state.putCharSequence(App.VSTUP, vstup.getText());
return state;
}

@Override
public void onSaveInstanceState(Bundle outState) {
super.onSaveInstanceState(outState);
/* If onDestroyView() is called first, we can use the previously savedState but we can't call saveState() anymore */
/* If onSaveInstanceState() is called first, we don't have savedState, so we need to call saveState() */
/* => (?:) operator inevitable! */
outState.putBundle(App.STAV, (savedState != null) ? savedState : saveState());
}

/* (...) */

}

或者，始终可以将数据显示在变量中的被动View中，并仅使用View来显示它们，从而保持两者同步。不过，我不认为最后一部分很干净。

相关讨论

在最新的支持库中，这里讨论的解决方案都不再是必需的。您可以使用FragmentTransaction随意播放Activity的片段。只需确保您的片段可以使用ID或标记进行标识。

只要您不在每次调用onCreate()时尝试重新创建片段，片段都将自动恢复。相反，您应检查savedInstanceState是否为null，并在此情况下查找对已创建片段的旧引用。

这是一个例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);

if (savedInstanceState == null) {
myFragment = MyFragment.newInstance();
getSupportFragmentManager()
.beginTransaction()
.add(R.id.my_container, myFragment, MY_FRAGMENT_TAG)
.commit();
} else {
myFragment = (MyFragment) getSupportFragmentManager()
.findFragmentByTag(MY_FRAGMENT_TAG);
}
...
}

但请注意，恢复片段的隐藏状态时存在错误。如果要在活动中隐藏片段，则需要在这种情况下手动恢复此状态。

相关讨论

我只想提供我想出的解决方案来处理本文中我从Vasek和devconsole派生的所有案例。此解决方案还可以处理特殊情况，当手机不能一次旋转而片段不可见时。

这是我存储捆绑以供以后使用，因为onCreate和onSaveInstanceState是片段不可见时唯一的调用

1
2
3
4
5
6
7
8
9
10
11
12

MyObject myObject;
private Bundle savedState = null;
private boolean createdStateInDestroyView;
private static final String SAVED_BUNDLE_TAG ="saved_bundle";

@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
if (savedInstanceState != null) {
savedState = savedInstanceState.getBundle(SAVED_BUNDLE_TAG);
}
}

由于在特殊旋转情况下不调用destroyView，我们可以确定如果它创建状态我们应该使用它。

1
2
3
4
5
6
7

@Override
public void onDestroyView() {
super.onDestroyView();
savedState = saveState();
createdStateInDestroyView = true;
myObject = null;
}

这部分是一样的。

1
2
3
4
5

private Bundle saveState() {
Bundle state = new Bundle();
state.putSerializable(SAVED_BUNDLE_TAG, myObject);
return state;
}

现在这里是棘手的部分。在我的onActivityCreated方法中，我实例化了"myObject"变量，但是onActivity和onCreateView上的旋转都没有被调用。因此，当方向旋转多次时，myObject在这种情况下将为null。我通过重复使用onCreate中保存的相同包作为外包来解决这个问题。

1
2
3
4
5
6
7
8
9
10
11

@Override
public void onSaveInstanceState(Bundle outState) {

if (myObject == null) {
outState.putBundle(SAVED_BUNDLE_TAG, savedState);
} else {
outState.putBundle(SAVED_BUNDLE_TAG, createdStateInDestroyView ? savedState : saveState());
}
createdStateInDestroyView = false;
super.onSaveInstanceState(outState);
}

现在，只要您想要恢复状态，只需使用savedState包

1
2
3
4
5
6
7
8

@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
...
if(savedState != null) {
myObject = (MyObject) savedState.getSerializable(SAVED_BUNDLE_TAG);
}
...
}

相关讨论

感谢DroidT，我做了这个：

我意识到如果Fragment没有执行onCreateView()，它的视图就不会被实例化。因此，如果后端堆栈上的片段没有创建其视图，我保存最后存储的状态，否则我使用我想要保存/恢复的数据构建自己的包。

1)扩展此课程：

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

import android.os.Bundle;
import android.support.v4.app.Fragment;

public abstract class StatefulFragment extends Fragment {

private Bundle savedState;
private boolean saved;
private static final String _FRAGMENT_STATE ="FRAGMENT_STATE";

@Override
public void onSaveInstanceState(Bundle state) {
if (getView() == null) {
state.putBundle(_FRAGMENT_STATE, savedState);
} else {
Bundle bundle = saved ? savedState : getStateToSave();

state.putBundle(_FRAGMENT_STATE, bundle);
}

saved = false;

super.onSaveInstanceState(state);
}

@Override
public void onCreate(Bundle state) {
super.onCreate(state);

if (state != null) {
savedState = state.getBundle(_FRAGMENT_STATE);
}
}

@Override
public void onDestroyView() {
savedState = getStateToSave();
saved = true;

super.onDestroyView();
}

protected Bundle getSavedState() {
return savedState;
}

protected abstract boolean hasSavedState();

protected abstract Bundle getStateToSave();

}

2)在你的片段中，你必须有：

1
2
3
4
5
6
7
8
9
10
11
12

@Override
protected boolean hasSavedState() {
Bundle state = getSavedState();

if (state == null) {
return false;
}

//restore your data here

return true;
}

3)例如，您可以在onActivityCreated中调用hasSavedState：

1
2
3
4
5
6
7
8
9
10

@Override
public void onActivityCreated(Bundle state) {
super.onActivityCreated(state);

if (hasSavedState()) {
return;
}

//your code here
}

1
2
3
4
5

final FragmentTransaction ft = getFragmentManager().beginTransaction();
ft.hide(currentFragment);
ft.add(R.id.content_frame, newFragment.newInstance(context),"Profile");
ft.addToBackStack(null);
ft.commit();

相关讨论