Fragment初学8——Fragment在Android开发中的应用2

2021-07-07 16:15:17

Fragment都是依附于Activity的，通信方式大致也分为如下几种：

  1. 如果Activity中包含自己管理的Fragment的引用，可以通过直接引用访问所有的Fragment的public方法
  2.  如果Activity中未保存任何Fragment的引用，那么可以通过 getFragmentManager.findFragmentByTag()或者findFragmentById()获得任何Fragment实 例，然后进行操作。
  3. 在Fragment中可以通过getActivity得到当前绑定的Activity的实例，然后进行操作。

注意：如果在Fragment中需要Context，可以通过调用getActivity(),如果该Context需要在Activity被销毁后还存在，则使用getActivity().getApplicationContext()。

因为要考虑Fragment的重复使用，所以必须降低Fragment与Activity的耦合，而且Fragment更不应该直接操作别的Fragment，毕竟Fragment操作应该由它的管理者Activity来决定。

下面通过两种方式分别重构FragmentOne和FragmentTwo的点击事件，以及Activity对点击事件的响应：


FragmentOne.java如下

public class FragmentOne extends Fragment {
    private Button mButton;

    /**
     * 设置按钮点击的回调接口
     * 
     */
    public interface BtnOneClickListener {
        void onBtnOneClick();
    }

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
            Bundle savedInstanceState) {
        // return inflater.inflate(R.layout.fragment_one, container, false);
        View view = inflater.inflate(R.layout.fragment_one, container, false);
        mButton = (Button) view.findViewById(R.id.btn_fragment_one);
        mButton.setOnClickListener(new OnClickListener() {
            // 由所属的Activity处理
            @Override
            public void onClick(View v) {
                if (getActivity() instanceof BtnOneClickListener) {
                    ((BtnOneClickListener) getActivity()).onBtnOneClick();
                }
            }
        });
        return view;
    }
}
现在FragmentOne不和任何Activity耦合，任何Activity都可以使用；同时声明了一个接口回调其点击事件，想要管理其点击事件的Activity实现此接口就即可。可以看到我们在onClick中首先判断了当前绑定的Activity是否实现了该接口，如果实现了则调用。

FragmentTwo.java类如下
public class FragmentTwo extends Fragment {

    private Button mButton;
    private BtnTwoClickListener mBtnTwoClickListener;

    public interface BtnTwoClickListener {
        void onBtnTwoClick();
    }
      //设置回调接口  
    public void setBtnTwoClickListener(BtnTwoClickListener btnTwoClickListener)  
    {  
        this.mBtnTwoClickListener = btnTwoClickListener;  
    } 
    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
            Bundle savedInstanceState) {
        // return inflater.inflate(R.layout.fragment_one, container, false);
        View view = inflater.inflate(R.layout.fragment_two, container, false);
        mButton = (Button) view.findViewById(R.id.btn_fragment_two);
        mButton.setOnClickListener(new OnClickListener() {

            @Override
            public void onClick(View v) {
                 if(mBtnTwoClickListener != null)  
                    {  
                     mBtnTwoClickListener.onBtnTwoClick();  
                    }  
            }
        });
        return view;
    }
}


代码大致和FragmentOne结构相同，与FragmentOne不同的是我们提供了setListener这样的方法，意味着Activity不仅需要实现该接口，还必须显示调用mButton.setBtnTwoClickListener(this)。

MainActivity类如下
public class MainActivity extends Activity implements BtnOneClickListener,BtnTwoClickListener{

    private FragmentOne mFragmentOne;  
    private FragmentTwo mFragmentTwo;  
    private FragmentThree mFragmentThree; 
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        requestWindowFeature(Window.FEATURE_NO_TITLE);
        // getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
        // WindowManager.LayoutParams.FLAG_FULLSCREEN);
        setContentView(R.layout.activity_main);
        mFragmentOne=new FragmentOne();
        FragmentManager fragmentManager = getFragmentManager();
        FragmentTransaction transaction = fragmentManager.beginTransaction();
        transaction.add(R.id.framelayout_fragment_main, mFragmentOne, "ONE");
        transaction.commit();
    }

    @Override
    public void onBtnOneClick() {
        if (mFragmentTwo == null)  
        {  
            mFragmentTwo = new FragmentTwo();  
            mFragmentTwo.setBtnTwoClickListener(this);  
        }  
        FragmentManager fragmentManager = getFragmentManager();  
        FragmentTransaction transaction = fragmentManager.beginTransaction();  
        transaction.replace(R.id.framelayout_fragment_main, mFragmentTwo, "TWO");  
        transaction.addToBackStack(null);  
        transaction.commit(); 
    }
    @Override
    public void onBtnTwoClick() {
        if (mFragmentThree == null)  
        {  
            mFragmentThree = new FragmentThree();  

        }  
        FragmentManager fm = getFragmentManager();  
        FragmentTransaction transaction = fm.beginTransaction();  
        transaction.hide(mFragmentTwo);  
        transaction.add(R.id.framelayout_fragment_main, mFragmentThree, "THREE");  
        transaction.addToBackStack(null);  
        transaction.commit(); 
    }
}
通过重构，项目效果和上一节的效果是一样的，这两种通信方式都是值得推荐的，我建议还是选择第二种。虽然Fragment和Activity可以通过getActivity与 findFragmentByTag或者findFragmentById进行任何操作，甚至在Fragment里面操作另外的Fragment，但是除非万不得已还是别用。Activity担任的是Fragment间类似总线一样的角色，应当由它决定Fragment的操作。另外Fragment不能响应Intent，但是Activity可以，Activity可以接收Intent，然后根据参数判断显示哪个 Fragment。
可说了这么多，我们有没有发现，这些都是理想的情况下，一旦运行时配置发生变化，例如屏幕发生旋转，屏幕会重新加载，很多人觉得强制设置屏幕方向不变就可以了，以前我也这样做，但是当应用被置于后台（例如用户点击了home键）长时间没有返回的时候，应用也会被重新启动。 比如上例：如果把上面的例子置于FragmentThree界面，然后处于后台状态，长时间后你会发现当你再次通过home打开时，上面 FragmentThree与FragmentOne叠加在一起，这就是因为你的Activity重新启动，在原来的FragmentThree上又绘制 了一个FragmentOne。

为了体现一下效果，再写个简单的FragmentOne.java

public class FragmentOne extends Fragment {

     private static final String TAG = "xmr";  


    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
            Bundle savedInstanceState) {
        // return inflater.inflate(R.layout.fragment_one, container, false);
        View view = inflater.inflate(R.layout.fragment_one, container, false);

        return view;
    }
    @Override  
    public void onCreate(Bundle savedInstanceState)  
    {  
        // TODO Auto-generated method stub  
        super.onCreate(savedInstanceState);  

        Log.i(TAG, "onCreate");  
    }  

    @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");  
    }  

}

MainActivity.java
public class MainActivity extends Activity {

    private FragmentOne mFragmentOne;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        requestWindowFeature(Window.FEATURE_NO_TITLE);
        // getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
        // WindowManager.LayoutParams.FLAG_FULLSCREEN);
        setContentView(R.layout.activity_main);
        mFragmentOne = new FragmentOne();
        FragmentManager fragmentManager = getFragmentManager();
        FragmentTransaction transaction = fragmentManager.beginTransaction();
        transaction.add(R.id.framelayout_fragment_main, mFragmentOne, "ONE");
        transaction.commit();
    }

}
不断的旋转屏幕，你会发现每旋转一次屏幕，屏幕上就多了一个FragmentOne的实例，并且后台log会打印出许多套生命周期的回调。
Fragment初学8——Fragment在Android开发中的应用2

其实在上一节 Fragment状态管理 已经提到过，当屏幕发生旋转时，Activity会重新启动，默认的Activity中的Fragment也会跟着Activity重新创建，这就造成当旋转的时候，本身存在的Fragment会重新启动，然后当执行Activity的onCreate时，又会再次实例化一个新的Fragment， 这就是出现的原因。

解决办法就是通过检查onCreate的参数Bundle savedInstanceState判断当前是否发生Activity的重新创建。

简单改一下代码，只有在savedInstanceState==null时，才进行创建Fragment实例：

public class MainActivity extends Activity {

    private FragmentOne mFragmentOne;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        requestWindowFeature(Window.FEATURE_NO_TITLE);
        // getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
        // WindowManager.LayoutParams.FLAG_FULLSCREEN);
        setContentView(R.layout.activity_main);
        if (savedInstanceState != null) {
            mFragmentOne = new FragmentOne();
            FragmentManager fragmentManager = getFragmentManager();
            FragmentTransaction transaction = fragmentManager
                    .beginTransaction();
            transaction
                    .add(R.id.framelayout_fragment_main, mFragmentOne, "ONE");
            transaction.commit();
        }
    }

}


现在无论进行多次旋转都只会有一个Fragment实例在Activity中。但是这并解决所有问题，例如当重新绘制时，Fragment发生重建，原本的数据如何保持？

其实和Activity类似，Fragment也有onSaveInstanceState的方法，在此方法中进行保存数据，然后在onCreate或者onCreateView或者onActivityCreated进行恢复都可以。

Fragment与ActionBar和MenuItem集成

Fragment可以添加自己的MenuItem到Activity的ActionBar或者可选菜单中。使用方法也很简单：

1、在Fragment的onCreate中调用setHasOptionsMenu(true);

2、然后在Fragment子类中实现onCreateOptionsMenu

3、如果希望在Fragment中处理MenuItem的点击，也可以实现onOptionsItemSelected，当然了Activity也可以直接处理该MenuItem的点击事件。
public class FragmentOne extends Fragment {

    private static final String TAG = "xmr";

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
            Bundle savedInstanceState) {
        // return inflater.inflate(R.layout.fragment_one, container, false);
        View view = inflater.inflate(R.layout.fragment_one, container, false);
        Button mButton = (Button) view.findViewById(R.id.btn_fragment_one);
        return view;
    }

    @Override
    public void onCreate(Bundle savedInstanceState) {
        // TODO Auto-generated method stub
        super.onCreate(savedInstanceState);
        setHasOptionsMenu(true);
    }

    @Override
    public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
        // TODO Auto-generated method stub
        super.onCreateOptionsMenu(menu, inflater);
        inflater.inflate(R.menu.menu_fragment, menu);
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        switch (item.getItemId()) {
        case R.id.item1_menu_fragment:
            Toast.makeText(getActivity(), "fragment1", Toast.LENGTH_SHORT)
                    .show();
            return true;
        case R.id.item2_menu_fragment:
            Toast.makeText(getActivity(), "fragment1", Toast.LENGTH_SHORT)
                    .show();
            return true;
        default:
            return true;
        }
    }

    @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");
    }

}


public class MainActivity extends Activity {

    private FragmentOne mFragmentOne;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        requestWindowFeature(Window.FEATURE_NO_TITLE);
        // getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
        // WindowManager.LayoutParams.FLAG_FULLSCREEN);
        setContentView(R.layout.activity_main);
        if (savedInstanceState == null) {
            mFragmentOne = new FragmentOne();
            FragmentManager fragmentManager = getFragmentManager();
            FragmentTransaction transaction = fragmentManager
                    .beginTransaction();
            transaction
                    .add(R.id.framelayout_fragment_main, mFragmentOne, "ONE");
            transaction.commit();
        }
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        // TODO Auto-generated method stub
         super.onCreateOptionsMenu(menu);
        getMenuInflater().inflate(R.menu.main, menu);
        return true;
    }
      @Override  
        public boolean onOptionsItemSelected(MenuItem item)  
        {  
            switch (item.getItemId())  
            {  
            case R.id.action_settings:  
                Toast.makeText(this, "setting", Toast.LENGTH_SHORT).show();  
                return true;  
            default:  
                //如果希望Fragment自己处理MenuItem点击事件，一定不要忘了调用super.xxx  
                return super.onOptionsItemSelected(item);  
            }  
        } 
}


源代码


参考：

上一篇：SVN-简要说明


下一篇：[小北De编程手记] : Lesson 04 玩转 xUnit.Net 之 Fixture（下）