双片段旋转Android与ActionBar

Question

我已经创建了一个简单的Android Activity，并使用ActionBar来切换两个片段。直到我旋转设备为止，一切都很好。事实上，当我旋转时，我得到了两个重叠的片段：之前处于活动状态的片段和第一个片段。为什么？如果旋转销毁并重新创建我的Activity，为什么我会得到2个片段？

示例代码：

Activity

package rb.rfrag.namespace;

import android.app.ActionBar;
import android.app.ActionBar.Tab;
import android.app.Activity;
import android.os.Bundle;

    public class RFragActivity extends Activity {
    /** Called when the activity is first created. */
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        // Notice that setContentView() is not used, because we use the root
        // android.R.id.content as the container for each fragment

     // setup action bar for tabs
        final ActionBar actionBar = getActionBar();
        actionBar.setNavigationMode(ActionBar.NAVIGATION_MODE_TABS);
        //actionBar.setDisplayShowTitleEnabled(false);

        Tab tab;
        tab = actionBar.newTab()
                .setText(R.string.VarsTab)
                .setTabListener(new TabListener<VarValues>(
                        this, "VarValues", VarValues.class));
        actionBar.addTab(tab);

        tab = actionBar.newTab()
                .setText(R.string.SecTab)
                .setTabListener(new TabListener<SecFrag>(
                        this, "SecFrag", SecFrag.class));
        actionBar.addTab(tab);
    }
}

TabListener

package rb.rfrag.namespace;

import android.app.ActionBar;
import android.app.Activity;
import android.app.Fragment;
import android.app.FragmentManager;
import android.app.FragmentTransaction;
import android.app.ActionBar.Tab;

public class TabListener<T extends Fragment> implements ActionBar.TabListener {
    private Fragment mFragment;
    private final Activity mActivity;
    private final String mTag;
    private final Class<T> mClass;

    /** Constructor used each time a new tab is created.
      * @param activity  The host Activity, used to instantiate the fragment
      * @param tag  The identifier tag for the fragment
      * @param clz  The fragment's Class, used to instantiate the fragment
      */
    public TabListener(Activity activity, String tag, Class<T> clz) {
        mActivity = activity;
        mTag = tag;
        mClass = clz;
    }

    /* The following are each of the ActionBar.TabListener callbacks */

    public void onTabSelected(Tab tab, FragmentTransaction ft) {    
        // Check if the fragment is already initialized
        if (mFragment == null) {
            // If not, instantiate and add it to the activity
            mFragment = Fragment.instantiate(mActivity, mClass.getName());
            ft.add(android.R.id.content, mFragment, mTag);
        } else {
            // If it exists, simply attach it in order to show it
            ft.attach(mFragment);
        }
    }

    public void onTabUnselected(Tab tab, FragmentTransaction ft) {
        if (mFragment != null) {
            // Detach the fragment, because another one is being attached
            ft.detach(mFragment);
        }
    }
}

- asclepix

Answer 1

我已经使用onSaveInstanceState和onRestoreInstanceState在Activity中来保持所选标签，并修改onTabSelected如下。

最后一次修改避免了Android重新构建它没有销毁的Fragment。但是，我不明白为什么旋转事件会摧毁Activity，而当前的Fragment却没有。（您对此有什么想法吗？）

public void onTabSelected(Tab tab, FragmentTransaction ft) {
        // previous Fragment management
        Fragment prevFragment;
        FragmentManager fm = mActivity.getFragmentManager();
        prevFragment = fm.findFragmentByTag(mTag); 
        if (prevFragment != null) { 
            mFragment = prevFragment; 
        } // \previous Fragment management

        // Check if the fragment is already initialized
        if (mFragment == null) {
            // If not, instantiate and add it to the activity
            mFragment = Fragment.instantiate(mActivity, mClass.getName());
            ft.add(android.R.id.content, mFragment, mTag);
        } else {
            // If it exists, simply attach it in order to show it
            ft.attach(mFragment);
        }
    }

- asclepix

---

这个完美地运行了。有没有线索表明这是做事情的“正确”方式？ - Miguel Moll

找到这个之前，我被这个问题困扰了很久……非常感谢你的答案！（我仍然难以相信Google没有在他们的示例中修复它） - Patrick

有趣。只有我在竖屏时使用了 android.support.v4.view.ViewPager 并在横屏时同时显示两个片段。旋转两次后，我在横屏模式下得到了两个片段。其中一个被称为 android:switcher:2131099773:1 — 让我感到很烦恼。我必须找到一个方法来摆脱这个僵尸。 - Martin

经过大量的研究和开发，这也解决了我的问题 :) 谢谢 @asclepix - Shiv

我不理解这个。当设备旋转时，确实会在片段上调用onDestroy()。那么它怎么还能继续使用和可见呢？ - Nilzor

运行得很好！有人知道为什么官方文档中的示例不能工作吗？我们都做错了什么吗？ - ValarDohaeris

Answer 2

因为我使用了一个android.support.v4.view.ViewPager，重写onTabSelected没有用。但是你的提示仍然指引我朝着正确的方向。

android.support.v4.app.FragmentManager将所有片段保存在android.support.v4.app.FragmentActivity的onSaveInstanceState中。忽略setRetainInstance——根据您的设计，这可能会导致重复的片段。

最简单的解决方法是在活动的orCreate中删除已保存的片段：

   @Override
   public void onCreate (final android.os.Bundle savedInstanceState)
   {
      if (savedInstanceState != null)
      {
         savedInstanceState.remove ("android:support:fragments");
      } // if

      super.onCreate (savedInstanceState);
…
      return;
   } // onCreate

- Martin

---

这个方案很好，但是当Fragment2进入横屏模式时，会显示Fragment1。不确定是否只有我遇到了这个问题。有什么解决办法吗？ - Art

在您的解决方案中，无论是纵向还是横向都能使用。在选项卡之间切换后不再重叠。 - Alexandru Circus

Answer 3

解决方案并不需要太多的工作，以下步骤可以确保在旋转屏幕时仍能保留选项卡的选择。我遇到了重叠的 Fragments，因为在屏幕旋转时，并不是之前选择的第二个选项卡被选中，而是第一个选项卡，因此第一个选项卡会覆盖第二个选项卡的内容。

以下是您的 Activity 应该看起来的样子（我正在使用 ActionBarSherlock，但进行调整应该非常容易）：

public class TabHostActivity extends SherlockFragmentActivity {

   private static final String SELETED_TAB_INDEX = "tabIndex";


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

     // Setup the action bar
     ActionBar actionBar = getSupportActionBar();
     actionBar.setNavigationMode(ActionBar.NAVIGATION_MODE_TABS);

     // Create the Tabs you need and add them to the actionBar...

     if (savedInstanceState != null) {
        // Select the tab that was selected before orientation change
        int index = savedInstanceState.getInt(SELETED_TAB_INDEX);
        actionBar.setSelectedNavigationItem(index);
     }
   }

   @Override
   protected void onSaveInstanceState(Bundle outState) {
     super.onSaveInstanceState(outState);
     // Save the index of the currently selected tab 
     outState.putInt(SELETED_TAB_INDEX, getSupportActionBar().getSelectedTab().getPosition());
   }
}

以下是我的ActionBar.TabListener看起来的样子（这是上述活动中的一个私有类）：

  private class MyTabsListener<T extends Fragment> implements ActionBar.TabListener {
     private Fragment fragment;
     private final SherlockFragmentActivity host;
     private final Class<Fragment> type;
     private String tag;

     public MyTabsListener(SherlockFragmentActivity parent, String tag, Class type) {
        this.host = parent;
        this.tag = tag;
        this.type = type;
     }

     @Override
     public void onTabSelected(Tab tab, FragmentTransaction transaction) {
        /*
         * The fragment which has been added to this listener may have been
         * replaced (can be the case for lists when drilling down), but if the
         * tag has been retained, we should find the actual fragment that was
         * showing in this tab before the user switched to another.
         */
        Fragment currentlyShowing = host.getSupportFragmentManager().findFragmentByTag(tag);

        // Check if the fragment is already initialised
        if (currentlyShowing == null) {
          // If not, instantiate and add it to the activity
          fragment = SherlockFragment.instantiate(host, type.getName());
          transaction.add(android.R.id.content, fragment, tag);
        } else {
          // If it exists, simply attach it in order to show it
          transaction.attach(currentlyShowing);
        }
     }

     public void onTabUnselected(Tab tab, FragmentTransaction fragmentTransaction) {
        /*
         * The fragment which has been added to this listener may have been
         * replaced (can be the case for lists when drilling down), but if the
         * tag has been retained, we should find the actual fragment that's
         * currently active.
         */
        Fragment currentlyShowing = host.getSupportFragmentManager().findFragmentByTag(tag);
        if (currentlyShowing != null) {
          // Detach the fragment, another tab has been selected
          fragmentTransaction.detach(currentlyShowing);
        } else if (this.fragment != null) {
          fragmentTransaction.detach(fragment);
        }
     }

     public void onTabReselected(Tab tab, FragmentTransaction fragmentTransaction) {
        // This tab is already selected
     }

上述实现还允许基于它们的标签替换选项卡中的片段。为此，在同一选项卡中切换片段时，我使用了与添加到该选项卡的初始框架所使用的相同的标记名称。

- AgentKnopf

Answer 4

感谢Martin和asclepix提供的解决方案。我有3个选项卡，第一个选项卡包含2个片段，就像这样：

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    tools:context=".MainActivity" >

    <FrameLayout 
        android:id="@+id/frActiveTask"
        android:layout_width="fill_parent"
        android:layout_height="50dp"
        android:layout_alignParentBottom="true" 
        />

    <FrameLayout
        android:id="@+id/frTaskList"
        android:layout_width="fill_parent"
        android:layout_height="match_parent"
        android:layout_alignParentTop="true"
        android:layout_above="@id/frActiveTask"
        />

</RelativeLayout>

使用onRestoreInstanceState、onSaveInstanceState和savedInstanceState.remove("android:support:fragments");方法和语句几乎可以正常工作，但如果您的活动选项卡不是第一个，并且旋转并单击第一个，则会出现清晰的显示，只有在第二次单击第一个选项卡时才会出现正确的片段显示。 调试代码后，我发现第一个addTab总是在选项卡侦听器中调用onTabSelected事件，带有一个片段add方法，然后当从onRestoreInstanceState调用setSelectedNavigationItem时，在第一个选项卡上执行detach，并添加其他选项卡。 我的解决方案修复了这种不必要的add调用。

我的活动

protected void onCreate(Bundle savedInstanceState) {
    boolean firstTabIsNotAdded = false;
    if (savedInstanceState != null) {
        savedInstanceState.remove("android:support:fragments");
        firstTabIsNotAdded = savedInstanceState.getInt(SELETED_TAB_INDEX) != 0;
    }
    super.onCreate(savedInstanceState);

    setContentView(R.layout.activity_main);

// codes before adding tabs

    actionBar = getSupportActionBar();
    actionBar.setNavigationMode(ActionBar.NAVIGATION_MODE_TABS);


    tabStartAndStop = actionBar.newTab().setText(getString(R.string.tab_title_start_and_stop))
            .setTabListener(
                    new FragmentTabListener<StartStopFragment>(this, 
                            getString(R.string.tab_title_start_and_stop_id), 
                            StartStopFragment.class,
                            firstTabIsNotAdded));
    tabHistory = actionBar.newTab().setText(getString(R.string.tab_title_history))
            .setTabListener(
                    new FragmentTabListener<HistoryFragment>(this, 
                            getString(R.string.tab_title_history_id), 
                            HistoryFragment.class,
                            false));
    tabRiporting = actionBar.newTab().setText(getString(R.string.tab_title_reporting))
            .setTabListener(
                    new FragmentTabListener<ReportingFragment>(this, 
                            getString(R.string.tab_title_reporting_id), 
                            ReportingFragment.class,
                            false));

    actionBar.addTab(tabStartAndStop);

        actionBar.addTab(tabHistory);
        actionBar.addTab(tabRiporting);

    }

    @Override
    protected void onRestoreInstanceState(Bundle savedInstanceState) {
        if (savedInstanceState != null) {
            int index = savedInstanceState.getInt(SELETED_TAB_INDEX);
            actionBar.setSelectedNavigationItem(index);
        }
        super.onRestoreInstanceState(savedInstanceState);
    }

    @Override
    protected void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);
        // Save the index of the currently selected tab
        outState.putInt(SELETED_TAB_INDEX, getSupportActionBar().getSelectedTab().getPosition());
    }

还有修改后的选项卡监听器

public class FragmentTabListener<T extends SherlockFragment> implements com.actionbarsherlock.app.ActionBar.TabListener {
    private Fragment mFragment;
    private final Activity mFragmentActivity;
    private final String mTag;
    private final Class<T> mClass;
    private boolean doNotAdd;

    /** Constructor used each time a new tab is created.
      * @param activity  The host Activity, used to instantiate the fragment
      * @param tag  The identifier tag for the fragment
      * @param clz  The fragment's Class, used to instantiate the fragment
      */
    public FragmentTabListener(Activity activity, String tag, Class<T> clz, boolean doNotAdd) {
        mFragmentActivity = activity;
        mTag = tag;
        mClass = clz;
        this.doNotAdd = doNotAdd;
    }

    /* The following are each of the ActionBar.TabListener callbacks */
    public void onTabSelected(Tab tab, FragmentTransaction ft) {

        // Check if the fragment is already initialized
        if (mFragment == null) {
            // If not, instantiate and add it to the activity
            if(doNotAdd){
                doNotAdd = false;
            }else{
                mFragment = Fragment.instantiate(mFragmentActivity, mClass.getName());
                ft.add(android.R.id.content, mFragment, mTag);
            }
        } else {
            // If it exists, simply attach it in order to show it
            ft.attach(mFragment);
        }
    }

    public void onTabUnselected(Tab tab, FragmentTransaction ft) {
        if (mFragment != null) {
            // Detach the fragment, because another one is being attached
            ft.detach(mFragment);
        }
    }

    public void onTabReselected(Tab tab, FragmentTransaction ft) {
        // User selected the already selected tab. Usually do nothing.
    }
}

- andep