33

我通过隐藏最后一个片段并添加一个新片段（参见下面的代码）在片段之间切换 - 也将其添加到后台堆栈。这样，用户可以在 Fragment 之间快速切换，而无需重新加载 Fragment 数据。

这在应用程序被终止之前运行良好（场景：用户使用其他几个应用程序并且我的应用程序被持久化并被终止）。

当用户打开应用程序时，它正在被恢复并显示所有片段 -彼此重叠。

问题：恢复的碎片如何恢复其隐藏状态？也许我错过了一些标志？某处？也许有更好的解决方案可以在片段之间快速切换（无需重新加载数据）？

添加片段的示例代码 - 单击某处时使用不同的片段多次调用：

FragmentTransaction fragmentTransaction = getFragmentManager().beginTransaction();
fragmentTransaction.hide(lastFragment);
fragmentTransaction.add(newFragment);
fragmentTransaction.addToBackStack(null);
fragmentTransaction.commit();
lastFragment = newFragment;
4

7 回答 7

16

希望有人找到更好的解决方案。在我接受我的解决方案之前，我会等待一个：

一般来说，我使用生成的标签来查找未隐藏的片段并隐藏它们。

具体来说，我为每个片段（StackEntry）生成一个唯一的标签，并在片段本身堆叠时堆叠标签。我将堆栈保留在捆绑包中，并在应用程序恢复时加载它以继续使用它。然后我使用标签列表找到所有未隐藏的片段并将它们隐藏——除了最后一个。

继承人示例代码：

public class FragmentActivity extends Activity {

    private static final String FRAGMENT_STACK_KEY = "FRAGMENT_STACK_KEY";

    private Stack<StackEntry> fragmentsStack = new Stack<StackEntry>();

    public FragmentActivity() {
    }

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

        setContentView(R.layout.content_frame);

        if (savedInstanceState == null) {
            // Init for the first time - not restore
            // ...
        } else {
            Serializable serializable = savedInstanceState.getSerializable(FRAGMENT_STACK_KEY);
            if (serializable != null) {
                // Workaround Android bug.
                // See: http://stackoverflow.com/questions/13982192/when-using-an-android-bundle-why-does-a-serialised-stack-deserialise-as-an-arra
                // And: https://code.google.com/p/android/issues/detail?id=3847
                @SuppressWarnings("unchecked")
                List<StackEntry> arrayList = (List<StackEntry>) serializable;
                fragmentsStack = new Stack<StackEntry>();
                fragmentsStack.addAll(arrayList);
            }

            // Hide all the restored fragments instead of the last one
            if (fragmentsStack.size() > 1) {
                FragmentTransaction fragmentTransaction = getFragmentManager().beginTransaction();
                for (int i = 0; i < fragmentsStack.size()-1; i++) {
                    String fragTag = fragmentsStack.get(i).getFragTag();
                    Fragment fragment = getFragmentManager().findFragmentByTag(fragTag);
                    fragmentTransaction.hide(fragment);
                }
                fragmentTransaction.commit();
            }
        }
        getFragmentManager().addOnBackStackChangedListener(new OnBackStackChangedListener() {
            @Override
            public void onBackStackChanged() {
                Fragment lastFragment = getLastFragment();
                if (lastFragment.isHidden()) {
                    FragmentTransaction fragmentTransaction = getFragmentManager().beginTransaction();
                    fragmentTransaction.show(lastFragment);
                    fragmentTransaction.commit();
                }
            }
        });
    }

    private Fragment getLastFragment() {
        if (fragmentsStack.isEmpty()) return null;
        String fragTag = fragmentsStack.peek().getFragTag();
        Fragment fragment = getFragmentManager().findFragmentByTag(fragTag);
        return fragment;
    }

    @Override
    protected void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);
        outState.putSerializable(FRAGMENT_STACK_KEY, fragmentsStack);
    }

    @Override
    public void onBackPressed() {
        if (!fragmentsStack.isEmpty()) {
            fragmentsStack.pop();
        }
    }

    public void switchContent(Fragment fragment) {
        FragmentTransaction fragmentTransaction = getFragmentManager().beginTransaction();
        Fragment lastFragment = getLastFragment();
        if (lastFragment != null) {
            fragmentTransaction.hide(lastFragment);
        }
        String fragTag;
        if (fragment.isAdded()) {
            fragmentTransaction.show(fragment);
            fragTag = fragment.getTag();
        } else {
            fragTag = Long.toString(System.currentTimeMillis());
            fragmentTransaction.add(R.id.content_frame, fragment, fragTag);
        }
        if (!isFirstFragment()) {
            // Add to backstack only the first content fragment and not the state before (that has nothing)
            fragmentTransaction.addToBackStack(null);
        }
        fragmentTransaction.commit();

        fragmentsStack.push(new StackEntry(fragTag));
    }

    public boolean isFirstFragment() {
        return fragmentsStack.size() == 0;
    }

    private static class StackEntry implements Serializable {
        private static final long serialVersionUID = -6162805540320628024L;

        private String fragTag = null;
        public StackEntry(String fragTag) {
            super();
            this.fragTag = fragTag;
        }
        public String getFragTag() {
            return fragTag;
        }
    }


    public static class Intent extends android.content.Intent {
        public Intent(Context packageContext) {
            super(packageContext, FragmentActivity.class);
        }
    }
}
于 2013-04-25T17:14:48.440 回答
9

我也遇到了这个问题，这是一个可能的解决方案：让每个片段保存自己的状态关于它是否被隐藏，然后将自己隐藏在它的 onCreate 中。

@Override
public void onSaveInstanceState(Bundle bundle) {
    super.onSaveInstanceState(bundle);
    if (this.isHidden()) {
        bundle.putBoolean("hidden",  true);
    }
}

@Override
public void onCreate(Bundle bundle) {
    super.onCreate(bundle);
    if (bundle != null) {
        if (bundle.getBoolean("hidden",  false)) {
            getFragmentManager()
                .beginTransaction()
                .hide(this)
                .commit();
        }
    }
}
于 2013-11-15T04:07:37.153 回答
3

最后，我找到了解决此问题的最简单方法：将 content_frame 从 FramLayout 更改为 LinearLayout。

于 2015-04-07T02:17:30.790 回答
1

我有同样的问题，并通过设置每个片段setRetainInstance(true);的方法来解决它。onCreate()

于 2013-10-18T11:54:11.687 回答
1

既然您提到您不介意从头开始重新加载片段，为什么不使用意图并重新启动主要片段活动呢？

我遇到了与您提到的相同的问题，其中片段彼此重叠。我查看了整个stackoverflow，发现只有这个讨论这个特定问题的线程。我尝试了Walt提供的解决方案，但没有按预期工作。

下面的解决方法至少对我有用，所以如果有人最终遇到这种情况，请分享它

在父片段的onSaveInstanceState处，我设置了一个标记以确保包中保存了一些内容。

public void onSaveInstanceState(Bundle outState) 
{
    // TODO Auto-generated method stub
    super.onSaveInstanceState(outState);

    outState.putString(TAG, "Get ready to be terminated");
};

在 onCreate 中，当保存的实例状态不为空时，您可以使用 Intent 指定要加载的类，

@Override
protected void onCreate(Bundle savedInstanceState)
{       
    super.onCreate(savedInstanceState);
    this.setContentView(R.layout.layout);

    if(savedInstanceState != null)
    {   
        Intent myIntent = new Intent(this, your.class);

        // Closing the parent fragment
        finish();

        this.startActivity(myIntent);
    }
    else
    {
        // your main code
        ...........
        ...........
    };
};

这将确保您的片段是从头开始重新创建的。

在我的情况下，当用户打开我的应用程序时，我有一个登录屏幕，如果他们在被重定向到片段屏幕之前已经“登录”。

在终止过程中，一旦应用程序进入前台，我会将用户重定向到登录页面，然后我已经存在的代码负责将用户再次重定向回新创建的片段屏幕。

注意：您需要确保您的子片段在onCreateView没有松散的结尾。

于 2014-11-07T19:38:38.210 回答
1

我有同样的问题。不幸的是，唯一好的解决方案是切换到使用fragmentTransaction.replace而不是fragmentTransaction.hide添加。

当时它很糟糕，但我真的很高兴我做到了。它迫使我思考savedInstanceState并妥善处理它。您提到在导航返回时会重新加载片段。我遇到了完全相同的问题，迫使我savedInstanceState正确处理。那里有2个案例。

  1. 如果活动没有被破坏，唯一需要重新创建的是视图（通过onCreateView），其他所有东西都还在内存中，所以这只是一个将适配器连接到视图的问题，你就完成了。

  2. 如果活动被破坏，我需要重新创建视图和适配器。为了最小化加载时间，我将重新创建适配器所需的数据存储在savedInstanceState

但是，您的抱怨是有效的，我不知道为什么 Android 不支持从带有使用添加和隐藏的片段的已破坏 Activity 返回正确的隐藏状态。

于 2013-11-27T12:58:45.560 回答
0

我遇到了同样的问题，我认为这是 Android 框架错误。这就是问题所在。

但是我的方法对你有用，我们应该重写该onSaveInstanceState(Bundle outState)方法，将我们的自定义数据保存到outState，但永远不要调用super.onSaveInstanceState(outState);。

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

    if (savedInstanceState != null) {
        mCustomVariable = savedInstanceState.getInt("variable", 0);
    }
}

@Override
protected void onSaveInstanceState(Bundle outState) {
    //super.onSaveInstanceState(outState);
    outState.putInt("variable", mCustomVariable);
}
于 2015-10-10T09:53:06.590 回答