安卓TabHost中为每个Fragment定制返回栈

Question

自从TabActivity被弃用后，我试图用已经在开发者Android网站上提到的Fragments替换它。 但是正如你们已经知道的，有一个关于用fragment替换选项卡的问题，因为只有一个Fragment Activity活动，所以没有每个片段的后退堆栈，正如你可以在其他SO问题中看到的大多数开发人员所说，你需要管理自己的自定义后退堆栈作为一种解决方案。

如下所示，我创建和实现了自己的自定义后退堆栈，它完美地工作，我可以跟踪每个选项卡中的每个片段。

选项卡1

    Fragment1 > Fragment2 > Fragment3

选项卡2

    Fragment5 > Fragment6

根据上面的导航，在我从Fragment1通过Fragment3进行导航之后，如果我更改选项卡到Tab2并回到Tab1，我仍然可以看到Fragment3，甚至可以使用我的自定义返回堆栈返回到Fragment1。

但问题在于，当我回到Tab1并看到Fragment3时，Fragment3会重新创建，我无法看到我在切换到Tab2之前所留下的更改。

这是我的自定义返回堆栈；

public static HashMap<String, Stack<Fragment>> customBackStack;

public static Stack<Fragment> simpleStack;
public static Stack<Fragment> contactStack;
public static Stack<Fragment> customStack;
public static Stack<Fragment> throttleStack;
public static Stack<Fragment> homeStack;

customBackStack = new HashMap<String, Stack<Fragment>>();

homeStack = new Stack<Fragment>();
simpleStack = new Stack<Fragment>();
contactStack = new Stack<Fragment>();
customStack = new Stack<Fragment>();
throttleStack = new Stack<Fragment>();

customBackStack.put("home", homeStack);
customBackStack.put("simple", simpleStack);
customBackStack.put("contacts", contactStack);
customBackStack.put("custom", customStack);
customBackStack.put("throttle", throttleStack);

这里是onTabChanged方法：

        public void onTabChanged(String tabId) {
        TabInfo newTab = mTabs.get(tabId);
        if (mLastTab != newTab) {
            FragmentTransaction ft = mActivity.getSupportFragmentManager().beginTransaction();
            if (mLastTab != null) {
                if (mLastTab.fragment != null) {
                    ft.detach(mLastTab.fragment);
                }
            }
            if (newTab != null) {
                if (newTab.fragment == null) {
                    if (!customBackStack.get(tabId).isEmpty()) {
                        Fragment fragment = customBackStack.get(tabId).pop();
                        customBackStack.get(tabId).push(fragment);
                        ft.replace(mContainerId, fragment);
                    }
                } else {
                    if (!customBackStack.get(tabId).isEmpty()) {
                        Fragment fragment = customBackStack.get(tabId).pop();
                        customBackStack.get(tabId).push(fragment);
                        ft.replace(mContainerId, fragment);
                    }
                }
            }

            mLastTab = newTab;
            ft.commit();
            mActivity.getSupportFragmentManager().executePendingTransactions();
        }
    }

这里是onBackPressed；

    public void onBackPressed() {

    Stack<Fragment> stack = customBackStack.get(mTabHost.getCurrentTabTag());

    if (stack.isEmpty()) {
        super.onBackPressed();
    } else {

        Fragment fragment = stack.pop();

        if (fragment.isVisible()) {
            if (stack.isEmpty()) {
                super.onBackPressed();
            } else {
                Fragment frg = stack.pop();
                customBackStack.get(mTabHost.getCurrentTabTag()).push(frg);

                transaction = getSupportFragmentManager().beginTransaction();
                transaction.setCustomAnimations(R.anim.slide_in_left, R.anim.slide_out_right,
                        R.anim.slide_in_right, R.anim.slide_out_left);

                transaction.replace(R.id.realtabcontent, frg).commit();
            }
        } else {
            getSupportFragmentManager().beginTransaction().replace(R.id.realtabcontent, fragment).commit();
        }
    }

}

因此，在切换选项卡后，自定义返回栈运行良好，但是在返回到选项卡时，最后一个片段正在重新创建，而不像在选项卡活动中一样恢复。

有什么解决办法吗？

编辑

您可以在此处找到我的示例应用程序，作为解决此问题的解决方案。

GitHub

- osayilgan

---

请查看以下简单的方法来管理片段：这里 - Winston

我们正在一个tabFragment中添加新的fragments... 我们应该如何做到这一点？ - Vikky

你需要遵循相同的结构。因此，如果您想将新的Fragment添加到选项卡中，则需要首先： 1-) 为要添加的每个Fragment创建一个Stack<Fragment>。 2-) 创建一个常量字符串，并将该Fragment与常量字符串一起放入哈希映射（自定义后退堆栈）中。 3-) 然后，您需要向mTabManager添加选项卡。 - osayilgan

在 onTabChanged() 方法中，if(newTab.fragment == null) 的代码和这个条件的 else 部分是相同的。我认为没有必要添加这个条件。 - Houcine

@Houcine 谢谢，我会看一下。可能不需要。 - osayilgan

Answer 1

我修改了谷歌的示例tablistener如下：

public static class TabListener<T extends SherlockFragment> implements ActionBar.TabListener {
    private final SherlockFragmentActivity mActivity;
    private final String mTag;
    private final Class<T> mClass;
    private final Bundle mArgs;
    public SherlockFragment mFragment;
    private final Stack<SherlockFragment> mStack;

    public TabListener(SherlockFragmentActivity activity, String tag, Class<T> clz) {
        this(activity, tag, clz, null, null);
    }

    public TabListener(SherlockFragmentActivity activity, String tag, Class<T> clz, Bundle args, Stack<SherlockFragment> stack) {
        mActivity = activity;
        mTag = tag;
        mClass = clz;
        mArgs = args;
        mStack = stack;

        // Check to see if we already have a fragment for this tab, probably
        // from a previously saved state.  If so, deactivate it, because our
        // initial state is that a tab isn't shown.
        mFragment = (SherlockFragment) mActivity.getSupportFragmentManager().findFragmentByTag(mTag);
        if (mFragment != null && !mFragment.isDetached()) {
            FragmentTransaction ft = mActivity.getSupportFragmentManager().beginTransaction();
            ft.detach(mFragment);
            ft.commit();
        }
    }

    public void onTabSelected(Tab tab, FragmentTransaction ft) {
        // we need to reattach ALL fragments thats in the custom stack, if we don't we'll have problems with setCustomAnimation for fragments.
        if (mFragment == null) {
            mFragment = (SherlockFragment) SherlockFragment.instantiate(mActivity, mClass.getName(), mArgs);
            ft.replace(android.R.id.content, mFragment, mTag);
        } else {
            ft.attach(mFragment);
        }
        if(mStack != null) {
            for(SherlockFragment fragment: mStack) {
                ft.attach(fragment);
            }
        }
    }

    public void onTabUnselected(Tab tab, FragmentTransaction ft) {
        if (mFragment != null) {
            ft.detach(mFragment);
        }
        if(mStack != null) {
            for(SherlockFragment fragment: mStack) {
                if(fragment!= null && !fragment.isDetached()) {
                    ft.detach(fragment);
                }
            }
        }
    }

    public void onTabReselected(Tab tab, FragmentTransaction ft) {
    }
}

我重写了onKeyDown方法如下：

@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
    if (keyCode == KeyEvent.KEYCODE_BACK) {
        int index = getSupportActionBar().getSelectedNavigationIndex();
        Stack<SherlockFragment> stack = null;
        SherlockFragment fragment = null;
        String rootTag = null;
        switch(index) {
            case 0:
                stack = mWatersTabListener.mStack;
                fragment = mWatersTabListener.mFragment;
                rootTag = mWatersTabListener.mTag;
                break;
            case 1:
                stack = mHarborTabListener.mStack;
                fragment = mHarborTabListener.mFragment;
                rootTag = mHarborTabListener.mTag;
                break;
        }

        if(stack.isEmpty()) {
            return super.onKeyDown(keyCode, event);
        } else {
            SherlockFragment topFragment = stack.pop();
            FragmentManager fragmentManager = getSupportFragmentManager();

            FragmentTransaction ft = fragmentManager.beginTransaction();

            ft.setCustomAnimations(R.anim.fragment_slide_right_enter,
                    R.anim.fragment_slide_right_exit);

            if(topFragment != null && !topFragment.isDetached()) {
                ft.detach(topFragment);
            }

            if(stack.isEmpty()) {
                ft.replace(android.R.id.content, fragment, rootTag);
                ft.commit();
                return true;
            } else {
                SherlockFragment nextFragment = stack.peek();
                ft.replace(android.R.id.content, nextFragment);
                ft.commit();
                return true;
            }
        }
    }
    return super.onKeyDown(keyCode, event);
}

重要的事情需要注意的是，当选择时，您必须将自定义堆栈中的所有片段附加，并在取消选择时将所有片段分离。如果对代码片段的理解存在问题，请随时提问。

- Warpzit

---

感谢您的答复，我在我的代码中也在做同样的事情。问题是，如果我将选项卡切换回先前打开的片段，则会重新创建该片段。因此，我无法保存片段的实例状态。有任何想法吗？你的情况也一样吗？ - osayilgan

@osayilgan，这个问题在我的代码中并没有出现，我无法确定为什么你的方案会有这种行为，因为你使用了不同的监听器（onChange）。但是我遇到的问题是，在切换到不同的选项卡时，每个片段都得重新添加（附加）。 - Warpzit

很好，我会看一下你和我的区别，这可能会有用。谢谢回答。 - osayilgan

@osayilgan 如果能帮到其他人，我会很高兴。 - Warpzit