Android Fragment

時間  2019-12-06
標籤 android fragment 欄目 Android 简体版
原文   原文鏈接

Fragment是activity的界面中的一部分或一種行爲。你能夠把多個Fragment們組合到一個activity中來建立一個多面界面而且你能夠在多個activity中重用一個Fragment。你能夠把Fragment認爲模塊化的一段activity，它具備本身的生命週期，接收它本身的事件，並能夠在activity運行時被添加或刪除。 html

Fragment不能獨立存在，它必須嵌入到activity中，並且Fragment的生命週期直接受所在的activity的影響。例如：當activity暫停時，它擁有的全部的Fragment們都暫停了，當activity銷燬時，它擁有的全部Fragment們都被銷燬。然而，當activity運行時（在onResume()以後，onPause()以前），你能夠單獨地操做每一個Fragment，好比添加或刪除它們。當你在執行上述針對Fragment的事務時，你能夠將事務添加到一個棧中，這個棧被activity管理，棧中的每一條都是一個Fragment的一次事務。有了這個棧，就能夠反向執行Fragment的事務，這樣就能夠在Fragment級支持「返回」鍵（向後導航）。 java

當向activity中添加一個Fragment時，它須置於ViewGroup控件中，而且需定義Fragment本身的界面。你能夠在layoutxml文件中聲明Fragment，元素爲：<fragment>；也能夠在代碼中建立Fragment，而後把它加入到ViewGroup控件中。然而，Fragment不必定非要放在activity的界面中，它能夠隱藏在後臺爲actvitiy工做。 android

本章描述如何使用fragment，包括fragment在加入activity的後退棧中時如何保持本身的狀態，如何與activity以及其它fragment們共享事件，如何顯示在activity的動做欄，等等。 數據庫

設計哲學

Android從3.0開始引入fragment，主要是爲了支持更動態更靈活的界面設計，好比在平板上的應用。平板機上擁有比手機更大的屏幕空間來組合和交互界面組件們。Fragment使你在作那樣的設計時，不需應付view樹中複雜的變化。經過把activity的layout分紅fragment，你能夠在activity運行時改變它的樣子，而且能夠在activity的後退棧中保存這些改變。 api

例如：寫一個讀新聞的程序，能夠用一個fragment顯示標題列表，另外一個fragment顯示選中標題的內容，這兩個fragment都在一個activity上，並排顯示。那麼這兩個fragment都有本身的生命週期並響應本身感興趣的事件。因而，不需再像手機上那樣用一個activity顯示標題列表，用另外一個activity顯示新聞內容；如今能夠把二者放在一個activity上同時顯示出來。以下圖： app


Fragment必須被寫成可重用的模塊。由於fragment有本身的layout，本身進行事件響應，擁有本身的生命週期和行爲，因此你能夠在多個activity中包含同一個Fragment的不一樣實例。這對於讓你的界面在不一樣的屏幕尺寸下都能給用戶完美的體驗尤爲重要。好比你能夠在程序運行於大屏幕中時啓動包含不少fragment的activity，而在運行於小屏幕時啓動一個包含少許fragment的activity。 ide

舉個例子－－仍是剛纔那個讀新聞的程序－當你檢測到程序運行於大屏幕時，啓動activityA，你將標題列表和新聞內容這兩個fragment都放在activityA中；當檢測到程序運行於小屏幕時，仍是啓動activityA，但此時A中只有標題列表fragment，當選中一個標題時，activityA啓動activityB，B中含有新聞內容fragment。 模塊化


建立Fragment

    要建立fragment，必須從Fragment或Fragment的派生類派生出一個類。Fragment的代碼寫起來有些像activity。它具備跟activity同樣的回調方法，好比 onCreate(),onStart(),onPause()和onStop()。實際上，若是你想把老的程序改成使用fragment，基本上只須要把activity的回調方法的代碼移到fragment中對應的方法便可。 函數

一般須要實現以上生命週期函數： 動畫

onCreate():

當建立fragment時系統調用此方法。在其中你必須初始化fragment的基礎組件們。可參考activity的說明。

onCreateView()：

系統在fragment要畫本身的界面時調用（在真正顯示以前）此方法。這個方法必須返回frament的layout的根控件。若是這個fragment不提供界面，那它應返回null。

onPause()：

不廢話了，跟activity同樣。

大多數程序應最少對fragment實現這三個方法。固然還有其它幾個回調方法可應該按狀況實現之。全部的生命週期回調函數在「操控fragment的生命週期」一節中有詳細討論。

下圖爲fragment的生命週期（它所在的activity處於運行狀態）。已經畫得很明白了，不用再解釋了吧？


 

還有幾個現成的fragemtn的派生類，你可能須要從它們派生，以下所列：

DialogFragment

顯示一個浮動的對話框。使用這個類建立對話框是替代activity建立對話框的最佳選擇．由於你能夠把fragmentdialog放入到activity的返回棧中，使用戶能再返回到這個對話框。

ListFragment

顯示一個列表控件，就像ListActivity類，它提供了不少管理列表的方法，好比onListItemClick()方法響應click事件。

PreferenceFragment

顯示一個由Preference對象組成的列表，與PreferenceActivity相同。它用於爲程序建立「設置」activity。

爲fragment添加用戶界面

    fragment通常做爲activity的用戶界面的一部分，把它本身的layout嵌入到activity的layout中。    一個

    要爲fragment提供layout，你必須實現onCreateView()回調方法，而後在這個方法中返回一個View對象，這個對象是fragment的layout的根。

    注：若是你的fragment是從ListFragment中派生的，就不須要實現onCreateView()方法了，由於默認的實現已經爲你返回了ListView控件對象。

    要從onCreateView()方法中返回layout對象，你能夠從layoutxml中生成layout對象。爲了幫助你這樣作，onCreateView()提供了一個LayoutInflater對象。

舉例：如下代碼展現了一個Fragment的子類如何從layoutxml文件example_fragment.xml中生成對象。

publicstaticclassExampleFragmentextendsFragment{
   @Override
  publicViewonCreateView(LayoutInflaterinflater,ViewGroupcontainer,BundlesavedInstanceState){
       //Inflate the layout for this fragment
       returninflater.inflate(R.layout.example_fragment,container,false);
   }
}

    onCreateView()參數中的container是存放fragment的layout的ViewGroup對象。savedInstanceState參數是一個Bundle，跟activity的onCreate()中Bundle差很少，用於狀態恢復。可是fragment的onCreate()中也有Bundle參數，因此此處的Bundle中存放的數據與onCreate()中存放的數據仍是不一樣的。至於詳細信息，請參考「操控fragment的生命週期」一節。

Inflate()方法有三個參數：

1layout的資源ID。

2存放fragment的layout的ViewGroup。

3布爾型數據表示是否在建立fragment的layout期間，把layout附加到container上（在這個例子中，由於系統已經把layout插入到container中了，因此值爲false，若是爲true會導至在最終的layout中建立多餘的ViewGroup(這句我看不明白，但我翻譯的應該沒錯)）。

如今你看到如何爲fragment建立layout了，下面講述如何把它添加到activity中。

把fragment添加到activity

    通常狀況下，fragment把它的layout做爲activitiy的loyout的一部分合併到activity中，有兩種方法將一個fragment添加到activity中：

方法一：在activity的layoutxml文件中聲明fragment

    以下代碼，一個activity中包含兩個fragment：

<?xmlversion="1.0"encoding="utf-8"?>
<LinearLayoutxmlns:android="http://schemas.android.com/apk/res/android"
   android:orientation="horizontal"
   android:layout_width="match_parent"
   android:layout_height="match_parent">
   <fragmentandroid:name="com.example.news.ArticleListFragment"
           android:id="@+id/list"
           android:layout_weight="1"
           android:layout_width="0dp"
          android:layout_height="match_parent"/>
   <fragmentandroid:name="com.example.news.ArticleReaderFragment"
           android:id="@+id/viewer"
           android:layout_weight="2"
           android:layout_width="0dp"
          android:layout_height="match_parent"/>
</LinearLayout>

<fragment>中聲明一個fragment。

    當系統建立上例中的layout時，它實例化每個fragment，而後調用它們的onCreateView()方法，以獲取每一個fragment的layout。系統把fragment返回的view對象插入到<fragment>元素的位置，直接代替<fragment>元素。

    注：每一個fragment都須要提供一個ID，系統在activity從新建立時用它來恢復fragment們，你也能夠用它來操做fragment進行其它的事物，好比刪除它。有三種方法給fragment提供ID：

1 爲android:id屬性賦一個數字。

2 爲android:tag屬性賦一個字符串。

3若是你沒有使用上述任何一種方法，系統將使用fragment的容器的ID。

方法二：在代碼中添加fragment到一個ViewGroup

     這種方法能夠在運行時，把fragment添加到activity的layout中。你只需指定一個要包含fragment的ViewGroup。

    爲了完成fragment的事務（好比添加，刪除，替換等），你必須使用FragmentTransaction的方法。你能夠從activity獲取到FragmentTransaction，以下：

FragmentManagerfragmentManager =getFragmentManager()
FragmentTransactionfragmentTransaction =fragmentManager.beginTransaction();

    而後你能夠用add()方法添加一個fragment，它有參數用於指定容納fragment的ViewGroup。以下：

ExampleFragmentfragment =newExampleFragment();
fragmentTransaction.add(R.id.fragment_container,fragment);
fragmentTransaction.commit();

    Add()的第一個參數是容器ViewGroup，第二個是要添加的fragment。一旦你經過FragmentTransaction對fragment作出了改變，你必須調用方法commit()提交這些改變。

不只在無界面的fragment中，在有界面的fragment中也可使用tag來做爲爲一標誌，這樣在須要獲取fragment對象時，要調用findFragmentTag()。

添加一個沒有界面的fragment

    上面演示瞭如何添加fragment來提供界面，然而，你也可使用fragment爲activity提供後臺的行爲而不用顯示fragment的界面。


管理fragment


    要添加一個沒有界面的fragment，需在activity中調用方法add(Fragment,String)（它支持用一個惟一的字符串作爲fragment的」tag」，而不是viewID）。這樣添加的fragment因爲沒有界面，因此你在實現它時不需調用實現onCreateView()方法。

    使用tag字符串來標識一個fragment並非只能用於沒有界面的fragment上，你也能夠把它用於有界面的fragment上，可是，若是一個fragment沒有界面，tag字符串將成爲它惟一的選擇。獲取以tag標識的fragment，需使用方法findFragmentByTab()。

要管理fragment們，需使用FragmentManager，要獲取它，需在activity中調用方法getFragmentManager()。

你能夠用FragmentManager來作以上事情：

 

1使用方法findFragmentById()或findFragmentByTag()，獲取activity中已存在的fragment們。

2使用方法popBackStack()從activity的後退棧中彈出fragment們（這能夠模擬後退鍵引起的動做）。

3用方法addOnBackStackChangedListerner()註冊一個偵聽器以監視後退棧的變化。

更多關於以上方法的信息，請參考「FragmentManager」文檔。

就像前面章節所演示的，你還可使用FragmentManager打開一個FragmentTransaction來執行fragment的事務，好比添加或刪除fragment。

執行Fragment的事務

在activity中使用fragment的一個偉大的好處是能跟據用戶的輸入對fragment進行添加、刪除、替換以及執行其它動做的能力。你提交的一組fragment的變化叫作一個事務。事務經過FragmentTransaction來執行。你還能夠把每一個事務保存在activity的後退棧中，這樣就可讓用戶在fragment變化之間導航（跟在activity之間導航同樣）。

你能夠經過FragmentManager來取得FragmentTransaction的實例，以下:

FragmentManagerfragmentManager=getFragmentManager();
FragmentTransactionfragmentTransaction=fragmentManager.beginTransaction();

一個事務是在同一時刻執行的一組動做（很像數據庫中的事務）。你能夠用add(),remove(),replace()等方法構成事務，最後使用commit()方法提交事務。

在調用commint()以前，你能夠用addToBackStack()把事務添加到一個後退棧中，這個後退棧屬於所在的activity。有了它，就能夠在用戶按下返回鍵時，返回到fragment們執行事務以前的狀態。

以下例：演示瞭如何用一個fragment代替另外一個fragment，同時在後退棧中保存被代替的fragment的狀態。

//Create new fragment and transaction
FragmentnewFragment=newExampleFragment();
FragmentTransactiontransaction=getFragmentManager().beginTransaction();

//Replace whatever is in the fragment_container view with thisfragment,
//and add the transaction to the backstack
transaction.replace(R.id.fragment_container,newFragment);
transaction.addToBackStack(null);

//Commit the transaction
transaction.commit();

解釋：newFragment代替了控件IDR.id.fragment_container所指向的ViewGroup中所含的任何fragment。而後調用addToBackStack()，此時被代替的fragment就被放入後退棧中，因而當用戶按下返回鍵時，事務發生回溯，原先的fragment又回來了。

若是你向事務添加了多個動做，好比屢次調用了add(),remove()等以後又調用了addToBackStack()方法，那麼全部的在commit()以前調用的方法都被做爲一個事務。當用戶按返回鍵時，全部的動做都被反向執行（事務回溯）。

事務中動做的執行順序可隨意，但要注意如下兩點：

1你必須最後調用commit()。

2若是你添加了多個fragment，那麼它們的顯示順序跟添加順序一至（後顯示的覆蓋前面的）。

若是你在執行的事務中有刪除fragment的動做，並且沒有調用addToBackStack()，那麼當事務提交時，那些被刪除的fragment就被銷燬了。反之，那些fragment就不會被銷燬，而是處於中止狀態。當用戶返回時，它們會被恢復。

密技：對於fragment事務，你能夠應用動畫。在commit()以前調用setTransition()就行。――通常銀我不告訴他哦。

可是，調用commit()後，事務並不會立刻執行。它會在activity的UI線程（其實就是主線程）中等待直到線程能執行的時候才執行（廢話）。若是必要，你能夠在UI線程中調用executePendingTransactions()方法來當即執行事務。但通常不需這樣作，除非有其它線程在等待事務的執行。

警告：你只能在activity處於可保存狀態的狀態時，好比running中，onPause()方法和onStop()方法中提交事務，不然會引起異常。這是由於fragment的狀態會丟失。若是要在可能丟失狀態的狀況下提交事務，請使用commitAllowingStateLoss()。

與activity通信

　　儘管fragment的實現是獨立於activity的，能夠被用於多個activity，可是每一個activity所包含的是同一個fragment的不一樣的實例。

　　Fragment能夠調用getActivity()方法很容易的獲得它所在的activity的對象，而後就能夠查找activity中的控件們（findViewById()）。例如：

ViewlistView =getActivity().findViewById(R.id.list);

　　一樣的，activity也能夠經過FragmentManager的方法查找它所包含的frament們。例如：

ExampleFragment　fragment=(ExampleFragment)getFragmentManager().findFragmentById(R.id.example_fragment

activity響應fragment的事件

　　有時，你可能須要fragment與activity共享事件。一個好辦法是在fragment中定義一個回調接口，而後在activity中實現之。

　　例如，仍是那個新聞程序的例子，它有一個activity，activity中含有兩個fragment。fragmentA顯示新聞標題，fragmentB顯示標題對應的內容。fragmentA必須在用戶選擇了某個標題時告訴activity，而後activity再告訴fragmentB，fragmentB就顯示出對應的內容（爲何這麼麻煩？直接fragmentA告訴fragmentB不就好了？也能夠啊，可是你的fragment就減小了可重用的能力。如今我只需把個人事件告訴宿主，由宿主決定如何處置，這樣是否是重用性更好呢？）。以下例，OnArticleSelectedListener接口在fragmentA中定義：

public　static　class　FragmentA　extends　ListFragment{
   ...
   //Container Activity must implement this interface
   public　interface　OnArticleSelectedListener{
       public　void　onArticleSelected(Uri　articleUri);
   }
   ...
}

而後activity實現接口OnArticleSelectedListener，在方法onArticleSelected()中通知fragmentB。當fragment添加到activity中時，會調用fragment的方法onAttach()，這個方法中適合檢查activity是否實現了OnArticleSelectedListener接口，檢查方法就是對傳入的activity的實例進行類型轉換，以下所示：

public　static　class　FragmentA　extends　ListFragment{
   OnArticleSelectedListener　mListener;
   ...
   @Override
   public　void　onAttach(Activity　activity){
       super.onAttach(activity);
       try{
           mListener =(OnArticleSelectedListener)activity;
       }catch(ClassCastException　e){
           throw　new　ClassCastException(activity.toString()+"must implement OnArticleSelectedListener");
       }
   }
   ...
}

若是activity沒有實現那個接口，fragment拋出ClassCastException異常。若是成功了，mListener成員變量保存OnArticleSelectedListener的實例。因而fragmentA就能夠調用mListener的方法來與activity共享事件。例如，若是fragmentA是一個ListFragment，每次選中列表的一項時，就會調用fragmentA的onListItemClick()方法，在這個方法中調用onArticleSelected()來與activity共享事件，以下：

public　static　class　FragmentA　extends　ListFragment{
   OnArticleSelectedListener　mListener;
   ...
   @Override
   public　void　onListItemClick(ListView　l,View　v,int　position,long　id){
       //Append the clicked item's row ID with the content provider Uri
       Uri　noteUri =ContentUris.withAppendedId(ArticleColumns.CONTENT_URI,id);
       //Send the event and Uri to the host activity
       mListener.onArticleSelected(noteUri);
   }
   ...
}

onListItemClick()傳入的參數id是列表的被選中的行ID，另外一個fragment用這個ID來從程序的ContentProvider中取得標題的內容。

處理fragement的生命週期

把條目添加到動做欄

你的fragment們能夠向activity的菜單（按Manu鍵時出現的東西）添加項，同時也可向動做欄（界面中頂部的那個區域）添加條目，這都需經過實現方法onCreateOptionManu()來完成。

你從fragment添加到菜單的任何條目，都會出如今現有菜單項以後。Fragment以後能夠經過方法onOptionsItemSelected()來響應本身的菜單項被選擇的事件。

你也能夠在fragemnt中註冊一個view來提供快捷菜單（上下文菜單）。當用戶要打開快捷菜單時，fragment的onCreateContextMenu()方法會被調用。當用戶選擇其中一項時，fragemnt的onContextItemSelected()方法會被調用。

注：儘管你的fragment能夠分別收到它所添加的菜單項的選中事件，可是activity纔是第一個接收這些事件的傢伙，只有當activity對某個事件置之不理時，fragment才能接收到這個事件，對於菜單和快捷菜單都是這樣。

 

處理fragement的生命週期

 

管理fragment的生命週期有些像管理activity的生命週期。Fragment能夠生存在三種狀態：

Resumed:

Fragment在一個運行中的activity中而且可見。

Paused:

另外一個activity處於最頂層，可是fragment所在的activity並無被徹底覆蓋（頂層的activity是半透明的或不佔據整個屏幕）。

Stoped:

Fragment不可見。多是它所在的activity處於stoped狀態或是fragment被刪除並添加到後退棧中了。此狀態的fragment仍然存在於內存中。

一樣相似於activity，你能夠把fragment的狀態保存在一個Bundle中，在activity被recreated時就需用到這個東西。你能夠在onSaveInstanceState()方法中保存狀態並在onCreate()或onCreateView()或onActivityCreated()中恢復，關於更多的保存狀態的信息，請參考Activitys章節。

Fragment與Activity的生命週期中最大的不一樣就是存儲到後退棧中的過程。Activity是在中止時自動被系統壓入中止棧，而且這個棧是被系統管理的；而fragment是被壓入activity所管理的一個後退棧，而且只有你在刪除fragment後並明確調用addToBackStack()方法時才被壓入。

然而，管理fragment的生命週期與管理activity的生命週期極其類似。你所須要去思考的是activity的生命週期如何影響fragment的生命週期。

 

協調與 activity生命週期的關係

 

Activity直接影響它所包含的fragment的生命週期，因此對activity的某個生命週期方法的調用也會產生對fragment相同方法的調用。例如：當activity的onPause()方法被調用時，它所包含的全部的fragment們的onPause()方法都會被調用。

Fragment比activity還要多出幾個生命週期回調方法，這些額外的方法是爲了與activity的交互而設立，以下：

onAttach()

當fragment被加入到activity時調用（在這個方法中能夠得到所在的activity）。

onCreateView()

當activity要獲得fragment的layout時，調用此方法，fragment在其中建立本身的layout(界面)。

onActivityCreated()

當activity的onCreated()方法返回後調用此方法。

onDestroyView()

當fragment的layout被銷燬時被調用。

onDetach()

當fragment被從activity中刪掉時被調用。

一旦activity進入resumed狀態（也就是running狀態），你就能夠自由地添加和刪除fragment了。所以，只有當activity在resumed狀態時，fragment的生命週期才能獨立的運轉，其它時候是依賴於activity的生命週期變化的。

android Fragments詳解七:fragement示例

下例中實驗了上面所講的全部內容。此例有一個activity，其含有兩個fragment。一個顯示莎士比亞劇的播放曲目，另外一個顯示選中曲目的摘要。此例還演示瞭如何跟據屏幕大小配置fragment。

主activity建立layout。

 

[java]  view plain copy
  1. @Override  
  2. protectedvoid onCreate(Bundle savedInstanceState) {  
  3.    super.onCreate(savedInstanceState);  
  4.   
  5.    setContentView(R.layout.fragment_layout);  
  6. }  


主activity的layoutxml文檔

 

 

[java]  view plain copy
  1. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
  2.     android:orientation="horizontal"  
  3.     android:layout_width="match_parent" android:layout_height="match_parent">  
  4.   
  5.     <fragment class="com.example.android.apis.app.FragmentLayout$TitlesFragment"  
  6.             android:id="@+id/titles" android:layout_weight="1"  
  7.             android:layout_width="0px" android:layout_height="match_parent" />  
  8.   
  9.     <FrameLayout android:id="@+id/details" android:layout_weight="1"  
  10.             android:layout_width="0px" android:layout_height="match_parent"  
  11.             android:background="?android:attr/detailsElementBackground" />  
  12.   
  13. </LinearLayout>  


系統在activity加載此layout時初始化TitlesFragment（用於顯示標題列表），TitlesFragment的右邊是一個FrameLayout，用於存放顯示摘要的fragment，可是如今它仍是空的，fragment只有當用戶選擇了一項標題後，摘要fragment纔會被放到FrameLayout中。

 

然而，並非全部的屏幕都有足夠的寬度來容納標題列表和摘要。因此，上述layout只用於橫屏，現把它存放於ret/layout-land/fragment_layout.xml。

以外，當用於豎屏時，系統使用下面的layout，它存放於ret/layout/fragment_layout.xml：

 

[java]  view plain copy
  1. <FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"  
  2.     android:layout_width="match_parent" android:layout_height="match_parent">  
  3.     <fragment class="com.example.android.apis.app.FragmentLayout$TitlesFragment"  
  4.             android:id="@+id/titles"  
  5.             android:layout_width="match_parent" android:layout_height="match_parent" />  
  6. </FrameLayout>  

 

這個layout只包含TitlesFragment。這表示當使用豎屏時，只顯示標題列表。當用戶選中一項時，程序會啓動一個新的activity去顯示摘要，而不是加載第二個fragment。

下一步，你會看到Fragment類的實現。第一個是TitlesFragment，它從ListFragment派生，大部分列表的功能由ListFragment提供。

當用戶選擇一個Title時，代碼須要作出兩種行爲，一種是在同一個activity中顯示建立並顯示摘要fragment，另外一種是啓動一個新的activity。

 

[java]  view plain copy
  1. public static class TitlesFragment extends ListFragment {  
  2.     boolean mDualPane;  
  3.     int mCurCheckPosition = 0;  
  4.   
  5.     @Override  
  6.     public void onActivityCreated(Bundle savedInstanceState) {  
  7.         super.onActivityCreated(savedInstanceState);  
  8.   
  9.         // Populate list with our static array of titles.  
  10.         setListAdapter(new ArrayAdapter<String>(getActivity(),  
  11.                 android.R.layout.simple_list_item_activated_1, Shakespeare.TITLES));  
  12.   
  13.         // Check to see if we have a frame in which to embed the details  
  14.         // fragment directly in the containing UI.  
  15.         View detailsFrame = getActivity().findViewById(R.id.details);  
  16.         mDualPane = detailsFrame != null && detailsFrame.getVisibility() == View.VISIBLE;  
  17.   
  18.         if (savedInstanceState != null) {  
  19.             // Restore last state for checked position.  
  20.             mCurCheckPosition = savedInstanceState.getInt("curChoice", 0);  
  21.         }  
  22.   
  23.         if (mDualPane) {  
  24.             // In dual-pane mode, the list view highlights the selected item.  
  25.             getListView().setChoiceMode(ListView.CHOICE_MODE_SINGLE);  
  26.             // Make sure our UI is in the correct state.  
  27.             showDetails(mCurCheckPosition);  
  28.         }  
  29.     }  
  30.   
  31.     @Override  
  32.     public void onSaveInstanceState(Bundle outState) {  
  33.         super.onSaveInstanceState(outState);  
  34.         outState.putInt("curChoice", mCurCheckPosition);  
  35.     }  
  36.   
  37.     @Override  
  38.     public void onListItemClick(ListView l, View v, int position, long id) {  
  39.         showDetails(position);  
  40.     }  
  41.   
  42.     /** 
  43.      * Helper function to show the details of a selected item, either by 
  44.      * displaying a fragment in-place in the current UI, or starting a 
  45.      * whole new activity in which it is displayed. 
  46.      */  
  47.     void showDetails(int index) {  
  48.         mCurCheckPosition = index;  
  49.   
  50.         if (mDualPane) {  
  51.             // We can display everything in-place with fragments, so update  
  52.             // the list to highlight the selected item and show the data.  
  53.             getListView().setItemChecked(index, true);  
  54.   
  55.             // Check what fragment is currently shown, replace if needed.  
  56.             DetailsFragment details = (DetailsFragment)  
  57.                     getFragmentManager().findFragmentById(R.id.details);  
  58.             if (details == null || details.getShownIndex() != index) {  
  59.                 // Make new fragment to show this selection.  
  60.                 details = DetailsFragment.newInstance(index);  
  61.   
  62.                 // Execute a transaction, replacing any existing fragment  
  63.                 // with this one inside the frame.  
  64.                 FragmentTransaction ft = getFragmentManager().beginTransaction();  
  65.                 ft.replace(R.id.details, details);  
  66.                 ft.setTransition(FragmentTransaction.TRANSIT_FRAGMENT_FADE);  
  67.                 ft.commit();  
  68.             }  
  69.   
  70.         } else {  
  71.             // Otherwise we need to launch a new activity to display  
  72.             // the dialog fragment with selected text.  
  73.             Intent intent = new Intent();  
  74.             intent.setClass(getActivity(), DetailsActivity.class);  
  75.             intent.putExtra("index", index);  
  76.             startActivity(intent);  
  77.         }  
  78.     }  


第二個fragment，DetailsFragment顯示被選擇的Title的摘要：

 

 

[java]  view plain copy
  1. public static class DetailsFragment extends Fragment {  
  2.     /** 
  3.      * Create a new instance of DetailsFragment, initialized to 
  4.      * show the text at 'index'. 
  5.      */  
  6.     public static DetailsFragment newInstance(int index) {  
  7.         DetailsFragment f = new DetailsFragment();  
  8.   
  9.         // Supply index input as an argument.  
  10.         Bundle args = new Bundle();  
  11.         args.putInt("index", index);  
  12.         f.setArguments(args);  
  13.   
  14.         return f;  
  15.     }  
  16.   
  17.     public int getShownIndex() {  
  18.         return getArguments().getInt("index", 0);  
  19.     }  
  20.   
  21.     @Override  
  22.     public View onCreateView(LayoutInflater inflater, ViewGroup container,  
  23.             Bundle savedInstanceState) {  
  24.         if (container == null) {  
  25.             // We have different layouts, and in one of them this  
  26.             // fragment's containing frame doesn't exist.  The fragment  
  27.             // may still be created from its saved state, but there is  
  28.             // no reason to try to create its view hierarchy because it  
  29.             // won't be displayed.  Note this is not needed -- we could  
  30.             // just run the code below, where we would create and return  
  31.             // the view hierarchy; it would just never be used.  
  32.             return null;  
  33.         }  
  34.   
  35.         ScrollView scroller = new ScrollView(getActivity());  
  36.         TextView text = new TextView(getActivity());  
  37.         int padding = (int)TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP,  
  38.                 4, getActivity().getResources().getDisplayMetrics());  
  39.         text.setPadding(padding, padding, padding, padding);  
  40.         scroller.addView(text);  
  41.         text.setText(Shakespeare.DIALOGUE[getShownIndex()]);  
  42.         return scroller;  
  43.     }  
  44. }  


若是當前的layout沒有R.id.detailsView（它被用於DetailsFragment的容器），那麼程序就啓動DetailsActivity來顯示摘要。

 

下面是DetailsActivity，它只是簡單地嵌入DetailsFragment來顯示摘要。

 

[java]  view plain copy
  1. public static class DetailsActivity extends Activity {  
  2.   
  3.     @Override  
  4.     protected void onCreate(Bundle savedInstanceState) {  
  5.         super.onCreate(savedInstanceState);  
  6.   
  7.         if (getResources().getConfiguration().orientation  
  8.                 == Configuration.ORIENTATION_LANDSCAPE) {  
  9.             // If the screen is now in landscape mode, we can show the  
  10.             // dialog in-line with the list so we don't need this activity.  
  11.             finish();  
  12.             return;  
  13.         }  
  14.   
  15.         if (savedInstanceState == null) {  
  16.             // During initial setup, plug in the details fragment.  
  17.             DetailsFragment details = new DetailsFragment();  
  18.             details.setArguments(getIntent().getExtras());  
  19.             getFragmentManager().beginTransaction().add(android.R.id.content, details).commit();  
  20.         }  
  21.     }  
  22. }  


注意這個activity在檢測到是豎屏時會結束本身，因而主activity會接管它並顯示出TitlesFragment和DetailsFragment。這能夠在用戶在豎屏時顯示在TitleFragment，但用戶旋轉了屏幕，使顯示變成了橫屏。

Android Tabhost with FragmentActivity

此文解決我這兩天的問題,故轉載：原文Android Tabhost with FragmentActivity

 

2012-05-07 更新)接續Android TabHost中切換Activity記錄了使用ActivityGroup達到在TabHost中切換Activity的方法，也在Android Screen Orientation Event螢幕方向處理+Acitivity Liftcycle記錄了當螢幕方向改變時的處理，這篇小蛙繼續記錄用FragmentActivity取代ActivityGroup，透過FragmentActivity內建的BackStack來管理倒退歷程。

MainTabActivity.java : 主要的Tabhost Activity。

 

複製代碼 
public class MainTabActivity extends Activity { private TabHost mHost; // 在Activity中使用Tabhost必須要有LocalActivityManager物件來設定  LocalActivityManager lam; @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); // main layout採用預設的Tabhost mHost = (TabHost) findViewById(android.R.id.tabhost); lam = new LocalActivityManager(MainTabActivity.this, false); lam.dispatchCreate(savedInstanceState); mHost.setup(lam); mHost.addTab(mHost.newTabSpec("Tab1").setIndicator("Tab1").setContent(new Intent(MainTabActivity.this, FragmentActivity1.class))); mHost.addTab(mHost.newTabSpec("Tab2").setIndicator("Tab2").setContent(new Intent(MainTabActivity.this, FragmentActivity2.class))); } @Override protected void onPause() { // 漏掉這行必定出錯  lam.dispatchPause(isFinishing()); super.onPause(); } @Override protected void onResume() { // 漏掉這行必定出錯  lam.dispatchResume(); super.onResume(); } }
複製代碼

FragmentActivity1.java : 第一個Tab中用來管理Fragment的FragmentActivity。(2012-05-07更新)經由Jay留言後，小蛙詳細測了一下，發現FragmentActivity主畫面中的Button是沒辦法消失的(因為FragmentActivity的目的關係)，所以改爲這樣，讓FragmentActivity純粹當成容器，主要的內容還是以Fragment為主。(這個方法不是惟一，可是一個可行的方法，應該也有更好的作法！)

複製代碼 
public class FragmentActivity1 extends FragmentActivity { public static FragmentManager fm; @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.fragment_activity_1); fm = getSupportFragmentManager(); // 只當容器，主要內容已Fragment呈現 initFragment(new Fragment1()); } // 切換Fragment public static void changeFragment(Fragment f){ changeFragment(f, false); } // 初始化Fragment(FragmentActivity中呼叫) public static void initFragment(Fragment f){ changeFragment(f, true); } private static void changeFragment(Fragment f, boolean init){ FragmentTransaction ft = fm.beginTransaction(); ft.replace(R.id.simple_fragment, f); if(!init) ft.addToBackStack(null); ft.commit(); } }
複製代碼

Fragment1.java : 真正使用到的Fragment。

複製代碼 
public class Fragment1 extends Fragment { @Override public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { View v = inflater.inflate(R.layout.fragment_1, container, false); Button tv = (Button)v.findViewById(R.id.button2); tv.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { // 直接呼叫FragmentActivity1的靜態方法來作切換 FragmentActivity1.changeFragment(new Fragment2()); } }); return v; } }
複製代碼

fragment_acitivity_1.xml : FragmentActivity layout。(2012-05-07修改) FragmentActivity只用來當容器，而不真正呈現內容(僅把Fragment內容載入)。

複製代碼 
<?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="fill_parent" android:layout_height="fill_parent" android:orientation="vertical" android:id="@+id/simple_fragment"> </LinearLayout>
複製代碼

fragment1.xml：Fragment layout，FragmentActivity載入的真正內容。

複製代碼 
<?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="fill_parent" android:layout_height="fill_parent" android:orientation="vertical"> <Button android:id="@+id/button2" android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="Button" /> </LinearLayout>
複製代碼

最後別忘了在AndroidManifest.xml中加入android:configChanges="orientation"設定。這樣就成功的使用在Activity中使用Tabhost並且透過FragmentActivity來管理Fragment囉！

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程