fragment使用_android fragment使用 - CSDN
精华内容
参与话题
  • Fragment简介和使用实例

    千次阅读 2014-07-30 15:04:48
    Fragment 是什么  今天我们来学习一个比较重要的...Fragment在应用开发中应用得非常的频繁,特别是在开发一些需要兼容手机设备、平板设备和智能电视等大屏幕设备的应用,Fragment发挥着重要的作用。那说了这么多

    转载请注明出处http://blog.csdn.net/yegongheng/article/details/38013349


    Fragment 是什么

           今天我们来学习一个比较重要的组件--Fragment。Fragment在应用开发中应用得非常的频繁,特别是在开发一些需要兼容手机设备、平板设备和智能电视等大屏幕设备的应用,Fragment发挥着重要的作用。那说了这么多,Fragment到底是什么呢?在这里我们先简单的用一句话总结就是:Fragment是Android为了应用适配不同设备的大屏幕、支持更加动态和灵活的UI设计所提供的一个组件。
           说到Fragment,就会联想到Activity,因为Fragment对象在应用中一般是不能独立存在的,它必须嵌入到activity中,而且Fragment的生命周期直接受所在的activity的影响。例如:当activity暂停时,他拥有的所有的Fragment都暂停了,当activity销毁时,他拥有的所有Fragment都被销毁。然而,当activity运行时(在onResume()之后,onPause()之前),可以单独地操作每个Fragment,比如添加或删除它们。当中执行上述针对Fragment的事务时,可以将事务添加到一个栈中,这个栈被activity管理,栈中的每一条都是一个Fragment的一次事务。有了这个栈,就可以反向执行Fragment的事务,这样就可以在Fragment级支持“返回”键(向后导航)。
            当向activity中添加一个Fragment时,它须置于ViewGroup控件中,并且需定义Fragment自己的界面。可以在layout.xml布局文件中声明Fragment,元素为:<fragment>;也可以在代码中创建Fragment,然后把它加入到ViewGroup
    控件中。然而,Fragment不一定非要放在activity的界面中,它可以隐藏在后台为activity工作。
            Android在3.0之后引入了Fragment的概念,主要目的是用在大屏幕设备-例如平板电脑上,以便支持更加动态和灵活的UI设计。平板电脑的屏幕尺寸比手机大得多,因此有更多的空间来存放更多的UI组件,并且这些组件之间会产生更多的交互。Fragment允许这样的一种设计,而不需要你亲自来管理viewhierarchy的复杂变化。通过将Activity的布局分散到Fragment中,你可以在运行时修改Activity的外观,并在由Activity管理的Back stack中保存那些变化。
             例如,一个新闻应用可以在屏幕的左侧使用一个Fragment来展示一个文章的列表,然后在屏幕右侧使用另一个Fragment来展示一篇文章,两个Fragment并排显示在相同的一个Activity中,并且每一个Fragment拥有它自己的一套生命周期回调方法,并且处理它们自己的用户输入事件。因此,取代使用一个activity来选择一篇文章而另一个activity来阅读文章的方式,用户可以在同一个activity中选择一篇文章并且阅读,如图所示:

             Fragment在你的应用中应当是一个模块化和可重用的组件。即,因为fragment定义了它自己的布局,以及通过自己的生命周期回调方法来定义自己的行为,你可以将Fragment包含到多个Activity中,这点特别重要,因为允许你将你的用户体验适配到不同的屏幕尺寸。举个例子,你可能仅当在屏幕尺寸足够大时,在一个activity中包含多个fragment并且当不属于这种情况时,会启动另一个单独的使用不同fragment的activity。
            继续之前那个新闻的例子-当运行在一个特别大的屏幕时(例如平板电脑),应用可以在activity A中嵌入2个fragment。然而,在一个正常尺寸的屏幕(例如手机)上,没有足够的空间同事供2个fragment使用。因此,activity A会仅含文章列表的fragment,而当用户选择一篇文章时,它会启动activity B,它包含阅读文章的fragment B。因此,应用可以同时支持上图中的2种模式。

    Fragment生命周期

            Fragment虽然必须嵌入到Activity才能使用,但它有自己的一套生命周期回调方法,其生命周期与Activity的生命周期类似,同时它受其所属的Activity(宿主Activity)生命周期的直接影响,例如:当activity暂停时,他拥有的所有的Fragment都暂停了,当activity销毁时,他拥有的所有Fragment都被销毁。下面是Fragment生命周期图(图1.1)以及与宿主Activity生命周期之间的关系图示(图1.2):
               
                   图1.1                                                                               图1.2
    下面将一一介绍Fragment各个回调方法的特性和使用:
          onAttach():当Fragment被绑定到Activity事调用(Activity会被传入);
          onCreate():当Fragment被创建时,系统调用该方法。在实现代码中,应当初始化想要在Fragment保持的必要组件,当Fragment暂停或停止后可以被恢复;(此方法在实现一个Fragment时必须)
          onCreateView():在Fragment第一次绘制界面时系统会调用此方法,为绘制Fragment的UI,方法需返回一个View对象,该对象是Fragment布局的根View。若Fragment不提供UI,则返回null;(此方法在实现一个Fragment时必须)
          onActivityCreated():当Activity被创建回调onCreate()方法后,系统调用此方法;
          onStart():当Fragment呈现给用户变得可见之前调用(在宿主Activity回调完onStart()方法后调用),此时用户与界面处于可见不可交互的状态。
          onResume():当用户和界面可以互相交互时调用(在宿主Activity回调完onResume()方法后调用)。
          onPause():当需要开启一个新的Activity或替换一个新的Fragment时,系统调用此方法(在宿主Activity回调完onPause()方法后调用)。此时用户将要离开与Fragment界面的交互,因此一般来讲应在此方法中保存一些需要持久化的变化。(此方法在实现一个Fragment时必须)
          onStop():当Fragment变得完全不可见时,系统调用该方法(在宿主Activity回调完onStop()方法后回调),出现此状态的原因可能是另一个Activity覆盖此宿主Activity或此Fragment被替换,此时Fragment面临被销毁。
          onDestoryView():当和Fragment关联的View hierarchy被移除时,系统调用该方法。
          onDestory():当Fragment被销毁时,系统调用该方法。
          onDetach():当Fragment与宿主Activity解除关联时,系统调用该方法。
    下面我们通过一个例子来具体了解一下Fragment的生命周期各个回调函数在何时调用,要使用Fragment,需创建一个继承Fragment的子类(LifeCycleFragment),我们这里重写了Fragment的全部生命周期函数,代码如下:
    public class LifeCycleFragment extends Fragment {
    
    	private static final String TAG = "FragmentLifeCycle";
    	
    	@Override
    	public void onAttach(Activity activity) {
    		// TODO Auto-generated method stub
    		super.onAttach(activity);
    		Log.i(TAG, "onAttach");
    	}
    
    	@Override
    	public void onCreate(Bundle savedInstanceState) {
    		// TODO Auto-generated method stub
    		super.onCreate(savedInstanceState);
    		Log.i(TAG, "onCreate");
    	}
    
    	@Override
    	public View onCreateView(LayoutInflater inflater, ViewGroup container,
    			Bundle savedInstanceState) {
    		// TODO Auto-generated method stub
    		Log.i(TAG, "onCreateView");
    		
    		View rootView = inflater.inflate(R.layout.fragment_lifecycle, container, false);
    		return rootView;
    	}
    	
    	@Override
    	public void onActivityCreated(Bundle savedInstanceState) {
    		// TODO Auto-generated method stub
    		super.onActivityCreated(savedInstanceState);
    		Log.i(TAG, "onActivityCreated");
    	}
    
    	@Override
    	public void onStart() {
    		// TODO Auto-generated method stub
    		super.onStart();
    		Log.i(TAG, "onStart");
    	}
    
    	@Override
    	public void onResume() {
    		// TODO Auto-generated method stub
    		super.onResume();
    		Log.i(TAG, "onResume");
    	}
    
    	@Override
    	public void onPause() {
    		// TODO Auto-generated method stub
    		super.onPause();
    		Log.i(TAG, "onPause");
    	}
    	
    	@Override
    	public void onStop() {
    		// TODO Auto-generated method stub
    		super.onStop();
    		Log.i(TAG, "onStop");
    	}
    
    	@Override
    	public void onDestroyView() {
    		// TODO Auto-generated method stub
    		super.onDestroyView();
    		Log.i(TAG, "onDestroyView");
    	}
    
    	@Override
    	public void onDestroy() {
    		// TODO Auto-generated method stub
    		super.onDestroy();
    		Log.i(TAG, "onDestroy");
    	}
    
    	@Override
    	public void onDetach() {
    		// TODO Auto-generated method stub
    		super.onDetach();
    		Log.i(TAG, "onDetach");
    	}
    	
    }
    从上面我们可以看到,LifeCycleFragment的每个生命周期函数都打印了日志,我来运行一下程序,看一下日志的打印情况如下图示:

    然后我们再点击一下Home键,日志打印的情况如下图示:

    然后我们再回到程序界面,日志的打印情况如下图示:

    最后我们点击回退键(Back)退出应用,日志的打印情况如下图示:

           依据上面对Fragment的管理生命周期的实例学习我们可知,管理Fragment的生命周期,和管理Activity的生命周期很类似,它们一般都包含Resumed、Paused和Stopped这三种状态。然而Fragment和Activity在生命周期方面也有一些差异,其中最大的区别就是各自如何在它的后台堆栈中存储。默认情况下,Activity被停止后,会被压入到由系统管理的Activity的后台堆栈(点击Back键回退到此Activity)。而Fragment被停止后,其实对象状态默认是不会被存放到堆栈中,除非当Fragment停止时调用addToBackStack()方法,此时才会将Fragment的对象状态压入到由宿主Activity管理的Fragment的后台堆栈。

    Fragment使用实例

           在我们实际开发中,在定义自己的Fragment类时,我们不需要重写Fragment全部的回调函数,但一般来讲,至少需重写并实现Fragment生命周期函数中的onCreate()、onCreateView()和onPause()这几个方法。在重写的onCreate()方法主要实例化一些在Fragment中需持久化的必要组件,在重写的onCreateView()方法中主要是返回当前Fragment的自定义根布局View和初始化布局中的一些控件对象,而在onPause()方法中主要是在用户离开Fragment时保存一些需要持久化的对象状态,下面有实现了三个方法的一个小例子,具体实例代码如下:
    public class ExampleFirstFragment extends Fragment {
    
    	@Override
    	public void onCreate(Bundle savedInstanceState) {
    		// TODO Auto-generated method stub
    		/**
    		 * 这里主要初始化一些在Fragment需使用和持久化的必要组件
    		 */
    		super.onCreate(savedInstanceState);
    		
    	}
    
    	@Override
    	public View onCreateView(LayoutInflater inflater, ViewGroup container,
    			Bundle savedInstanceState) {
    		// TODO Auto-generated method stub
    		/**
    		 * 使用inflate()方法加载一个自定义的Layout布局,该布局是Fragment的根布局view.
    		 * inflate()方法的3个参数:
    		 * 1.想要加载的Layout Resource Id;
    		 * 2.加载 Layout的父ViewGroup,目的是将Layout挂靠到container上;
    		 * 3.布尔值,指示是否将Layout附着到ViewGroup中,这里一般指定false,
    		 * 因为Layout已经附着到container上,若为true,系统将为Layout新建一个ViewGroup作为附着对象,多余;
    		 */
    		View inView = inflater.inflate(R.layout.fragment_main, container, false);
    		
    		/**
    		 * 这里主要是初始化Layout中的控件对象
    		 */
    		return inView;
    	}
    
    	@Override
    	public void onPause() {
    		// TODO Auto-generated method stub
    		super.onPause();
    		/**
    		 * 当用户离开此Fragment界面时,系统调用此方法,这里主要保存一些需要持久化的对象状态
    		 */
    	}
    }
    基本了解完如何自定义一个Fragment后,接下来我们将学习如何添加Fragment到Activity中并显示,一般的,有两种添加Fragment的方式,一种为静态添加,另外一种是动态添加。下面通过实例来更深入地学习两种方式的异同:

    静态添加Fragment

    首先创建两个自定义的Fragment,分别为AddFragmentFirst和AddFragmentSecond。AddFragmentFirst代码如下:
    public class AddFragmentFirst extends Fragment {
    
    	@Override
    	public void onCreate(Bundle savedInstanceState) {
    		// TODO Auto-generated method stub
    		super.onCreate(savedInstanceState);
    	}
    
    	@Override
    	public View onCreateView(LayoutInflater inflater, ViewGroup container,
    			Bundle savedInstanceState) {
    		// TODO Auto-generated method stub
    		View inView = inflater.inflate(R.layout.fragment_addfragmentfirst, container, false);
    		return inView;
    	}
    
    	@Override
    	public void onPause() {
    		// TODO Auto-generated method stub
    		super.onPause();
    	}
    }
    AddFragmentSecond代码如下:
    public class AddFragmentSecond extends Fragment {
    
    	@Override
    	public void onCreate(Bundle savedInstanceState) {
    		// TODO Auto-generated method stub
    		super.onCreate(savedInstanceState);
    		
    	}
    
    	@Override
    	public View onCreateView(LayoutInflater inflater, ViewGroup container,
    			Bundle savedInstanceState) {
    		// TODO Auto-generated method stub
    		View inView = inflater.inflate(R.layout.fragment_addfragmentsecond, container, false);
    		return inView;
    	}
    
    	@Override
    	public void onPause() {
    		// TODO Auto-generated method stub
    		super.onPause();
    	}
    }
    然后将两个自定义的Fragment添加到AddByStaticActivity中,AddByStaticActivity的代码如下:
    /**
     * 
     * @author AndroidLeaf
     * 静态添加Fragment
     *
     */
    public class AddByStaticActivity extends Activity {
    
    	@Override
    	protected void onCreate(Bundle savedInstanceState) {
    		// TODO Auto-generated method stub
    		super.onCreate(savedInstanceState);
    		setContentView(R.layout.activity_addbystatic);
    		
    	}
    }
    AddByStaticActivity的布局文件activity_addbystatic的代码如下:
    <LinearLayout 
       xmlns:android="http://schemas.android.com/apk/res/android"
       xmlns:tools="http://schemas.android.com/tools"
       android:layout_width="match_parent"
       android:layout_height="match_parent"
       android:orientation="horizontal"
       >
        <fragment
            android:layout_width="0dp"
            android:layout_weight="1"
            android:layout_height="match_parent"
            android:id="@+id/addfragment_first"
            android:name="com.androidleaf.fragmentdemo.fragment.AddFragmentFirst"
            />
         <fragment
            android:layout_width="0dp"
            android:layout_weight="1"
            android:layout_height="match_parent"
            android:id="@+id/addfragment_second"
            android:name="com.androidleaf.fragmentdemo.fragment.AddFragmentSecond"
            />
    </LinearLayout>
           以上代码中,<fragment>中的android:name属性指定了Activity layout实例化的Fragment类,同时也可以使用class属性也可完成同样的功能。当系统创建Activity layout时,它实例化layout中的每一个fragment类并回调fragment中的onCreateView()方法,返回并获取fragment的根布局view,然后将根布局View插入到<fragment>中。需要注意的是,每一个<fragment>都需要一个唯一标识,当Activity重启时,可以用来恢复fragment对象状态。一般的目前Android已经提供了三种方式来为fragment提供唯一标识,如下:
    1、为android:id提供唯一一个ID;
    2、为android:tag提供唯一一个字符;
    3、如果以上两种都没有提供,系统默认使用fragment的容器的ID;
    我们的示例程序使用了android:id属性为每个fragment提供唯一标识。
    那么所有的代码我们都已经写完了,下面我们运行一下程序,运行的效果如下:
       
           
    大功告成,两个fragment成功嵌入到Activity中。

    动态添加Fragment

           上面我们已经通过XML方式成功将fragment嵌入到Activity中(这种嵌入方式我们称为静态添加),但这种添加方式依然不够灵活.于是Android提供了另一种更加灵活的添加方式,也是我们日常开发中用的最多的一种添加方式----动态添加。
    动态添加顾名思义就是在程序运行时根据不同的情况动态地添加我们所需的fragment,下面我们将通过实例来学习如何动态添加Fragment。
    自定义一个AddByDynamicActivity,并根据屏幕宽高的变化,动态添加AddFragmentFirst和AddFragmentSecond,代码如下:
    public class AddByDynamicActivity extends Activity {
    
    	@SuppressLint("NewApi")
    	@Override
    	protected void onCreate(Bundle savedInstanceState) {
    		// TODO Auto-generated method stub
    		super.onCreate(savedInstanceState);
    		setContentView(R.layout.activity_addbydynamic);
    		
    		//获取屏幕宽高
    		DisplayMetrics mDisplayMetrics = new DisplayMetrics();
    		getWindowManager().getDefaultDisplay().getMetrics(mDisplayMetrics);
    		//1.根据上下文获取FragmentManager对象
    		FragmentManager manager = this.getFragmentManager();
    	
    		if(mDisplayMetrics.widthPixels < mDisplayMetrics.heightPixels){
    			//2.使用获取到的manager对象开启一个事务
    			FragmentTransaction mFragmentTransaction01 = manager.beginTransaction();
    			//3.替换Fragment
    			mFragmentTransaction01.replace(R.id.container, new AddFragmentFirst());
    			//4.提交事务
    			mFragmentTransaction01.commit();
    		}else{
    			FragmentTransaction mFragmentTransaction02 = manager.beginTransaction();
    			mFragmentTransaction02.replace(R.id.container, new AddFragmentSecond()).commit();
    		}
    		
    	}
    }
    AddByDynamicActivity的布局文件activity_addbydynamic的代码如下:
    <LinearLayout 
       xmlns:android="http://schemas.android.com/apk/res/android"
       xmlns:tools="http://schemas.android.com/tools"
       android:layout_width="match_parent"
       android:layout_height="match_parent"
       android:id="@+id/container"
       android:orientation="horizontal"
       />
    
    AddFragmentFirst和AddFragmentSecond的代码沿用上面学习静态添加Fragment时的代码。编写完成后,我们运行一下程序,显示的运行界面如下图所示:

    然后点击Ctrl + F11组合键(这里使用Android模拟器测试),程序显示的界面如下图所示:

    根据上面的运行结果我们可知,我们已经成功完成了根据不同的情况动态地添加或替换不同的Fragment对象的测试。接下来我们就此来深入的学习一下动态添加Fragment的具体编码步骤以及需要注意的地方。
             首先,要在Activity管理Fragment,我们需要使用Android API提供的FragmentManager类,我们可以通过Activity的getFragmentManager()方法获取FragmentManager对象,而要对Fragment进行添加、删除、隐藏或替换操作,则需对每个需要执行的操作开启一个事务(FragmentTransaction),我们可以通过FragmentManager对象的beginTransaction()方法开启。接着,我们可以根据具体需求使用add()、remove()、hide()或replace()方法来执行对Fragment的管理操作。最后,我们必须将每一个事务都提交到事务管理器中等待执行,Android提供了commit()和commitAllowingStateLoss()两个方法来执行事务提交,两个方法的区别是当使用commit()方法时,宿主Activity必须在保存它的状态(用户离开Activity)之前执行commit()提交操作,否则将会抛出一个异常,这是因为当activity再次被恢复时commit之后的状态将丢失。如果丢失也没关系,那么使用commitAllowingStateLoss()方法即可。这里需要注意的是,当事务提交完成后,事务并不会马上执行,而是由事务管理器安排的队列执行顺序,在必要时在宿主Activity的UI线程中执行。若不想等待要马上执行的话,可以在UI线程调用executePendingTransactions()来立即执行由commit()提交的事务. 但这么做通常不必要,除非事务是其他线程中的任务的一个从属。
    依据上面的代码实例,我们下面来总结一下动态添加Fragment的具体步骤:
             1、使用Activity的上下文对象的getFragmentManager()方法获取FragmentManager对象;
             2、使用获取到的FragmentManager对象开启一个事务(FragmentTransaction),调用beginTransaction()方法执行事务开启;
             3、使用开启的事务对象(FragmentTransaction)执行添加、隐藏、删除或替换(add()、hide()、remove() or replace())Fragment的操作;
             4、调用commit()或commitAllowingStateLoss()方法执行事务的提交。

    为Activity创建事件回调方法

             在一些情况下,Fragment需要建立与宿主Activity或和同一宿主Activity的姊妹Fragment的通信来完成相关操作功能。Fragment一般可以调用getActivity()方法来访问宿主Activity实例,同样的,宿主Activity也可以调用FragmentManager类中的findFragmentById()或findFramentByTag()方法来得到Fragment的引用对象,并依此来调用Fragment中的方法。而要建立两个属于同一个Activity的Fragment对象的通信,则最好的方法就是借助宿主Activity这个桥梁来完成信息的传递,就比如上面讲的那个列表新闻显示的例子(FragmentA显示新闻标题列表,FragmentB显示新闻的详细内容),当我们点击FragmentA中的列表选项时,则需要将列表选项的值传递给FragmentB,以便FragmentB根据用户点击的列表项显示对应的新闻内容。下面我们将使用代码简单地实现新闻显示这个例子,加深对Fragment的了解。我们先整理一下实现思路:首先定义一个宿主Activity(例子名中为ActivityForCallBackActivity),主要用于装载新闻列表的Fragment(例子中名为ActivityForCallBackFragmentA)和显示新闻内容详细的Fragment(例子中名为ActivityForCallBackFragmentB),然后在ActivityForCallBackFragmentA中定义一个事件回调方法,并在宿主ActivityForCallBackActivity实现其回调接口,这里使用回调主要作用是用于监听用户点击新闻列表项的事件,接着在宿主ActivityForCallBackActivity使用getFragmentManager().findFragmentById()方法获取显示新闻内容详细(ActivityForCallBackFragmentB)的实例,并在实现的回调方法onArticleSelected()方法中调用ActivityForCallBackFragmentB中的setContent()用于设置从ActivityForCallBackFragmentA传递过来的新闻Title。好了,基本思路已经理清,下面看下具体实现的代码。
            首先定义一个ActivityForCallBackActivity类作为两个Fragment的宿主Activity,该类的代码如下:
    /**
     * 
     * @author AndroidLeaf
     *	该示例主要实现新闻阅读例子
     */
    public class ActivityForCallBackActivity extends Activity implements OnArticleSelectedListener{
    
    	private ActivityForCallBackFragmentB mFragmentB;
    	@SuppressLint("NewApi")
    	@Override
    	protected void onCreate(Bundle savedInstanceState) {
    		// TODO Auto-generated method stub
    		super.onCreate(savedInstanceState);
    		setContentView(R.layout.activity_activityforcallback);
    		//获取ActivityForCallBackFragmentB新闻详细内容对象
    		mFragmentB = (ActivityForCallBackFragmentB) getFragmentManager().findFragmentById(R.id.activityforcallback_fragment_b);
    	}
    
    	@Override
    	public void onArticleSelected(int itemID,String title) {
    		// TODO Auto-generated method stub
    		//详细页显示新闻Title
    		mFragmentB.setContent(title);
    	}
    }

    布局文件activity_activityforcallback.xml的代码如下:

    <LinearLayout 
       xmlns:android="http://schemas.android.com/apk/res/android"
       xmlns:tools="http://schemas.android.com/tools"
       android:layout_width="match_parent"
       android:layout_height="match_parent"
       android:orientation="horizontal"
       >
        <fragment
            android:layout_width="0dp"
            android:layout_weight="1"
            android:layout_height="match_parent"
            android:id="@+id/activityforcallback_fragment_a" 
            android:name="com.androidleaf.fragmentdemo.fragment.ActivityForCallBackFragmentA"
            />
         <fragment
            android:layout_width="0dp"
            android:layout_weight="2"
            android:layout_height="match_parent"
            android:id="@+id/activityforcallback_fragment_b"
            android:name="com.androidleaf.fragmentdemo.fragment.ActivityForCallBackFragmentB"
            />
    </LinearLayout>
    
    然后创建展示新闻列表的ActivityForCallBackFragmentA.java类,代码如下:
    public class ActivityForCallBackFragmentA extends Fragment implements OnItemClickListener{
    
    	private ListView mListView;
    	ArrayAdapter<String> adapter = null;
    	ArrayList<String> list = null;
    	
    	/**
    	 * 创建一个事件回调函数,用来监听用户点击列表选项的操作
    	 */
    	public OnArticleSelectedListener mArticleSelectedListener;
    	
    	public interface OnArticleSelectedListener{
    		public void onArticleSelected(int itemID,String title);
    	}
    	
    	@Override
    	public void onAttach(Activity activity) {
    		// TODO Auto-generated method stub
    		super.onAttach(activity);
    		try {
    			//将宿主Activity对象强制转换成OnArticleSelectedListener实例,主要是为了确保宿主Activity实现监听接口
    			mArticleSelectedListener = (OnArticleSelectedListener) activity;
    		} catch (ClassCastException e) {
    			// TODO: handle exception
    			 throw new ClassCastException(activity.toString() + " must implement OnArticleSelectedListener");
    		}
    		
    	}
    
    	@Override
    	public void onCreate(Bundle savedInstanceState) {
    		// TODO Auto-generated method stub
    		super.onCreate(savedInstanceState);
    		/**
    		 * 初始化新闻列表的值
    		 */
    		list = new ArrayList<String>();
    		list.add("a");
    		list.add("b");
    		list.add("c");
    		list.add("d");
    		list.add("e");
    		list.add("f");
    		list.add("g");
    		adapter = new ArrayAdapter<String>(getActivity(), android.R.layout.simple_list_item_1, android.R.id.text1, list);
    	}
    
    	@Override
    	public View onCreateView(LayoutInflater inflater, ViewGroup container,
    			Bundle savedInstanceState) {
    		// TODO Auto-generated method stub
    		View inView = inflater.inflate(R.layout.fragment_activityforcallback_a, container, false);
    		mListView = (ListView)inView.findViewById(R.id.callback_listview);
    		mListView.setAdapter(adapter);
    		mListView.setOnItemClickListener(this);
    		return inView;
    	}
    
    	@Override
    	public void onPause() {
    		// TODO Auto-generated method stub
    		super.onPause();
    	}
    
    	@Override
    	public void onItemClick(AdapterView<?> parent, View view, int position,
    			long id) {
    		// TODO Auto-generated method stub
    		//将选中的列表选项ID和Title传递给实现监听接口的宿主Activity
    		mArticleSelectedListener.onArticleSelected(position,list.get(position));
    	}
    }
    布局文件fragment_activityforcallback_a.xml的代码如下:
    <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:tools="http://schemas.android.com/tools"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:id="@+id/callback_a_container"
        android:paddingBottom="@dimen/activity_vertical_margin"
        android:paddingLeft="@dimen/activity_horizontal_margin"
        android:paddingRight="@dimen/activity_horizontal_margin"
        android:paddingTop="@dimen/activity_vertical_margin"
       >
    	<ListView 
    	    android:layout_width="match_parent"
    	    android:id="@+id/callback_listview"
    	    android:layout_height="wrap_content"
    	    />
    </RelativeLayout>
    接着创建显示详细新闻内容的ActivityForCallBackFragmentB.java类,代码如下:
    public class ActivityForCallBackFragmentB extends Fragment{
    
    	private TextView mTextView;
    	@Override
    	public void onCreate(Bundle savedInstanceState) {
    		// TODO Auto-generated method stub
    		super.onCreate(savedInstanceState);
    	}
    
    	@Override
    	public View onCreateView(LayoutInflater inflater, ViewGroup container,
    			Bundle savedInstanceState) {
    		// TODO Auto-generated method stub
    		View inView = inflater.inflate(R.layout.fragment_activityforcallback_b, container, false);
    		mTextView = (TextView)inView.findViewById(R.id.callback_textview);
    		return inView;
    	}
    
    	@Override
    	public void onPause() {
    		// TODO Auto-generated method stub
    		super.onPause();
    	}
    	
    	public void setContent(String titleContent){
    		if(!TextUtils.isEmpty(titleContent)){
    			mTextView.setText(titleContent);
    		}
    	}
    }
    布局文件fragment_activityforcallback_b.xml代码如下:
    <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:tools="http://schemas.android.com/tools"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:background="#FF0000"
        android:paddingBottom="@dimen/activity_vertical_margin"
        android:paddingLeft="@dimen/activity_horizontal_margin"
        android:paddingRight="@dimen/activity_horizontal_margin"
        android:paddingTop="@dimen/activity_vertical_margin"
       >
    
        <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_centerInParent="true"
            android:textSize="50sp"
            android:textColor="#000000"
            android:id="@+id/callback_textview"
            />
    
    </RelativeLayout>
    
    代码编写完成,接下来运行程序,效果图如下图示:


    在Fragment中添加ActionBar
           在Fragment添加ActionBar的方法其实和在Activity添加ActionBar的方法类似,在这里就不再赘述,需要了解ActionBar使用方法的读者,可以学习(ActionBar简介和使用实例)这篇文章。不过读者使用时需要注意的一点是,当用户在Fragment中选择一个菜单项时,其宿主Activity会首先接收到对应的回调.如果Activity的on-item-selected回调函数实现并没有处理被选中的项目, 然后事件才会被传递到Fragment的回调。在文章末尾提供下载的Demo中有关于在Fragment添加ActionBar的具体例子,由于较为简单,这里就不贴出代码,读者可以下载Demo来进行学习。

    利用Fragment实现应用在手机和平板上的兼容实例

          Fragment起初是专门为了应用程序适配手机小屏幕和平板电脑大屏幕以达到应用在两者上运行能有最好的界面显示效果而设计的,例如对于屏幕尺寸较大的平板电脑,它有比一般手机设备更大的空间来显示更多的视图控件对象,那系统在运行应用时,当检测到是运行在较大屏幕尺寸的设备上时,系统将自动加载更大的屏幕界面布局,然后可以动态地添加Fragment来填充剩余的视图空间,最后实现更多的界面交互。不过由于Fragment有自己独立的生命周期,并可以在Activity中动态地被添加、删除或替换的特性,许多开发者在开发手机应用时也喜欢频繁使用Fragment来实现更加灵活的UI视图(即便应用不考虑或不需要在平板电脑上很好的显示界面)。下面我们通过一个新闻列表显示实例来学习如何使用Fragment来实现手机和平板的的适配,首先创建一个宿主Activity(例子中名为AdapterMobileAndPadActivity),主要用于装载Fragment和显示视图布局,代码如下:
    public class AdapterMobileAndPadActivity extends Activity{
    
    	@SuppressLint("NewApi")
    	@Override
    	protected void onCreate(Bundle savedInstanceState) {
    		// TODO Auto-generated method stub
    		super.onCreate(savedInstanceState);
    		setContentView(R.layout.activity_adaptermobile_and_pad);
    		
    	}
    }
    布局文件activity_adaptermobile_and_pad分为两处地方,一个是在res/layout文件路径下,另一个是res/layout-land文件路径下,如下图所示:

    res/layout/activity_adaptermobile_and_pad布局文件代码如下:
    <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:tools="http://schemas.android.com/tools"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="horizontal" >
    
        <fragment
            android:layout_width="0dp"
            android:layout_weight="1"
            android:layout_height="match_parent"
            android:id="@+id/adapter_article_list"
            android:name="com.androidleaf.fragmentdemo.fragment.AdapterArticleListFragment"
            />
    </LinearLayout>
    
    res/layout-land/activity_adaptermobile_and_pad布局文件代码如下:
    <LinearLayout 
       xmlns:android="http://schemas.android.com/apk/res/android"
       xmlns:tools="http://schemas.android.com/tools"
       android:layout_width="match_parent"
       android:layout_height="match_parent"
       android:orientation="horizontal"
       >
        <fragment
            android:layout_width="0dp"
            android:layout_weight="1"
            android:layout_height="match_parent"
            android:id="@+id/adapter_article_list"
            android:name="com.androidleaf.fragmentdemo.fragment.AdapterArticleListFragment"
            />
        <FrameLayout 
            android:layout_width="0dp"
            android:layout_weight="3"
            android:layout_height="match_parent"
            android:id="@+id/details_container"
            />
    	    
    </LinearLayout>
    
    两个文件夹中的同名布局文件分别为手机和平板界面的显示提供视图布局,当应用运行时,Android系统会根据当前运行环境来判断应用是否运行在大屏幕设备上,如果运行在大屏幕设备上,则加载res/layout-land下的布局文件,否则默认加载res/layout下的布局文件。关于动态加载界面布局的更多内容,可以学习( Android官方提供的支持不同屏幕大小的全部方法 )这篇文章。
    接下来创建新闻列表显示界面的Fragment(例子中名为AdapterArticleListFragment),具体的代码如下:
    public class AdapterArticleListFragment extends ListFragment{
    
    	/**
    	 * 判断当前加载的是否为大屏幕布局
    	 */
    	private boolean isScreenPad;
    	/**
    	 * 用来记录上次选中的项
    	 */
    	private int mCurrentPosition;
    	
    	/**
    	 * 列表测试数据
    	 */
    	public static String[] articleTitles = {
    		"a",
    		"b",
    		"c",
    		"d",
    		"e",
    		"f",
    		"g",
    	};
    	@Override
    	public void onCreate(Bundle savedInstanceState) {
    		// TODO Auto-generated method stub
    		super.onCreate(savedInstanceState);
    	}
    
    	@Override
    	public void onActivityCreated(Bundle savedInstanceState) {
    		// TODO Auto-generated method stub
    		super.onActivityCreated(savedInstanceState);
    		
    		//绑定数据列表
    		setListAdapter(new ArrayAdapter<>(getActivity(), android.R.layout.simple_list_item_1, android.R.id.text1, articleTitles));
    		
    		View details = getActivity().findViewById(R.id.details_container);
    		//检测是否使用大屏幕尺寸的布局
    		isScreenPad = details != null && details.getVisibility() == View.VISIBLE;
    		
    		if(savedInstanceState != null){
    			//获取上次离开界面时列表选项值
    			mCurrentPosition = savedInstanceState.getInt("currentChoice", 0);
    		}
    		if(isScreenPad){
    			//设置列表选中的选项高亮
    			getListView().setChoiceMode(ListView.CHOICE_MODE_SINGLE);
    			
    			showDetails(mCurrentPosition);
    		}
    	}
    
    	
    
    	@Override
    	public void onListItemClick(ListView l, View v, int position, long id) {
    		// TODO Auto-generated method stub
    		super.onListItemClick(l, v, position, id);
    		showDetails(position);
    	}
    
    	
    	/**
    	 * 离开界面时保存当前选中的选项的状态值
    	 */
    	@Override
    	public void onSaveInstanceState(Bundle outState) {
    		// TODO Auto-generated method stub
    		super.onSaveInstanceState(outState);
    		outState.putInt("currentChoice", mCurrentPosition);
    	}
    
    	/**
    	 * 
    	 * @param index
    	 */
    	public void showDetails(int index){
    		mCurrentPosition = index;
    		if(isScreenPad){
    			getListView().setItemChecked(index, true);
    			
    			AdapterArticleDetailFragment mDetailFragment = (AdapterArticleDetailFragment) getActivity().getFragmentManager().findFragmentById(R.id.details_container);
    			//若mDetailFragment为空或选中非当前显示的Fragment
    			if(mDetailFragment == null ||  mDetailFragment.showIndex() != index){
    				mDetailFragment = AdapterArticleDetailFragment.newInstance(index);
    				//替换Fragment实例对象
    				getActivity().getFragmentManager().beginTransaction().replace(R.id.details_container, mDetailFragment)
    				.setTransition(FragmentTransaction.TRANSIT_FRAGMENT_FADE)
    				.commit();
    			}
    		}else{
    			Intent mIntent = new Intent();
    	    	mIntent.setClass(getActivity(), AdapterArticleDetailActivity.class);
    	    	Bundle mBundle = new Bundle();
    	    	mBundle.putInt("index", index);
    	    	mIntent.putExtras(mBundle);
    	    	getActivity().startActivity(mIntent);
    		}
    	}
    	
    	@Override
    	public void onPause() {
    		// TODO Auto-generated method stub
    		super.onPause();
    	}
    }
    
    然后创建新闻内容详细显示的Fragment(例子中名为AdapterArticleDetailFragment),具体的代码如下:
    public class AdapterArticleDetailFragment extends Fragment{
    	
    	private TextView titleContent;
    	public static int index;
    	
    	/**
    	 * 实例化 AdapterArticleDetailFragment对象
    	 * @param index
    	 * @return AdapterArticleDetailFragment
    	 */
    	public static AdapterArticleDetailFragment newInstance(int index){
    		
    		AdapterArticleDetailFragment mAdapterArticleDetailFragment = new AdapterArticleDetailFragment();
    		Bundle mBundle = new Bundle();
    		mBundle.putInt("index", index);
    		//保存当前选中的选项ID
    		mAdapterArticleDetailFragment.setArguments(mBundle);
    		
    		return mAdapterArticleDetailFragment;
    	}
    	
    	/**
    	 * 获取当前显示的选项ID
    	 * @return int index
    	 */
    	public int showIndex(){
    		if(getArguments() == null){
    			return 0;
    		}
    		return getArguments().getInt("index",0);
    	}
    	
    	@Override
    	public void onCreate(Bundle savedInstanceState) {
    		// TODO Auto-generated method stub
    		super.onCreate(savedInstanceState);
    	}
    
    	@Override
    	public View onCreateView(LayoutInflater inflater, ViewGroup container,
    			Bundle savedInstanceState) {
    		// TODO Auto-generated method stub
    		View inView = inflater.inflate(R.layout.fragment_articledetails, container, false);
    		titleContent = (TextView)inView.findViewById(R.id.articledetails_textview);
    		//设置详情页的内容
    		titleContent.setText(AdapterArticleListFragment.articleTitles[getArguments().getInt("index",0)]);
    		return inView;
    	}
    
    	@Override
    	public void onPause() {
    		// TODO Auto-generated method stub
    		super.onPause();
    	}
    }
    布局文件fragment_articledetails的代码如下:
    <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:tools="http://schemas.android.com/tools"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:background="#FF0000"
        android:paddingBottom="@dimen/activity_vertical_margin"
        android:paddingLeft="@dimen/activity_horizontal_margin"
        android:paddingRight="@dimen/activity_horizontal_margin"
        android:paddingTop="@dimen/activity_vertical_margin"
       >
    
        <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_centerInParent="true"
            android:textSize="55sp"
            android:textColor="#000000"
            android:id="@+id/articledetails_textview"
            />
    
    </RelativeLayout>
    
    对于手机设备运行应用时,由于没有足够的空间同时容纳两个Fragment,因此需要新开启一个Activity(例子中名为AdapterArticleDetailActivity),具体的代码如下:
    public class AdapterArticleDetailActivity extends Activity{
    
    	@SuppressLint("NewApi")
    	@Override
    	protected void onCreate(Bundle savedInstanceState) {
    		// TODO Auto-generated method stub
    		super.onCreate(savedInstanceState);
    		setContentView(R.layout.activity_articledetails_activity);
    		
    		if(savedInstanceState == null){
    			AdapterArticleDetailFragment mArticleDetailFragment = new AdapterArticleDetailFragment();
    			mArticleDetailFragment.setArguments(getIntent().getExtras());
    			getFragmentManager().beginTransaction().add(R.id.article_details_act,mArticleDetailFragment).commit();
    		}
    	}
    }
    布局文件activity_articledetails_activity代码如下:
    <LinearLayout 
       xmlns:android="http://schemas.android.com/apk/res/android"
       xmlns:tools="http://schemas.android.com/tools"
       android:layout_width="match_parent"
       android:layout_height="match_parent"
       android:orientation="horizontal"
       android:id="@+id/article_details_act"
       >
    </LinearLayout>
    代码编写完毕,最后在Android手机模拟器上运行该程序,效果如图下:

    依据上图效果我们来分析下,当手机竖屏显示时,只显示新闻列表,点击选项新开启一个Activity用于显示新闻详细内容,然后点击Ctrl + F11切换至横屏,Android系统自动适配屏幕加载res/layout-land下的布局,同时显示新闻列表项和新闻内容详细页面。然后在Android 平板模拟器上运行该程序,效果图如下:

    自此,我们便达到了应用在手机和平板上都能完美显示视图界面的效果,Fragment的强大之处相信读者也已经切身感受到了。

    总结:由于Fragment其可独立管理自己的生命周期且可以被动态地添加、删除和替换的特性,它在实际开发中应用得非常频繁,因此开发人员必须深刻地理解Fragment各方面特点并熟练地运用。一般学习Fragment需要着重学习以下几点:(1)Fragment的生命周期管理;(2)如何动态添加、删除和替换Fragment;(3)如何建立Fragment与宿主Activity和建立Fragment与Fragment之间的通信;(4)利用Fragment适配手机和平板的视图界面显示。


    展开全文
  • Fragment的详细介绍和使用方法

    千次阅读 2016-05-10 07:18:09
    Fragment是Android3.0新增的概念,Fragment翻译成中文是碎片的意思,不过却和Activity十分的相似,这一篇我花大量的篇幅来详细的讲解Fragment的介绍和使用方法。 一、Fragment的基础知识介绍 1.1概述 ...

    Fragment是Android3.0新增的概念,Fragment翻译成中文是碎片的意思,不过却和Activity十分的相似,这一篇我花大量的篇幅来详细的讲解Fragment的介绍和使用方法。

    一、Fragment的基础知识介绍


    1.1概述


    1.1.1 特性


            Fragment是activity的界面中的一部分或一种行为。可以把多个Fragment组合到一个activity中来创建一个多界面

    并且可以在多个activity中重用一个Fragment。可以把Fragment任务模块化的一段activity,它具有自己的生命周期,

    接收它自己的事件,并可以在activity运行时被添加或删除。

           Fragment不能独立存在,它必须嵌入到activity中,而且Fragment的生命周期直接受所在的activity的影响。

    如:当activity暂停时,他拥有的所有的Fragment都暂停了,当activity销毁时,他拥有的所有Fragment都被销毁。然

    而,当activity运行时(在onResume()之后,onPause()之前),可以单独地操作每个Fragment,比如添加或删除它

    们。当中执行上述针对Fragment的事务时,可以将事务添加到一个栈中,这个栈被activity管理,栈中的每一条都是一

    个Fragment的一次事务。有了这个栈,就可以反向执行Fragment的事务,这样就可以在Fragment级支持“返回”键

    (向后导航)。

            当向activity中添加一个Fragment时,它须置于ViewGroup控件中,并且需定义Fragment自己的界面。可以在

    layout.xml布局文件中声明Fragment,元素为:<fragment>;也可以在代码中创建Fragment,然后把它加入到

    ViewGroup控件中。然而,Fragment不一定非要放在activity的界面中,它可以隐藏在后台为activity工作。


    1.1.2 生命周期


    onCreate():

         当创建fragment时系统调用此方法。在其中必须初始化fragment的基础组件们。可参考activity的说明;


    onCreateView():

         系统在fragment要画自己的界面时调用(在真正显示之前)此方法,这个方法必须返回fragment的layout的根控

    件,如果这个fragment不提供界面,那它应返回null;


    onPause():

         大多数程序应最少对fragment实现这三个方法,当然还有其它几个回调方法可应该按情况实现之,所有的声明周期

    回调函数在“操控fragment的生命周期”一节中有详细讨论。


    下图为fragment的生命周期(它所在的activity处于运行状态)



     Activity和Fragment生命周期对比图如下:


    两个的生命周期很类似,也息息相关。


    1.1.3 派生类


    DialogFragment

        显示一个浮动的对话框。使用这个类创建对话框是替代activity创建对话框的最佳选择。因为可以把fragmentdialog

    放入到activity的返回栈中,使用户能再返回到这个对话框。


    ListFragment

        显示一个列表控件,就像ListActivity类,它提供了很多管理列表的方法,比如onListItemClick()方法响应click事件。


    PreferenceFragment

        显示一个由Preference对象组成的列表,与PreferenceActivity相同。它用于为程序创建“设置”activity。


    1.2 范例


         写一个读新闻的程序,可以用一个fragment显示标题列表,另一个fragment显示选中标题的内容,这两个fragment

    都在一个activity上,并排显示。那么这两个fragment都有自己的生命周期并响应自己感兴趣的事件。于是,不需要再

    像手机上那样用一个activity显示标题列表,用另一个activity显示新闻内容;现在可以把两者放在一个activity上同时显

    示出来。如下图:


             

           Fragment必须被写成可重用的模块。因为fragment有自己的layout,自己进行事件响应,拥有自己的生命周期和

    行为,所以可以在多个activity中包含同一个Fragment的不同实例。这对于让世界在不同的屏幕尺寸下都能给用户完美

    的体验尤其重要。比如可以在程序运行于大屏幕中时启动包含很多fragment的activity,而在运行小屏幕时启动一个包

    含少量fragment的activity。

            刚才读新闻的程序,当检测到程序运行于大屏幕时,启动activityA,将标题列表和新闻内容这两个fragment都放

    在activityA中;当检测到程序运行于小屏幕时,还是启动activityA,但此时A中只有标题列表fragment,当选中一个标

    题时,activityA启动activityB,B中含有新闻内容fragment。


    1.3 创建Fragment


             要创建fragment,必须从Fragment或Fragment的派生类派生出一个类。Fragment的代码写起来有些像activity。

    它具有跟activity一样的回调方法,比如onCreate(),onStart(),onPause()和onStop()。实际上,如果想把老的程序改为

    使用fragment,基本上只需要把activity的回调方法的代码移到fragment中对应的方法即可。


    1.3.1添加有界面的Fragment


           Fragment一般作为activity的用户界面的一部分,把它自己layout嵌入到activity的layout中。一个要为fragment提

    供layout,必须实现onCreateView()回调方法,然后在这个方法中返回一个View对象,这个对象时fragment的layout的

    根。

           注意:如果fragment是从ListFragment中派生的,就不需要实现onCreateView()方法了,因为默认的实现已经返

    回了ListView控件对象。

           要从onCreateView()方法中返回layout对象,可以从layout.xml布局文件中生成layout对象。为了帮助这样做,

    onCreateView()提供了一个layoutInflater对象。举例:以下代码展示了一个Fragment的子类如何从layout.xml布局文件

    example_fragment.xml中生成对象。

    [java] view plain copy
    1. <span style="font-size:10px;">public static ExampleFragment extends Fragment {   
    2. @Override   
    3. publicView onCreateView(LayoutInflater inflater, ViewGroup container,   
    4. Bundle savedInstanceState) {   
    5. returninflater.inflate(R.layout.example_fragment, container, false);   
    6. }   
    7. }</span>  

           

         onCreateView()参数中的Container是存放fragment的layout的ViewGroup对象。saveInstanceState参数是一个

    Bundle,跟activity的onCreate()中Bundle差不多,用于状态恢复。但是fragment的onCreate()中也有Bundle参数,所

    以此处的Bundle中存放的数据与onCreate()中存放的数据还是不同的。

    Inflate()方法中有三个参数:

      <1> layout的资源ID;

      <2> 存放fragment的layout的ViewGroup;

      <3> 布尔数据表示是否在创建fragment的layout期间,把layout附加到container上(在这个例子中,因为系统已经把layout插入到container中了,所以值为false,如果为true会导致在最终的layout中创建多余的ViewGroup)。

          下面讲述如何把它添加到activity中。把fragment添加到activity一般情况下,fragment把它的layout作为activity的

    layout的一部分合并到activity中,有两种方法将一个fragment添加到activity中:


    方法一:在activity的layout.xml文件中声明fragment

    [html] view plain copy
    1. <?xmlversionxmlversion="1.0" encoding="utf-8" ?>  
    2. <LinearLayoutxmlns:androidLinearLayoutxmlns:android=" http://schemas.android.com/apk/res/android"   
    3. android:orientation="horizontal"   
    4. android:layout_width="match_parent"   
    5. android:layout_height="match_parent" >  
    6. <fragmentandroid:namefragmentandroid:name="com.android.cwj.ArticleListFragment"   
    7. android:id="@+id/list"   
    8. android:layout_weight="1"   
    9. android:layout_width="0dp"   
    10. android:layout_height="match_parent" />  
    11. <fragmentandroid:namefragmentandroid:name="com.android.cwj.ArticleReaderFragment"   
    12. android:id="@+id/viewer"   
    13. android:layout_weight="2"   
    14. android:layout_width="0dp"   
    15. android:layout_height="match_parent" />  
    16. </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属性赋一个字符串。

    如果没有使用上述任何一种方法,系统将使用fragment的容器的ID。

    方法二:在代码中添加fragment到一个ViewGroup

            这种方法可以在运行时,把fragment添加到activity的layout中。只需指定一个要包含fragment的ViewGroup。为

    了完成fragment的事务(比如添加,删除,替换等),必须使用FragmentTransaction的方法。可以从activity获取

    FragmentTransaction,如下:

    [java] view plain copy
    1. FragmentManager fragmentManager = getFragmentManager();  
    2. FragmentTransaction fragmentTransaction = fragmentManager.beginTransaction();  

             然后可以用add()方法添加一个fragment,它有参数用于指定容纳fragment的ViewGroup。如,Add()的第一个参数

    是容器ViewGroup,第二个是要添加的fragment。一旦通过FragmentTransaction对fragment做出了改变,必须调用方

    法commit()提交这些改变。不仅在无界面的fragment中,在有界面的fragment中也可以使用tag来作为唯一的标志,这

    样在需要获取fragment对象时,要调用findFragmentTag()。

     

    1.3.2 添加没有界面的Fragment

             上面演示了如何添加fragment来提供界面,然而,也可以使用fragment为activity提供后台的行为而不用显示

    fragment的界面。要添加一个没有界面的fragment,需要在activity中调用方法add(Fragment,String)(它支持用一个唯

    一的字符串做为fragment的“tag”,而不是viewID)。这样添加的fragment由于没有界面,所以在实现它时不需要调用

    实现onCreateView()方法。

            使用tag字符串来标示一个fragment并不是只能用于没有界面的fragment上,也可以把它用于有界面的fragment

    上,但是,如果一个fragment没有界面,tag字符串将成为它唯一的选择。获取以tag表示的fragment,需使用方法

    findFragmentByTab()。


    1.4 Fragment管理

          要管理fragment,需使用FragmentManager,要获取它,需在activity中调用方法getFragmentManager()。

    可以用FragmentManager来做以下事情:

          <1> 使用方法findFragmentById()或findFragmentByTag(),获取activity中已存在的fragment;

          <2> 使用方法popBackStack()从activity的后退栈中弹出fragment(这可以模拟后退键引发的动作),用方法addOnBackStackChangedListenner()注册一个侦听器以监视后退栈的变化;

          <3> 还可以使用FragmentManager打开一个FragmentTransaction来执行fragment的事务,比如添加或删除fragment。

           在activity中使用fragment的一个伟大的好处是能根据用户的输入对fragment进行添加、删除、替换以及执行其他

    动作的能力。提交的一组fragment的变化叫做一个事务。事务通过FragmentTransaction来执行。还可以把每个事务保

    存在activity的后退栈中,这样就可以让用户在fragment变化之间导航(跟在activity之间导航一样)。


    可以通过FragmentManager来取得FragmentTransaction的实例,如下:

    [java] view plain copy
    1. FragmentManager fragmentManager = getFragmentManager();  
    2. FragmentTransaction fragmentTransaction = fragmentManager.beginTransaction();  

     

    一个事务是在同一时刻执行的一组动作(很像数据库中的事务)。可以用add(),remove(),replace()等方法构成事务

    ,最后使用commit()方法提交事务。在调用commit()之前,可以用addToBackStack()把事务添加到一个后退栈中,这

    个后退栈属于所在的activity。有了它,就可以在用户按下返回键时,返回到fragment执行事务之前的状态。如下例:

    演示了如何用一个fragment代替另一个fragment,同时在后退栈中保存被代替的fragment的状态。

    [java] view plain copy
    1. //创建一个fragment  
    2. Fragment newFragment = new ExampleFragment();  
    3. //实例化fragment事务管理器  
    4. FragmentTransaction transaction = getFragmentManager().beginTransaction();  
    5.   
    6. //用新创建的fragment来代替fragment_container  
    7. transaction.replace(R.id.fragment_container,newFragment);  
    8. //添加进栈中  
    9. transaction.addToBackStack(null);  
    10.   
    11. //提交事务  
    12. transaction.commit();  

           解释:newFragment代替了控件ID R.id.fragment_container所指向的ViewGroup中所含的任何fragment。然后调

    用addToBackStack(),此时被代替的fragment就被放入后退栈中,于是当用户按下返回键时,事务发生回溯,原先的

    fragment又回来了。如果向事务添加了多个动作,比如多次调用了add(),remove()等之后又调用了addToBackStack(

    )方法,那么所有的在commit()之前调用的方法都被作为一个事务。

    当用户按返回键时,所有的动作都被反向执行(事务回溯)。

        

    事务中动作的执行顺序可随意,但要注意以下几点:

    <1> 必须最后调用commit();
    <2> 如果添加了多个fragment,那么它们的现实顺序跟添加顺序一致(后显示的覆盖前面的)

    <3> 如果在执行的事务中有删除fragment的动作,而且没有调用addToBackStack(),那么当事务提交时,那些被删除

    的fragment就被销毁了。反之,那些fragment就不会被销毁,而是处于停止状态。当用户返回时,它们会被恢复。

    <4> 但是,调用commit()后,事务并不会马上执行。它会在activity的UI线程(其实就是主线程)中等待直到现成能执

    行的时候才执行。如果必要,可以在UI线程中调用executePendingTransactions()方法来立即执行事务。但一般不需

    要这样做,除非有其它线程在等待事务的执行。

     

        注意:只能在activity处于可保存状态的状态时,比如running中,onPause()方法和onStop()方法中提交事务,否则

    会引发异常。这是因为fragment的状态会丢失。如果要在可能丢失状态的情况下提交事务,请使用

    commitAllowingStateLoss()。

     

    1.5 Fragment与Activity通讯

          

          尽管fragment的实现是独立于activity的,可以被用于多个activity,但是每个activity所包含的是同一个fragment的

    不同的实例。Fragment可以调用getActivity()方法很容易的得到它所在的activity的对象,然后查找activity中的控件

    们(findViewById())。         

           有时,可能需要fragment与activity共享事件。一个好办法是在fragment中定义一个回调接口,然后在activity中实

    现之。例如,还是那个新闻程序的例子,它有一个activity,activity中含有两个fragment。fragmentA显示新闻标题,

    fragmentB现实标题对应的内容。fragmentA必须在用户选择了某个标题时告诉activity,然后activity再告诉

    fragmentB,fragmentB就显示出对应的内容。

     

     二、Fragment实例讲解一

     

    2.1 实例效果图


    点击“存储”按钮显示的界面:

     

    点击wifi“按钮”显示的界面:



    2.2 项目结构


     

    2.3 具体代码编写


    1、左边页面布局界面,frag_list.xml:

    [html] view plain copy
    1. <?xml version="1.0" encoding="utf-8"?>  
    2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
    3.     android:layout_width="match_parent"  
    4.     android:layout_height="match_parent"  
    5.     android:orientation="vertical" >  
    6.   
    7.     <TextView  
    8.         android:layout_width="wrap_content"  
    9.         android:layout_height="wrap_content"  
    10.         android:text="无线和网络"  
    11.         android:textSize="30sp" />  
    12.   
    13.     <TextView  
    14.         android:layout_width="match_parent"  
    15.         android:layout_height="1px"  
    16.         android:background="@color/lineColor" />  
    17.   
    18.     <LinearLayout  
    19.         android:layout_width="match_parent"  
    20.         android:layout_height="wrap_content"  
    21.         android:layout_gravity="center_vertical"  
    22.         android:layout_marginLeft="10dp"  
    23.         android:orientation="horizontal" >  
    24.   
    25.         <TextView  
    26.             android:id="@+id/wifi"  
    27.             android:layout_width="wrap_content"  
    28.             android:layout_height="wrap_content"  
    29.             android:layout_gravity="center_vertical"  
    30.             android:text="WI-Fi"  
    31.             android:textSize="30sp" />  
    32.   
    33.         <ToggleButton  
    34.             android:id="@+id/toggleButton"  
    35.             android:layout_width="wrap_content"  
    36.             android:layout_height="wrap_content"  
    37.             android:layout_gravity="center_vertical"  
    38.             android:layout_marginLeft="20dp"  
    39.             android:text="开" />  
    40.     </LinearLayout>  
    41.   
    42.     <TextView  
    43.         android:layout_width="match_parent"  
    44.         android:layout_height="1px"  
    45.         android:background="@color/lineColor" />  
    46.   
    47.     <TextView  
    48.         android:layout_width="wrap_content"  
    49.         android:layout_height="wrap_content"  
    50.         android:text="设备"  
    51.         android:textSize="30sp" />  
    52.   
    53.     <TextView  
    54.         android:layout_width="match_parent"  
    55.         android:layout_height="1px"  
    56.         android:background="@color/lineColor" />  
    57.   
    58.     <TextView  
    59.         android:id="@+id/saveBut"  
    60.         android:layout_width="fill_parent"  
    61.         android:layout_height="wrap_content"  
    62.         android:layout_marginLeft="10dp"  
    63.         android:text="存储"  
    64.         android:textSize="35sp" />  
    65.   
    66. </LinearLayout>  

    2、右边页面布局界面,frag_detail.xml:

    [html] view plain copy
    1. <span style="font-size:12px;"><?xml version="1.0" encoding="utf-8"?>  
    2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
    3.     android:layout_width="match_parent"  
    4.     android:layout_height="match_parent"  
    5.     android:background="@color/right"  
    6.     android:orientation="vertical" >  
    7.   
    8.     <RelativeLayout  
    9.         android:id="@+id/save"  
    10.         android:layout_width="fill_parent"  
    11.         android:layout_height="fill_parent"  
    12.         android:layout_margin="10dp"  
    13.         android:visibility="gone" >  
    14.   
    15.         <include layout="@layout/save" />  
    16.     </RelativeLayout>  
    17.   
    18.     <RelativeLayout  
    19.         android:id="@+id/wifi"  
    20.         android:layout_width="fill_parent"  
    21.         android:layout_height="fill_parent"  
    22.         android:layout_margin="10dp"  
    23.         android:visibility="gone" >  
    24.   
    25.         <include layout="@layout/wifi" />  
    26.     </RelativeLayout>  
    27.   
    28. </LinearLayout></span>  

    3、主布局界面,main.xml:

    [html] view plain copy
    1. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
    2.     xmlns:tools="http://schemas.android.com/tools"  
    3.     android:layout_width="match_parent"  
    4.     android:layout_height="match_parent"  
    5.     android:orientation="horizontal"  
    6.     tools:context=".AndroidFragmentActivity" >  
    7.   
    8.     <!-- 主頁面 -->  
    9.     <!-- 左边页面 -->  
    10.   
    11.     <fragment  
    12.         android:id="@+id/frag_list"  
    13.         android:name="co.cm.fragement.FragementList"  
    14.         android:layout_width="fill_parent"  
    15.         android:layout_height="wrap_content"  
    16.         android:layout_weight="2" />  
    17.   
    18.     <!-- 右面页面 -->  
    19.   
    20.     <fragment  
    21.         android:id="@+id/frag_detail"  
    22.         android:name="co.cm.fragement.FragementDetails"  
    23.         android:layout_width="fill_parent"  
    24.         android:layout_height="wrap_content"  
    25.         android:layout_weight="1" />  
    26.   
    27. </LinearLayout>  

    4、list_item.xml:

    [html] view plain copy
    1. <?xml version="1.0" encoding="utf-8"?>  
    2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
    3.     android:layout_width="match_parent"  
    4.     android:layout_height="match_parent"  
    5.     android:background="@color/left"  
    6.     android:orientation="horizontal" >  
    7.   
    8.     <ImageView  
    9.         android:id="@+id/img"  
    10.         android:layout_width="wrap_content"  
    11.         android:layout_height="wrap_content" />  
    12.   
    13.     <TextView  
    14.         android:id="@+id/txt_title"  
    15.         android:layout_width="wrap_content"  
    16.         android:layout_height="wrap_content"  
    17.         android:text="Large Text"  
    18.         android:textAppearance="?android:attr/textAppearanceLarge" />  
    19.   
    20. </LinearLayout>  

    5、save.xml:

    [html] view plain copy
    1. <?xml version="1.0" encoding="utf-8"?>  
    2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
    3.     android:layout_width="match_parent"  
    4.     android:layout_height="match_parent"  
    5.     android:orientation="vertical" >  
    6.   
    7.     <TextView  
    8.         android:layout_width="match_parent"  
    9.         android:layout_height="1px"  
    10.         android:background="@color/lineColor" />  
    11.   
    12.     <TextView  
    13.         android:layout_width="wrap_content"  
    14.         android:layout_height="wrap_content"  
    15.         android:layout_marginLeft="10dp"  
    16.         android:text="内部存储空间"  
    17.         android:textSize="30sp" />  
    18.   
    19.     <TextView  
    20.         android:layout_width="wrap_content"  
    21.         android:layout_height="wrap_content"  
    22.         android:layout_marginBottom="5dp"  
    23.         android:layout_marginLeft="10dp"  
    24.         android:layout_marginTop="5dp"  
    25.         android:text="1GB/1.98GB"  
    26.         android:textSize="20sp" />  
    27.   
    28.     <TextView  
    29.         android:layout_width="match_parent"  
    30.         android:layout_height="1px"  
    31.         android:background="@color/lineColor" />  
    32.   
    33.     <TextView  
    34.         android:layout_width="wrap_content"  
    35.         android:layout_height="wrap_content"  
    36.         android:layout_marginLeft="20dp"  
    37.         android:text="总容量"  
    38.         android:textSize="30sp" />  
    39.   
    40.     <TextView  
    41.         android:layout_width="wrap_content"  
    42.         android:layout_height="wrap_content"  
    43.         android:layout_marginBottom="5dp"  
    44.         android:layout_marginLeft="20dp"  
    45.         android:layout_marginTop="5dp"  
    46.         android:text="1.98GB"  
    47.         android:textSize="20sp" />  
    48.   
    49.     <TextView  
    50.         android:layout_width="match_parent"  
    51.         android:layout_height="1px"  
    52.         android:background="@color/lineColor" />  
    53.   
    54. </LinearLayout>  

    6、wifi_list:

    [html] view plain copy
    1. <?xml version="1.0" encoding="utf-8"?>  
    2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
    3.     android:layout_width="match_parent"  
    4.     android:layout_height="match_parent"  
    5.     android:orientation="vertical" >  
    6.   
    7.     <TextView  
    8.         android:id="@+id/wifi_name"  
    9.         android:layout_width="match_parent"  
    10.         android:layout_height="wrap_content"  
    11.         android:text="qinjin_tp_2" />  
    12.   
    13.     <LinearLayout  
    14.         android:layout_width="match_parent"  
    15.         android:layout_height="wrap_content"  
    16.         android:orientation="horizontal" >  
    17.   
    18.         <TextView  
    19.             android:layout_width="wrap_content"  
    20.             android:layout_height="wrap_content"  
    21.             android:text="信号强度  :" />  
    22.   
    23.         <TextView  
    24.             android:id="@+id/wifi_name_state"  
    25.             android:layout_width="match_parent"  
    26.             android:layout_height="wrap_content"  
    27.             android:text="还没有连接" />  
    28.     </LinearLayout>  
    29.   
    30. </LinearLayout>  

    7、wifi.xml:

    [html] view plain copy
    1. <?xml version="1.0" encoding="utf-8"?>  
    2. <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"  
    3.     android:layout_width="match_parent"  
    4.     android:layout_height="match_parent"  
    5.     android:orientation="vertical" >  
    6.   
    7.     <LinearLayout  
    8.         android:id="@+id/wifiLinear"  
    9.         android:layout_width="match_parent"  
    10.         android:layout_height="wrap_content"  
    11.         android:orientation="vertical" >  
    12.   
    13.         <LinearLayout  
    14.             android:layout_width="match_parent"  
    15.             android:layout_height="wrap_content"  
    16.             android:orientation="vertical" >  
    17.   
    18.             <TextView  
    19.                 android:layout_width="wrap_content"  
    20.                 android:layout_height="wrap_content"  
    21.                 android:text="MAC地址  :"  
    22.                 android:textSize="@dimen/textsize" />  
    23.   
    24.             <TextView  
    25.                 android:id="@+id/mac_address"  
    26.                 android:layout_width="wrap_content"  
    27.                 android:layout_height="wrap_content"  
    28.                 android:text="MAC地址 "  
    29.                 android:textSize="@dimen/textsize" />  
    30.         </LinearLayout>  
    31.   
    32.         <LinearLayout  
    33.             android:layout_width="match_parent"  
    34.             android:layout_height="wrap_content"  
    35.             android:orientation="vertical" >  
    36.   
    37.             <TextView  
    38.                 android:layout_width="wrap_content"  
    39.                 android:layout_height="wrap_content"  
    40.                 android:text="接入点的BSSID :"  
    41.                 android:textSize="@dimen/textsize" />  
    42.   
    43.             <TextView  
    44.                 android:id="@+id/bssid"  
    45.                 android:layout_width="wrap_content"  
    46.                 android:layout_height="wrap_content"  
    47.                 android:text="接入点的BSSID "  
    48.                 android:textSize="@dimen/textsize" />  
    49.         </LinearLayout>  
    50.   
    51.         <LinearLayout  
    52.             android:layout_width="match_parent"  
    53.             android:layout_height="wrap_content"  
    54.             android:orientation="vertical" >  
    55.   
    56.             <TextView  
    57.                 android:layout_width="wrap_content"  
    58.                 android:layout_height="wrap_content"  
    59.                 android:text="IP地址: "  
    60.                 android:textSize="@dimen/textsize" />  
    61.   
    62.             <TextView  
    63.                 android:id="@+id/ip_address"  
    64.                 android:layout_width="wrap_content"  
    65.                 android:layout_height="wrap_content"  
    66.                 android:text="IP地址 "  
    67.                 android:textSize="@dimen/textsize" />  
    68.         </LinearLayout>  
    69.   
    70.         <LinearLayout  
    71.             android:layout_width="match_parent"  
    72.             android:layout_height="wrap_content"  
    73.             android:orientation="vertical" >  
    74.   
    75.             <TextView  
    76.                 android:layout_width="wrap_content"  
    77.                 android:layout_height="wrap_content"  
    78.                 android:text="id  "  
    79.                 android:textSize="@dimen/textsize" />  
    80.   
    81.             <TextView  
    82.                 android:id="@+id/id"  
    83.                 android:layout_width="wrap_content"  
    84.                 android:layout_height="wrap_content"  
    85.                 android:text="id "  
    86.                 android:textSize="@dimen/textsize" />  
    87.         </LinearLayout>  
    88.   
    89.         <LinearLayout  
    90.             android:layout_width="match_parent"  
    91.             android:layout_height="wrap_content"  
    92.             android:orientation="vertical" >  
    93.   
    94.             <TextView  
    95.                 android:layout_width="wrap_content"  
    96.                 android:layout_height="wrap_content"  
    97.                 android:text=" WifiInfo的所有信息包   "  
    98.                 android:textSize="@dimen/textsize" />  
    99.   
    100.             <TextView  
    101.                 android:id="@+id/info"  
    102.                 android:layout_width="wrap_content"  
    103.                 android:layout_height="wrap_content"  
    104.                 android:text="WifiInfo的所有信息包  "  
    105.                 android:textSize="@dimen/textsize" />  
    106.         </LinearLayout>  
    107.   
    108.         <ListView  
    109.             android:id="@+id/listview"  
    110.             android:layout_width="fill_parent"  
    111.             android:layout_height="fill_parent"  
    112.             android:layout_marginBottom="2dp" >  
    113.         </ListView>  
    114.     </LinearLayout>  
    115.   
    116.     <TextView  
    117.         android:id="@+id/wifiText"  
    118.         android:layout_width="wrap_content"  
    119.         android:layout_height="wrap_content"  
    120.         android:layout_centerInParent="true"  
    121.         android:text="要查看可用的网络,请打开wifi"  
    122.         android:textSize="@dimen/textsize" />  
    123.   
    124. </RelativeLayout>  

    8、主界面类,AndroidFragmentActivity.Java

    [java] view plain copy
    1. package co.cm.fragement;  
    2.   
    3. import co.cm.fragement.R;  
    4. import android.app.Activity;  
    5. import android.content.Context;  
    6. import android.os.Bundle;  
    7.   
    8. public class AndroidFragmentActivity extends Activity {  
    9.     // 主activity  
    10.     @Override  
    11.     public void onCreate(Bundle savedInstanceState) {  
    12.         super.onCreate(savedInstanceState);  
    13.         setContentView(R.layout.main);  
    14.         WifiAdmin.getWifiAdmin().setmContext(AndroidFragmentActivity.this);  
    15.         WifiAdmin.getWifiAdmin().getWifiMeathod();  
    16.     }  
    17. }  

    9、左面fragment界面类,FragmentList.java:

    [java] view plain copy
    1. package co.cm.fragement;  
    2.   
    3. import co.cm.fragement.R;  
    4.   
    5. import android.app.Fragment;  
    6. import android.os.Bundle;  
    7. import android.os.Handler;  
    8. import android.os.Message;  
    9. import android.util.Log;  
    10. import android.view.LayoutInflater;  
    11. import android.view.View;  
    12. import android.view.View.OnClickListener;  
    13. import android.view.ViewGroup;  
    14. import android.widget.CompoundButton;  
    15. import android.widget.CompoundButton.OnCheckedChangeListener;  
    16. import android.widget.LinearLayout;  
    17. import android.widget.TextView;  
    18. import android.widget.ToggleButton;  
    19.   
    20. /** 
    21.  * @author yuyang 
    22.  *  功能描述:左面fragment界面类,该类提供了选项操作 
    23.  */  
    24. public class FragementList extends Fragment {  
    25.     //点击切换到wifi存储界面  
    26.     private TextView wifi;  
    27.       
    28.     //点击切换到save存储界面  
    29.     private TextView saveBut;  
    30.       
    31.     //定义右面fragment实例  
    32.     private FragementDetails frag_detail;  
    33.       
    34.     //打开关闭wifi按钮  
    35.     private ToggleButton toggleButton;  
    36.           
    37.     //toggleButton按钮是否被点击  
    38.     private boolean isChecked = false;  
    39.       
    40.     //监听button状态线程标志位  
    41.     private boolean butIsRunning = false;  
    42.   
    43.     @Override  
    44.     public View onCreateView(LayoutInflater inflater, ViewGroup container,Bundle savedInstanceState) {  
    45.         // 在这里初始化fragment的页面  
    46.         return inflater.inflate(R.layout.frag_list, container, false);  
    47.     }  
    48.   
    49.     @Override  
    50.     public void onActivityCreated(Bundle savedInstanceState) {  
    51.         super.onActivityCreated(savedInstanceState);  
    52.         // 由于fragment不是activity,不是oncreated,而是onActivityCreated  
    53.         setView();  
    54.         setListener();  
    55.   
    56.         startThread();// 启动控制button的线程,当wifi状态不是在1或者3的时候,不可点击,  
    57.         // if (frag != null && frag.isInLayout()) {  
    58.         // switch (arg2) {  
    59.         // case 0:  
    60.         // frag.setText("0000");  
    61.     }  
    62.   
    63.     /** 
    64.      * 给按钮设置监听 
    65.      */  
    66.     public void setListener() {   
    67.         saveBut.setOnClickListener(new OnClickListener() {  
    68.             @Override  
    69.             public void onClick(View v) {  
    70.                 frag_detail.setSaveShow();  
    71.             }  
    72.         });  
    73.           
    74.         wifi.setOnClickListener(new OnClickListener() {  
    75.             @Override  
    76.             public void onClick(View v) {  
    77.                 frag_detail.setWifiShow();  
    78.                 Log.i("111", WifiAdmin.getWifiAdmin().checkState() + "===-=-");  
    79.                 checktoggleButton();// 当点回到wifi界面时,刷新button的状态  
    80.             }  
    81.         });  
    82.   
    83.         toggleButton.setOnClickListener(new OnClickListener() {  
    84.             @Override  
    85.             public void onClick(View v) {  
    86.                 Log.i("111", isChecked + "/" + WifiAdmin.getWifiAdmin().checkState());  
    87.                 if (isChecked) {  
    88.                     WifiAdmin.getWifiAdmin().OpenWifi();  
    89.                     frag_detail.setWifiShow();  
    90.                     // toggleButton.setText("关闭");  
    91.                     toggleButton.setChecked(false);  
    92.                     isChecked = false;  
    93.                 } else {  
    94.                     WifiAdmin.getWifiAdmin().CloseWife();  
    95.                     frag_detail.setWifiShow();  
    96.                     // toggleButton.setText("打开");  
    97.                     toggleButton.setChecked(true);  
    98.                     isChecked = true;  
    99.                 }  
    100.                 toggleButton.setClickable(false);  
    101.             }  
    102.         });  
    103.     }  
    104.   
    105.     //  
    106.     public void checktoggleButton() {  
    107.         if (WifiAdmin.getWifiAdmin().checkState() == 1) {  
    108.             toggleButton.setChecked(true);  
    109.             isChecked = true;  
    110.         }  
    111.         if (WifiAdmin.getWifiAdmin().checkState() == 3) {  
    112.             toggleButton.setChecked(false);  
    113.             isChecked = false;  
    114.         }  
    115.     }  
    116.   
    117.     public void setView() {  
    118.         wifi = (TextView) getView().findViewById(R.id.wifi);  
    119.         toggleButton = (ToggleButton) getView().findViewById(R.id.toggleButton);  
    120.         saveBut = (TextView) getView().findViewById(R.id.saveBut);  
    121.           
    122.         // 实例化右面界面,以便操纵里面的方法F  
    123.         frag_detail = (FragementDetails) getFragmentManager().findFragmentById(R.id.frag_detail);  
    124.           
    125.         // 初始化button的装态  
    126.         if (WifiAdmin.getWifiAdmin().checkState() == 3) {  
    127.             toggleButton.setChecked(false);  
    128.             isChecked = false;  
    129.         }  
    130.         if (WifiAdmin.getWifiAdmin().checkState() == 1) {  
    131.             toggleButton.setChecked(true);  
    132.             isChecked = true;  
    133.         }  
    134.         toggleButton.setClickable(true);  
    135.     }  
    136.   
    137.     @Override  
    138.     public void onDestroy() {  
    139.         frag_detail.stopWifiThread();  
    140.         butIsRunning = false;  
    141.         super.onDestroy();  
    142.     }  
    143.   
    144.     private void startThread() {  
    145.         butIsRunning = true;  
    146.         new Thread(new Runnable() {  
    147.   
    148.             @Override  
    149.             public void run() {  
    150.                 while (butIsRunning) {  
    151.                     //只有wifi状态改变变化完毕之后才能允许点击按钮  
    152.                     if (WifiAdmin.getWifiAdmin().checkState() == 3) {  
    153.                         if (!isChecked) {  
    154.                             toggleButton.setClickable(true);  
    155.                         }  
    156.   
    157.                     } else if (WifiAdmin.getWifiAdmin().checkState() == 1) {  
    158.                         if (isChecked) {  
    159.                             toggleButton.setClickable(true);  
    160.                         }  
    161.                     }  
    162.                 }  
    163.             }  
    164.         }).start();  
    165.     }  
    166.   
    167. }  

    10、右面fragment界面类

    [java] view plain copy
    1. package co.cm.fragement;  
    2.   
    3. import java.util.ArrayList;  
    4. import java.util.List;  
    5. import co.cm.fragement.R;  
    6. import android.app.Fragment;  
    7. import android.net.wifi.ScanResult;  
    8. import android.net.wifi.WifiConfiguration;  
    9. import android.os.Bundle;  
    10. import android.os.Handler;  
    11. import android.os.Message;  
    12. import android.util.Log;  
    13. import android.view.LayoutInflater;  
    14. import android.view.View;  
    15. import android.view.ViewGroup;  
    16. import android.widget.BaseAdapter;  
    17. import android.widget.LinearLayout;  
    18. import android.widget.ListView;  
    19. import android.widget.RelativeLayout;  
    20. import android.widget.TextView;  
    21.   
    22. /** 
    23.  * @author yangyu 
    24.  *  功能描述:右面fragment界面类,该类实现了右面显示的操作 
    25.  */  
    26. public class FragementDetails extends Fragment {  
    27.     private TextView mac_address, bssid, ip_address, id, info, wifiText;  
    28.       
    29.     private ListView listView;  
    30.       
    31.     private LinearLayout wifiLinear;  
    32.       
    33.     private RelativeLayout save, wifi;  
    34.       
    35.     private boolean ThreadFlag = false;  
    36.       
    37.     //wifi数据适配器  
    38.     private WifiAdapter wifiAdapter;  
    39.       
    40.     // 扫描出的网络连接列表  
    41.     private List<ScanResult> mWifiList = new ArrayList<ScanResult>();  
    42.       
    43.     // 网络连接列表  
    44.     private List<WifiConfiguration> mWifiConfiguration = null;  
    45.       
    46.     private int nowWifiState = 0;  
    47.   
    48.     @Override  
    49.     public View onCreateView(LayoutInflater inflater, ViewGroup container,Bundle savedInstanceState) {  
    50.         return inflater.inflate(R.layout.frag_detail, container, false);  
    51.     }  
    52.   
    53.     @Override  
    54.     public void onActivityCreated(Bundle savedInstanceState) {  
    55.         super.onActivityCreated(savedInstanceState);  
    56.         setView();  
    57.         // setListener();  
    58.         setWifiShow();  
    59.   
    60.     }  
    61.   
    62.     /** 
    63.      * 显示wifi界面 
    64.      */  
    65.     public void setWifiShow() {   
    66.         //通过隐藏显示来达到不同页面内容的切换  
    67.         save.setVisibility(View.GONE);  
    68.         wifi.setVisibility(View.VISIBLE);  
    69.         stopWifiThread();  
    70.         refreshWifi();  
    71.   
    72.     }  
    73.   
    74.     /** 
    75.      * 显示保存界面 
    76.      */  
    77.     public void setSaveShow() {  
    78.         stopWifiThread();  
    79.         save.setVisibility(View.VISIBLE);  
    80.         wifi.setVisibility(View.GONE);  
    81.     }  
    82.   
    83.     /** 
    84.      * 初始化组件 
    85.      */  
    86.     public void setView() {  
    87.         // -----------------wifi-----------------  
    88.         wifiText = (TextView) getView().findViewById(R.id.wifiText);  
    89.         mac_address = (TextView) getView().findViewById(R.id.mac_address);  
    90.         bssid = (TextView) getView().findViewById(R.id.bssid);  
    91.         ip_address = (TextView) getView().findViewById(R.id.ip_address);  
    92.         id = (TextView) getView().findViewById(R.id.id);  
    93.         info = (TextView) getView().findViewById(R.id.info);  
    94.         listView = (ListView) getView().findViewById(R.id.listview);  
    95.         wifiLinear = (LinearLayout) getView().findViewById(R.id.wifiLinear);  
    96.         save = (RelativeLayout) getView().findViewById(R.id.save);  
    97.         wifi = (RelativeLayout) getView().findViewById(R.id.wifi);  
    98.         wifiAdapter = new WifiAdapter();  
    99.         listView.setAdapter(wifiAdapter);  
    100.     }  
    101.   
    102.     private Handler handler = new Handler() {  
    103.         @Override  
    104.         public void handleMessage(Message msg) {  
    105.             nowWifiState = WifiAdmin.getWifiAdmin().checkState();  
    106.             // 当wifi打开时,刷新wifi列表的内容  
    107.             if (nowWifiState == 3) {  
    108.                 mWifiList = WifiAdmin.getWifiAdmin().GetWifiList();  
    109.                 // 如果刚开始检测的wifi列表为空,则创建一个实例化的wifi而不是null,负责会在adpter里面报错  
    110.                 if (mWifiList != null) {  
    111.                     // 如果wifi列表发生改变,则更新,else不更新  
    112.                     if (!mWifiList.toString().equals(  
    113.                             WifiAdmin.getWifiAdmin().getLastWifiList().toString())) {  
    114.                         WifiAdmin.getWifiAdmin().setLastWifiList(mWifiList);  
    115.                         wifiAdapter.notifyDate();  
    116.                     }  
    117.                 } else {  
    118.                     mWifiList = new ArrayList<ScanResult>();  
    119.                 }  
    120.             }  
    121.             refreshMeathod();  
    122.   
    123.             super.handleMessage(msg);  
    124.         }  
    125.     };  
    126.   
    127.     /** 
    128.      * 刷新wifi的状态  
    129.      */  
    130.     public void refreshWifi() {  
    131.         new Thread(new Runnable() {  
    132.             @Override  
    133.             public void run() {  
    134.                 ThreadFlag = true;  
    135.                 while (ThreadFlag) {  
    136.                     // Log.i("111", WifiAdmin.getWifiAdmin().checkState() +  
    137.                     // "!!!");  
    138.                     Message msg = handler.obtainMessage();  
    139.                     handler.sendMessage(msg);  
    140.                     try {  
    141.                         Thread.sleep(1000);  
    142.                     } catch (InterruptedException e) {  
    143.                         e.printStackTrace();  
    144.                     }  
    145.                 }  
    146.             }  
    147.         }).start();  
    148.     }  
    149.   
    150.     public void refreshMeathod() {        
    151.         // 此处可用switch  
    152.         if (nowWifiState == 3) {          
    153.             wifiLinear.setVisibility(View.VISIBLE);  
    154.             wifiText.setVisibility(View.INVISIBLE);  
    155.             mac_address.setText(WifiAdmin.getWifiAdmin().GetMacAddress() + "");  
    156.             bssid.setText(WifiAdmin.getWifiAdmin().GetBSSID() + "");  
    157.             ip_address.setText(WifiAdmin.getWifiAdmin().GetIPAddress() + "");  
    158.             id.setText(WifiAdmin.getWifiAdmin().GetNetworkId() + "");  
    159.             info.setText(WifiAdmin.getWifiAdmin().GetWifiInfo() + "");            
    160.         } else if (nowWifiState == 1) {  
    161.             wifiText.setVisibility(View.VISIBLE);  
    162.             wifiLinear.setVisibility(View.INVISIBLE);  
    163.             wifiText.setText("要查看可用的网络,请打开wifi");  
    164.         } else if (nowWifiState == 2) {  
    165.             wifiText.setVisibility(View.VISIBLE);  
    166.             wifiLinear.setVisibility(View.INVISIBLE);  
    167.             wifiText.setText("wifi正在打开");  
    168.         } else if (nowWifiState == 4) {  
    169.             wifiText.setVisibility(View.VISIBLE);  
    170.             wifiLinear.setVisibility(View.INVISIBLE);  
    171.             wifiText.setText("wifi正在关闭");  
    172.         } else {  
    173.             wifiText.setVisibility(View.VISIBLE);  
    174.             wifiLinear.setVisibility(View.INVISIBLE);  
    175.             wifiText.setText("我不知道wifi正在做什么");  
    176.         }  
    177.     }  
    178.   
    179.     public void stopWifiThread() {  
    180.         ThreadFlag = false;  
    181.     }  
    182.   
    183.     public class WifiAdapter extends BaseAdapter {  
    184.         @Override  
    185.         public int getCount() {           
    186.             return mWifiList.size();  
    187.         }  
    188.   
    189.         @Override  
    190.         public Object getItem(int position) {  
    191.             return mWifiList.get(position);  
    192.         }  
    193.   
    194.         @Override  
    195.         public long getItemId(int position) {  
    196.             return position;  
    197.         }  
    198.   
    199.         @Override  
    200.         public View getView(int position, View convertView, ViewGroup parent) {  
    201.             View view = convertView;  
    202.   
    203.             final ChatViewHolder vh;  
    204.   
    205.             if (convertView == null) {  
    206.                 vh = new ChatViewHolder();  
    207.                 view = View.inflate(WifiAdmin.getWifiAdmin().getmContext(),  
    208.                         R.layout.wifi_list, null);  
    209.                 vh.wifi_name = (TextView) view.findViewById(R.id.wifi_name);  
    210.   
    211.                 vh.wifi_name_state = (TextView) view  
    212.                         .findViewById(R.id.wifi_name_state);  
    213.   
    214.                 view.setTag(vh);  
    215.             } else {  
    216.                 vh = (ChatViewHolder) view.getTag();  
    217.             }  
    218.             vh.wifi_name.setText(mWifiList.get(position).SSID.toString());// 网络的名字,唯一区别WIFI网络的名字  
    219.             vh.wifi_name_state.setText(mWifiList.get(position).level + "");  
    220.             return view;  
    221.         }  
    222.   
    223.         public void notifyDate() {  
    224.             notifyDataSetChanged();  
    225.         }  
    226.   
    227.     }  
    228.   
    229.     public class ChatViewHolder {  
    230.         TextView wifi_name;// 网络的名字,唯一区别WIFI网络的名字  
    231.         TextView wifi_name_state;// 所发现的WIFI网络信号强度  
    232.     }  
    233.   
    234. }  

    11、wifiAdmin类,提供了wifi操作的方法,WifiAdmin.java:

    [java] view plain copy
    1. package co.cm.fragement;  
    2.   
    3. import java.util.ArrayList;  
    4. import java.util.List;  
    5.   
    6. import android.content.Context;  
    7. import android.net.wifi.ScanResult;  
    8. import android.net.wifi.WifiConfiguration;  
    9. import android.net.wifi.WifiInfo;  
    10. import android.net.wifi.WifiManager;  
    11. import android.net.wifi.WifiManager.WifiLock;  
    12. import android.util.Log;  
    13.   
    14. /** 
    15.  * @author yangyu 
    16.  *  wifiAdmin提供了wifi操作的方法 
    17.  */  
    18. public class WifiAdmin {  
    19.     private static WifiAdmin wifiAdmin;  
    20.       
    21.     private WifiManager mWifiManager = null;  
    22.       
    23.     private WifiInfo mWifiInfo = null;  
    24.       
    25.     // 扫描出的网络连接列表  
    26.     private List<ScanResult> mWifiList = new ArrayList<ScanResult>();  
    27.       
    28.     // 扫描出的网络连接列表  
    29.     private List<ScanResult> lastWifiList = new ArrayList<ScanResult>();  
    30.       
    31.     // 网络连接列表  
    32.     private List<WifiConfiguration> mWifiConfiguration = null;  
    33.       
    34.     private WifiLock mWifiLock = null;  
    35.           
    36.     // 上次网络状态  
    37.     private int lastWifiState = 0;  
    38.   
    39.     //定义上下文Context  
    40.     Context mContext;  
    41.   
    42.     public List<ScanResult> getLastWifiList() {  
    43.         return lastWifiList;  
    44.     }  
    45.   
    46.     public void setLastWifiList(List<ScanResult> lastWifiList) {  
    47.         this.lastWifiList = lastWifiList;  
    48.     }  
    49.   
    50.     public int getLastWifiState() {  
    51.         return lastWifiState;  
    52.     }  
    53.   
    54.     public void setLastWifiState(int lastWifiState) {  
    55.         this.lastWifiState = lastWifiState;  
    56.     }  
    57.   
    58.     public static WifiAdmin getWifi() {  
    59.         return wifiAdmin;  
    60.     }  
    61.   
    62.     public Context getmContext() {  
    63.         return mContext;  
    64.     }  
    65.   
    66.     public void setmContext(Context mContext) {  
    67.         this.mContext = mContext;  
    68.     }  
    69.   
    70.     public static WifiAdmin getWifiAdmin() {  
    71.         if (wifiAdmin == null) {  
    72.             wifiAdmin = new WifiAdmin();  
    73.   
    74.         }  
    75.         return wifiAdmin;  
    76.     }  
    77.   
    78.     public void getWifiMeathod() {  
    79.         mWifiManager = (WifiManager) mContext  
    80.                 .getSystemService(mContext.WIFI_SERVICE);  
    81.         mWifiInfo = mWifiManager.getConnectionInfo();  
    82.     }  
    83.   
    84.     /** 
    85.      * 打开wifi 
    86.      */  
    87.     public void OpenWifi() {  
    88.         if (!mWifiManager.isWifiEnabled()) {  
    89.             mWifiManager.setWifiEnabled(true);  
    90.         } else {  
    91.             Log.i("111""open 失败");  
    92.         }  
    93.     }  
    94.   
    95.     /** 
    96.      * 关闭wifi  
    97.      */  
    98.     public void CloseWife() {  
    99.         if (mWifiManager.isWifiEnabled()) {  
    100.             mWifiManager.setWifiEnabled(false);  
    101.         } else {  
    102.             Log.i("111""close 失败");  
    103.         }  
    104.     }  
    105.   
    106.     /** 
    107.      * 锁定wifi 
    108.      */  
    109.     public void lockWifi() {  
    110.         mWifiLock.acquire();  
    111.     }  
    112.   
    113.     public void rlockWifi() {  
    114.         if (mWifiLock.isHeld()) {  
    115.             mWifiLock.acquire();  
    116.         }  
    117.     }  
    118.   
    119.     // 检查当前wifi状态WIFI网卡的状态是由一系列的整形常量来表示的。  
    120.     //1.WIFI_STATE_DISABLED : WIFI网卡不可用(1)  
    121.     //2.WIFI_STATE_DISABLING : WIFI网卡正在关闭(0)  
    122.     //3.WIFI_STATE_ENABLED : WIFI网卡可用(3)  
    123.     //4.WIFI_STATE_ENABLING : WIFI网正在打开(2) (WIFI启动需要一段时间)  
    124.     //5.WIFI_STATE_UNKNOWN : 未知网卡状态  
    125.     public int checkState() {  
    126.         return mWifiManager.getWifiState();  
    127.     }  
    128.   
    129.     /** 
    130.      * 创建一个wifilock 
    131.      */  
    132.     public void Createwifilock() {  
    133.         mWifiLock = mWifiManager.createWifiLock("Testss");  
    134.     }  
    135.   
    136.     /** 
    137.      * 得到配置好的网络 
    138.      * @return 
    139.      */  
    140.     public List<WifiConfiguration> GetConfinguration() {  
    141.         return mWifiConfiguration;  
    142.     }  
    143.   
    144.     /** 
    145.      * 连接配置好的指定ID的网络 
    146.      * @param index 
    147.      */  
    148.     public void ConnectConfiguration(int index) {  
    149.         if (index > mWifiConfiguration.size()) {  
    150.             return;  
    151.         }  
    152.         mWifiManager.enableNetwork(mWifiConfiguration.get(index).networkId,true);  
    153.     }  
    154.   
    155.     /** 
    156.      * 开始扫描网络 
    157.      */  
    158.     public void StartScan() {  
    159.         mWifiManager.startScan();  
    160.         // 得到扫描结果  
    161.         mWifiList = mWifiManager.getScanResults();  
    162.         // 得到配置好的网络连接  
    163.         mWifiConfiguration = mWifiManager.getConfiguredNetworks();  
    164.     }  
    165.   
    166.     /** 
    167.      * 得到网络列表 
    168.      * @return 
    169.      */  
    170.     public List<ScanResult> GetWifiList() {  
    171.         mWifiManager.startScan();  
    172.         // 得到扫描结果  
    173.         mWifiList = mWifiManager.getScanResults();  
    174.         return mWifiList;  
    175.     }  
    176.   
    177.     public List<WifiConfiguration> getmWifiConfiguration() {  
    178.         return mWifiConfiguration;  
    179.     }  
    180.       
    181.     /** 
    182.      * 查看扫描结果 
    183.      */  
    184.     public StringBuilder LookUpScan() {  
    185.         StringBuilder stringBuilder = new StringBuilder();  
    186.         for (int i = 0; i < mWifiList.size(); i++) {  
    187.             stringBuilder.append("Index_" + new Integer(i + 1).toString() + ":");  
    188.             // 将ScanResult信息转换成一个字符串包  
    189.             // 其中把包括:BSSID、SSID、capabilities、frequency、level  
    190.             stringBuilder.append((mWifiList.get(i)).toString());  
    191.             stringBuilder.append("\n");  
    192.         }  
    193.         return stringBuilder;  
    194.     }  
    195.       
    196.     /** 
    197.      * 得到MAC地址 
    198.      */  
    199.     public String GetMacAddress() {  
    200.         return (mWifiInfo == null) ? "NULL" : mWifiInfo.getMacAddress();  
    201.     }  
    202.       
    203.     /** 
    204.      * 得到接入点的BSSID 
    205.      */  
    206.     public String GetBSSID() {  
    207.         return (mWifiInfo == null) ? "NULL" : mWifiInfo.getBSSID();  
    208.     }  
    209.       
    210.     /** 
    211.      * 得到IP地址 
    212.      */  
    213.     public int GetIPAddress() {  
    214.         return (mWifiInfo == null) ? 0 : mWifiInfo.getIpAddress();  
    215.     }  
    216.       
    217.     /** 
    218.      * 得到连接的ID 
    219.      */  
    220.     public int GetNetworkId() {  
    221.         return (mWifiInfo == null) ? 0 : mWifiInfo.getNetworkId();  
    222.     }  
    223.       
    224.     /** 
    225.      * 得到WifiInfo的所有信息包 
    226.      */  
    227.     public String GetWifiInfo() {  
    228.         return (mWifiInfo == null) ? "NULL" : mWifiInfo.toString();  
    229.     }  
    230.       
    231.     /** 
    232.      * 添加一个网络并连接 
    233.      */  
    234.     public void AddNetwork(WifiConfiguration wcg) {  
    235.         int wcgID = mWifiManager.addNetwork(wcg);  
    236.         mWifiManager.enableNetwork(wcgID, true);  
    237.     }  
    238.       
    239.     /** 
    240.      * 断开指定ID的网络 
    241.      */  
    242.     public void DisconnectWifi(int netId) {  
    243.         mWifiManager.disableNetwork(netId);  
    244.         mWifiManager.disconnect();  
    245.     }  
    246. }  

           

               小结: 当我们需要在一个界面中处理很多事情的时候,可以推荐使用fragment,因为他会把我们的activity分割成很多小块,每个小块都有他的生命周期,非常方便,而有时我们会用单例模式来存储每个页面都有的东西。


    三、Fragment实例讲解二

     

    3.1 项目的效果图                                          

                                               

     

    3.2 项目结构目录


     

    3.3 代码具体编写


    1、标题栏的布局界面,title_view.xml:

    [html] view plain copy
    1. <?xml version="1.0" encoding="utf-8"?>  
    2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
    3.     android:layout_width="fill_parent"  
    4.     android:layout_height="50dip"  
    5.     android:background="@drawable/title_bg"  
    6.     android:orientation="horizontal" >  
    7.   
    8.     <Button  
    9.         android:id="@+id/left_btn"  
    10.         style="@style/Text.Title_Button"  
    11.         android:layout_width="wrap_content"  
    12.         android:layout_height="35dip"  
    13.         android:layout_gravity="center_vertical"  
    14.         android:background="@drawable/title_btn_back"  
    15.         android:minWidth="60dip" />  
    16.   
    17.     <TextView  
    18.         android:id="@+id/title_text"  
    19.         style="@style/Text.Title"  
    20.         android:layout_width="fill_parent"  
    21.         android:layout_height="wrap_content"  
    22.         android:layout_gravity="center_vertical"  
    23.         android:layout_weight="1" />  
    24.   
    25.     <Button  
    26.         android:id="@+id/right_btn"  
    27.         style="@style/Text.Title_Button"  
    28.         android:layout_width="wrap_content"  
    29.         android:layout_height="35dip"  
    30.         android:layout_gravity="center_vertical"  
    31.         android:background="@drawable/title_btn"  
    32.         android:minWidth="70dip" />  
    33.   
    34. </LinearLayout>  

    2、首页的fragment页面,这里就列出一个,fragment_home.xml:

    [html] view plain copy
    1. <?xml version="1.0" encoding="utf-8"?>  
    2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
    3.     android:layout_width="fill_parent"  
    4.     android:layout_height="fill_parent"  
    5.     android:orientation="vertical" >  
    6.   
    7.     <com.eoe.tampletfragment.view.TitleView  
    8.         android:id="@+id/title"  
    9.         android:layout_width="fill_parent"  
    10.         android:layout_height="wrap_content" />  
    11.   
    12.     <TextView  
    13.         android:id="@+id/fragment_home_text"  
    14.         android:layout_width="fill_parent"  
    15.         android:layout_height="wrap_content"  
    16.         android:text="@string/fragment_home_text"  
    17.         android:textSize="18sp" />  
    18.   
    19. </LinearLayout>  

    3、帮助Activity界面,activity_help.xml:

    [html] view plain copy
    1. <?xml version="1.0" encoding="utf-8"?>  
    2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
    3.     android:layout_width="fill_parent"  
    4.     android:layout_height="fill_parent"  
    5.     android:background="@drawable/activity_bg"  
    6.     android:orientation="vertical" >  
    7.   
    8.     <com.eoe.tampletfragment.view.TitleView  
    9.         android:id="@+id/title"  
    10.         android:layout_width="fill_parent"  
    11.         android:layout_height="wrap_content" />  
    12.   
    13. </LinearLayout>  

    4、主页面布局,activity_main.xml:

    [html] view plain copy
    1. <?xml version="1.0" encoding="utf-8"?>  
    2. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
    3.     android:layout_width="fill_parent"  
    4.     android:layout_height="fill_parent"  
    5.     android:background="@drawable/activity_bg"  
    6.     android:orientation="vertical" >  
    7.   
    8.     <fragment  
    9.         android:id="@+id/fragment_home"  
    10.         android:layout_width="fill_parent"  
    11.         android:layout_height="fill_parent"  
    12.         android:layout_weight="1"  
    13.         class="com.eoe.tampletfragment.fragment.HomeFragment" />  
    14.   
    15.     <fragment  
    16.         android:id="@+id/fragment_search"  
    17.         android:layout_width="fill_parent"  
    18.         android:layout_height="fill_parent"  
    19.         android:layout_weight="1"  
    20.         class="com.eoe.tampletfragment.fragment.SearchFragment" />  
    21.   
    22.     <fragment  
    23.         android:id="@+id/fragment_settings"  
    24.         android:layout_width="fill_parent"  
    25.         android:layout_height="fill_parent"  
    26.         android:layout_weight="1"  
    27.         class="com.eoe.tampletfragment.fragment.SettingsFragment" />  
    28.   
    29.     <com.eoe.tampletfragment.fragment.FragmentIndicator  
    30.         android:id="@+id/indicator"  
    31.         android:layout_width="fill_parent"  
    32.         android:layout_height="wrap_content"  
    33.         android:background="@drawable/tab_footer_bg" />  
    34.   
    35. </LinearLayout>  

     详细说明:

      <1> 主页面MainActivity继承自FragmentActivity类,负责实现导航按钮所对应页面的显示和隐藏。
    (详细实现见源码)
      <2> 主页面由底部导航栏和面板组成。

      <3> fragment标签所对应Fragment的实现类。
      <4> com.eoe.tampletfragment.fragment.FragmentIndicator标签所对应的是底部导航栏。

       

    5、自定义顶部工具栏,TitleView.java:

    [java] view plain copy
    1. package com.eoe.tampletfragment.view;  
    2.   
    3. import android.content.Context;  
    4. import android.util.AttributeSet;  
    5. import android.view.LayoutInflater;  
    6. import android.view.View;  
    7. import android.widget.Button;  
    8. import android.widget.FrameLayout;  
    9. import android.widget.TextView;  
    10.   
    11. import com.eoe.tampletfragment.R;  
    12.   
    13. /** 
    14.  * @author yangyu 
    15.  *  功能描述:自定义顶部工具栏 
    16.  */  
    17. public class TitleView extends FrameLayout implements View.OnClickListener {  
    18.   
    19.     private Button mLeftBtn;  
    20.     private Button mRightBtn;  
    21.     private TextView mTitle;  
    22.   
    23.     private OnLeftButtonClickListener mOnLeftButtonClickListener;  
    24.     private OnRightButtonClickListener mOnRightButtonClickListener;  
    25.   
    26.     public interface OnLeftButtonClickListener {  
    27.         public void onClick(View button);  
    28.     }  
    29.   
    30.     public interface OnRightButtonClickListener {  
    31.         public void onClick(View button);  
    32.     }  
    33.   
    34.     public void setLeftButton(String text, OnLeftButtonClickListener listener) {  
    35.         mLeftBtn.setText(text);  
    36.         mLeftBtn.setVisibility(View.VISIBLE);  
    37.         mOnLeftButtonClickListener = listener;  
    38.     }  
    39.       
    40.     public void setLeftButton(int stringID, OnLeftButtonClickListener listener) {  
    41.         mLeftBtn.setText(stringID);  
    42.         mLeftBtn.setVisibility(View.VISIBLE);  
    43.         mOnLeftButtonClickListener = listener;  
    44.     }  
    45.       
    46.     public void removeLeftButton() {  
    47.         mLeftBtn.setText("");  
    48.         mLeftBtn.setVisibility(View.INVISIBLE);  
    49.         mOnLeftButtonClickListener = null;  
    50.     }  
    51.       
    52.     public void hiddenLeftButton() {  
    53.         mLeftBtn.setVisibility(View.INVISIBLE);  
    54.     }  
    55.       
    56.     public void showLeftButton() {  
    57.         mLeftBtn.setVisibility(View.VISIBLE);  
    58.     }  
    59.       
    60.     public void setRightButton(String text, OnRightButtonClickListener listener) {  
    61.         mRightBtn.setText(text);  
    62.         mRightBtn.setVisibility(View.VISIBLE);  
    63.         mOnRightButtonClickListener = listener;  
    64.     }  
    65.       
    66.     public void setRightButton(int stringID, OnRightButtonClickListener listener) {  
    67.         mRightBtn.setText(stringID);  
    68.         mRightBtn.setVisibility(View.VISIBLE);  
    69.         mOnRightButtonClickListener = listener;  
    70.     }  
    71.       
    72.     public void removeRightButton() {  
    73.         mRightBtn.setText("");  
    74.         mRightBtn.setVisibility(View.INVISIBLE);  
    75.         mOnRightButtonClickListener = null;  
    76.     }  
    77.       
    78.     public void hiddenRightButton() {  
    79.         mRightBtn.setVisibility(View.INVISIBLE);  
    80.     }  
    81.       
    82.     public void showRightButton() {  
    83.         mRightBtn.setVisibility(View.VISIBLE);  
    84.     }  
    85.   
    86.     public TitleView(Context context) {  
    87.         this(context, null);  
    88.     }  
    89.   
    90.     public TitleView(Context context, AttributeSet attrs) {  
    91.         this(context, attrs, 0);  
    92.     }  
    93.   
    94.     public TitleView(Context context, AttributeSet attrs, int defStyle) {  
    95.         super(context, attrs, defStyle);  
    96.   
    97.         LayoutInflater inflater = (LayoutInflater) context  
    98.                 .getSystemService(Context.LAYOUT_INFLATER_SERVICE);  
    99.         inflater.inflate(R.layout.title_view, thistrue);  
    100.   
    101.         mLeftBtn = (Button) findViewById(R.id.left_btn);  
    102.         mLeftBtn.setVisibility(View.INVISIBLE);  
    103.         mLeftBtn.setOnClickListener(this);  
    104.         mRightBtn = (Button) findViewById(R.id.right_btn);  
    105.         mRightBtn.setVisibility(View.INVISIBLE);  
    106.         mRightBtn.setOnClickListener(this);  
    107.           
    108.         mTitle = (TextView) findViewById(R.id.title_text);  
    109.         mTitle.setVisibility(View.INVISIBLE);  
    110.     }  
    111.       
    112.     public void setTitle(String text) {  
    113.         mTitle.setVisibility(View.VISIBLE);  
    114.         mTitle.setText(text);  
    115.     }  
    116.       
    117.     public void setTitle(int stringID) {  
    118.         mTitle.setVisibility(View.VISIBLE);  
    119.         mTitle.setText(stringID);  
    120.     }  
    121.   
    122.     @Override  
    123.     public void onClick(View v) {  
    124.         switch (v.getId()) {  
    125.         case R.id.left_btn:  
    126.             if(mOnLeftButtonClickListener != null)  
    127.                 mOnLeftButtonClickListener.onClick(v);  
    128.             break;  
    129.         case R.id.right_btn:  
    130.             if(mOnRightButtonClickListener != null)  
    131.                 mOnRightButtonClickListener.onClick(v);  
    132.             break;  
    133.         }  
    134.     }  
    135.   
    136. }  

    6、自定义底部工具栏,FragmentIndicator.java:

    [java] view plain copy
    1. package com.eoe.tampletfragment.fragment;