Android 安卓切换选项卡时片段重叠

首先，感谢大家为这个伟大的社区所做的一切

我试图遵循支持演示示例代码来实现选项卡式片段接口

在顶层，我尝试实现两个选项卡，将单个片段与每个选项卡关联，并在相应地选择每个选项卡时显示片段

目前，我有两个问题（但我确信它们是相关的…）

1） 每个选项卡的碎片相互重叠。这可能与不正确的碎片连接/分离有关

2） 第三个神秘片段正在某处创建，并与其他片段重叠

---

在emulator上（以及在物理设备上），当选择任一选项卡时，您可以看到有两个片段重叠 选择tab1时，片段1和未知片段重叠

选择tab2时，片段1和片段2重叠

---

屏幕截图链接（声誉不足，无法上传照片…

（表1重叠）

（表2重叠）

---

为了演示/清晰起见，我将每个片段中的文本分开。

以下是我的评论/回复中这些截图的链接。（声誉不足，无法上传超过2个链接…

活动布局（fragment_tabs.xml）

源代码

公共类选项卡InfoHome扩展了SherlockFragmentActivity{
TabHost-mTabHost；
TabManager-mTabManager；
静态字符串tag1name=“simple1”；
静态字符串tag2name=“simple2”；
静态字符串tab1string=“您正在查看片段1”；
静态字符串tab2string=“您正在查看片段2”；
@凌驾
创建时受保护的void（Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
setContentView（R.layout.fragment_选项卡）；
如果（savedInstanceState==null）{
//执行第一次初始化——添加初始片段。
Fragment frag1=CountingFragment.newInstance（tab1string）；
Fragment frag2=CountingFragment.newInstance（tab2string）；
FragmentTransaction ft=getSupportFragmentManager（）.beginTransaction（）；
ft.add（R.id.realtabcontent，frag1，tag1name）；
ft.add（R.id.realtabcontent，frag2，tag2name）；
ft.commit（）；
} 
否则{
mTabHost.setCurrentTabByTag（savedInstanceState.getString（“tab”））；
}    
mTabHost=（TabHost）findViewById（android.R.id.TabHost）；
mTabHost.setup（）；
mTabManager=新选项卡管理器（this，mTabHost，R.id.realtabcontent）；
mTabManager.addTab（mTabHost.newTabSpec（tag1name）
.setIndicator（标记1名称），
TabbedInfoHome.CountingFragment.class，
无效）；
mTabManager.addTab（mTabHost.newTabSpec（tag2name）
.setIndicator（标记2名称），
TabbedInfoHome.CountingFragment.class，
无效）；
}   
@凌驾
SaveInstanceState上的公共无效（束超出状态）{
super.onSaveInstanceState（超出状态）；
putString（“tab”，mTabHost.getCurrentTabTag（））；
}
公共静态类CountingFragment扩展了SherlockFragment{
字符串显示字符串；
String FRAGMENT_TAG=this.getClass（）.getSimpleName（）；
/**
*创建CountingFragment的新实例，提供“num”
*作为论据。
*/
静态计数片段newInstance（显示字符串）{
CountingFragment f=新的CountingFragment（）；
Bundle args=新Bundle（）；
args.putString（“string”，toDisplay）；
f、 设置参数（args）；
返回f；
}
/*创建时，从实例的参数中检索该实例的编号*/
@凌驾
创建时的公共void（Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
displayString=getArguments（）！=null？getArguments（）。getString（“字符串”）：“未传入任何字符串！”；
}
/*片段的UI只是一个简单的文本视图，显示其
*实例号*/
@凌驾
创建视图上的公共视图（布局、充气机、视图组容器、，
Bundle savedInstanceState）{
视图v=充气机。充气（R.layout.hello_world，container，false）；
查看电视=v.findviewbyd（R.id.text）；
布尔separateStrings=false；
/*重叠很难理解，所以
*让我们来说明这两个片段是如何出现的*/
如果（分隔带）{
字符串温度；
/*b/c我只创建了CountingFragments对象的两个实例，
*只有两个“显示字符串”要考虑…
*/
if（（displayString.compareTo（tab1string）==0））{
/*用户单击了选项卡1*/
temp=“\n\n\n”+显示字符串；
}
else if（（displayString.compareTo（tab2string）==0））{
/*用户单击了tab2*/
temp=“\n\n\n\n\n\n\n”+显示字符串；
}
否则{
/*未知CountingFragment实例*/
temp=“我在这里干什么……？”；
}
（（文本视图）电视）.setText（温度）；
}
否则{
/*显示片段的正常情况；（但它们重叠！）*/
（（文本视图）tv）.setText（显示字符串）；
}
返回v；
}
}
/**
*这是一个帮助器类，它实现了
*将片段与选项卡主机中的选项卡关联。它依赖于
*通常，选项卡主机有一个简单的API来提供视图或
*每个选项卡将显示的意图。这不足以进行切换
*在片段之间。因此，我们将内容作为选项卡主机的一部分
*0dp高（未显示），TabManager提供自己的虚拟
*查看以显示为选项卡内容。它侦听选项卡中的更改，并执行以下操作：
*注意切换到所示的正确片段
<TabHost
xmlns:android="http://schemas.android.com/apk/res/android"
android:id="@android:id/tabhost"
android:layout_width="match_parent"
android:layout_height="match_parent">

<LinearLayout
    android:orientation="vertical"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <TabWidget
        android:id="@android:id/tabs"
        android:orientation="horizontal"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_weight="0"/>

    <FrameLayout
        android:id="@android:id/tabcontent"
        android:layout_width="0dp"
        android:layout_height="0dp"
        android:layout_weight="0"/>

    <FrameLayout
        android:id="@+id/realtabcontent"
        android:layout_width="match_parent"
        android:layout_height="0dp"
        android:layout_weight="1"/>

</LinearLayout>
</TabHost>

public class TabbedInfoHome extends SherlockFragmentActivity {

TabHost mTabHost;
TabManager mTabManager;

static String tag1name = "simple1";
static String tag2name = "simple2";

static String tab1string = "You are looking at fragment 1";
static String tab2string = "You are looking at fragment 2";


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

    setContentView(R.layout.fragment_tabs); 

    if (savedInstanceState == null) {
        // Do first time initialization -- add initial fragment.
        Fragment frag1 = CountingFragment.newInstance(tab1string);
        Fragment frag2 = CountingFragment.newInstance(tab2string);
        FragmentTransaction ft = getSupportFragmentManager().beginTransaction();

        ft.add(R.id.realtabcontent, frag1, tag1name);
        ft.add(R.id.realtabcontent, frag2, tag2name);

        ft.commit();
    } 
    else {
        mTabHost.setCurrentTabByTag(savedInstanceState.getString("tab"));
    }    

    mTabHost = (TabHost)findViewById(android.R.id.tabhost);
    mTabHost.setup();

    mTabManager = new TabManager(this, mTabHost, R.id.realtabcontent);

    mTabManager.addTab(mTabHost.newTabSpec(tag1name)
                .setIndicator(tag1name),
                TabbedInfoHome.CountingFragment.class,
                null);

    mTabManager.addTab(mTabHost.newTabSpec(tag2name)
                .setIndicator(tag2name),
                TabbedInfoHome.CountingFragment.class, 
                null);
}   

@Override
public void onSaveInstanceState(Bundle outState) {
    super.onSaveInstanceState(outState);
    outState.putString("tab", mTabHost.getCurrentTabTag());
}

public static class CountingFragment extends SherlockFragment {
    String displayString;
    String FRAGMENT_TAG = this.getClass().getSimpleName();



    /**
     * Create a new instance of CountingFragment, providing "num"
     * as an argument.
     */
    static CountingFragment newInstance(String toDisplay) {
        CountingFragment f = new CountingFragment();

        Bundle args = new Bundle();
        args.putString("string", toDisplay);
        f.setArguments(args);
        return f;
    }

     /* When creating, retrieve this instance's number from its arguments. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);         
        displayString = getArguments() != null ? getArguments().getString("string") : "no string was passed in!";
    }


    /* The Fragment's UI is just a simple text view showing its
     * instance number. */
    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
            Bundle savedInstanceState) {

        View v = inflater.inflate(R.layout.hello_world, container, false);
        View tv = v.findViewById(R.id.text);

        boolean separateStrings = false;

        /* the overlapping is hard to decipher, so
         *  lets illustrate how both fragments are appearing */
        if(separateStrings) {

            String temp;

            /* b/c I only created TWO instances of the CountingFragments object, 
             *  there should only be TWO "displayStrings" to consider...
             */
            if( (displayString.compareTo(tab1string) == 0) ) {
                /* user clicked tab 1 */
                temp = "\n\n\n\n" + displayString;
            }
            else if( (displayString.compareTo(tab2string) == 0) ) {
                /* user clicked tab2 */
                temp = "\n\n\n\n\n\n\n" + displayString;
            }
            else {
                /* unknown CountingFragment instance */
                temp = "What am I doing here..??? ";
            }

            ((TextView)tv).setText(temp);

        }
        else {
            /* normal case of the fragment being shown; (but they overlap!) */
            ((TextView)tv).setText(displayString);
        }


        return v;
    }
}

/**
 * This is a helper class that implements a generic mechanism for
 * associating fragments with the tabs in a tab host.  It relies on a
 * trick.  Normally a tab host has a simple API for supplying a View or
 * Intent that each tab will show.  This is not sufficient for switching
 * between fragments.  So instead we make the content part of the tab host
 * 0dp high (it is not shown) and the TabManager supplies its own dummy
 * view to show as the tab content.  It listens to changes in tabs, and takes
 * care of switch to the correct fragment shown in a separate content area
 * whenever the selected tab changes.
 */
public static class TabManager implements TabHost.OnTabChangeListener {
    private final FragmentActivity mActivity;
    private final TabHost mTabHost;
    private final int mContainerId;
    private final HashMap<String, TabInfo> mTabs = new HashMap<String, TabInfo>();
    TabInfo mLastTab;

    static final class TabInfo {
        private final String tag;
        private final Class<?> clss;
        private final Bundle args;
        private Fragment fragment;

        TabInfo(String _tag, Class<?> _class, Bundle _args) {
            tag = _tag;
            clss = _class;
            args = _args;
        }
    }

    static class DummyTabFactory implements TabHost.TabContentFactory {
        private final Context mContext;

        public DummyTabFactory(Context context) {
            mContext = context;
        }

        @Override
        public View createTabContent(String tag) {
            View v = new View(mContext);
            v.setMinimumWidth(0);
            v.setMinimumHeight(0);
            return v;
        }
    }

    public TabManager(FragmentActivity activity, TabHost tabHost, int containerId) {
        mActivity = activity;
        mTabHost = tabHost;
        mContainerId = containerId;
        mTabHost.setOnTabChangedListener(this);
    }

    public void addTab(TabHost.TabSpec tabSpec, Class<?> clss, Bundle args) {

        tabSpec.setContent(new DummyTabFactory(mActivity));
        String tag = tabSpec.getTag();

        TabInfo info = new TabInfo(tag, clss, args);

        // 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.
        info.fragment = mActivity.getSupportFragmentManager().findFragmentByTag(tag);


        if (info.fragment != null ) {  // && !info.fragment.isDetached()) {
            Log.d("addingTab", "we already have a fragment for this tab. tabInfo.fragment.id: " + info.fragment.getId());
            FragmentTransaction ft = mActivity.getSupportFragmentManager().beginTransaction();
            ft.detach(info.fragment);
            ft.commit();
            mActivity.getSupportFragmentManager().executePendingTransactions();
        }

        // associate the tabSpec tag with a particular TabInfo object
        mTabs.put(tag, info);
        mTabHost.addTab(tabSpec);
    }

    @Override
    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) {
                    newTab.fragment = Fragment.instantiate(mActivity,
                            newTab.clss.getName(), newTab.args);

                    ft.add(mContainerId, newTab.fragment, newTab.tag);
                } else {
                    ft.attach(newTab.fragment);
                }
            }

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

}   

             // in order to avoid fragment 
     Fragment prevFragment;
        FragmentManager fm = mActivity.getFragmentManager();
        prevFragment = fm.findFragmentByTag(mTag); 
        if (prevFragment != null) { 
            mFragment = prevFragment; 
        } // \previous Fragment management

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

setContentView(R.layout.fragment_tabs); 

if (savedInstanceState == null) {
    // Do first time initialization -- add initial fragment.
    Fragment frag1 = CountingFragment.newInstance(tab1string);
    Fragment frag2 = CountingFragment.newInstance(tab2string);
    FragmentTransaction ft = getSupportFragmentManager().beginTransaction();

    ft.add(R.id.realtabcontent, frag1, tag1name);
    ft.add(R.id.realtabcontent, frag2, tag2name);

    ft.commit();
    this.getSupportFragmentManager().executePendingTransactions();      // <----- This is the key 
} 
else {
    mTabHost.setCurrentTabByTag(savedInstanceState.getString("tab"));
}    

mTabHost = (TabHost)findViewById(android.R.id.tabhost);
mTabHost.setup();

mTabManager = new TabManager(this, mTabHost, R.id.realtabcontent);

mTabManager.addTab(mTabHost.newTabSpec(tag1name)
            .setIndicator(tag1name),
            TabbedInfoHome.CountingFragment.class,
            null);

mTabManager.addTab(mTabHost.newTabSpec(tag2name)
            .setIndicator(tag2name),
            TabbedInfoHome.CountingFragment.class, 
            null);
}