Fragment之间的通信方式对比

因为是基于项目而不是一个小demo来介绍Fragment之间如何通信的，特此提醒。

你只需要关注以下几个地方：

1、宿主Activity是如何showFragment的（方式1和方式2有区别）

2、每个Fragment定义了什么接口行为，这些接口行为在哪里触发回调，是Fragment还是Activity实现了该回调，是Fragment之间互相设置回调（方式1）还是通过Activity来中转（方式2）

3、方式1其实是不建议这样去实现，只是为了形成与方式2的对比，因为两个Fragment之间是不建议直接进行通信的

4、为了重用Fragment UI 组件，在设计中你应该通过定义每一个fragemnt自己的layout和行为，让fragment的自包含和模块化。一旦你定义了这些可重用的Fragment，你可以通过Activity将它们关联起来并通过程序的逻辑代码将他们连接起来以实现整体组合的UI（这其实就是方式2的逻辑，完全由宿主Activity掌控）。

5、觉得有用的同学可以自己提取一下方式2的实现，自己搞一个小demo或者应用到项目中，实践出真知

6、除了这两种实现方式，还有别的更好的方法的朋友，欢迎指正。

入正题，因为项目代码比较长，我只是截取了与该课题相关的部分代码。

我们先来看第一种实现方式：

1、RecordActivity：

[java] view plain copy 在CODE上查看代码片派生到我的代码片
  1. public class RecordActivity extends BaseActivity implements SoftKeyBoardStateListener{  
  2.       
  3.     private static final String TAG = "LiveRecordsActivity";    ...  
  4.     private void showFragment() {  
  5.         hidenLoadingDialog();  
  6.         if(SDCardUtil.getSdcardAvailableSpace()< 50.0*1024*1024){  
  7.             ToastUtils.toast(this, R.string.space_not_enough);  
  8.             finish();  
  9.             return;  
  10.         };  
  11.           
  12.         FragmentManager manager = getSupportFragmentManager();  
  13.         FragmentTransaction transaction = manager.beginTransaction();  
  14.         recordPlayerFragment = new RecordPlayerFragment(mRoom, mType, facing);  
  15.         recordfragment = new RecordFragment(mRoom, mType, facing);  
  16.         //通过两者之间的回调进行通信  
  17.         recordPlayerFragment.setCallback(recordfragment);  
  18.         recordfragment.setCallback(recordPlayerFragment);  
  19.         //看这里  
  20.         transaction.add(R.id.rl_live_records_detail_content, recordPlayerFragment);  
  21.         transaction.add(R.id.rl_live_records_detail_content, recordfragment);  
  22.           
  23.         transaction.commit();  
  24.         registerNetWorkReceiver();  
  25.     }  
  26.    ...  
  27. }  
2、RecordFragment：

实现RecordPlayerCallback接口

[java] view plain copy 在CODE上查看代码片派生到我的代码片
  1. public class RecordFragment extends LiveRecordsFragment implements RecordPlayerCallback{  
  2.       
  3.     private static final String TAG = "RecordFragment";  
  4.       
  5.     private int facing = Camera.CameraInfo.CAMERA_FACING_BACK; //前置摄像头还是后置摄像头  
  6.       
  7.     private boolean canChangeCamera = false;  
  8.       
  9.     private CameraChangeCallback callback;  
  10.       
  11.     public void setCallback(CameraChangeCallback callback) {  
  12.         this.callback = callback;  
  13.     }  
  14.   
  15.   
  16.     public RecordFragment(LiveRoom room, LiveRecordsType type, int facing) {  
  17.         super(room, type);  
  18.         this.facing = facing;  
  19.     }  
  20.       
  21.       
  22.     @Override  
  23.     public void onCreate(Bundle savedInstanceState) {  
  24.         super.onCreate(savedInstanceState);  
  25.     }  
  26.       
  27.     @Override  
  28.     public void onPause() {  
  29.         super.onPause();  
  30.         if(isClosedAlready){  
  31.             return;  
  32.         }  
  33.         LogHelper.i(TAG, "whb --------------onPause() 2");  
  34.         //当页面不可见时，关闭房间  
  35.         leaveRoom(mRoomID);  
  36.         LogHelper.i(TAG, "whb --------------onPause() end");  
  37.     }  
  38.       
  39.     @Override  
  40.     public void onDestroy() {  
  41.         super.onDestroy();  
  42.     }  
  43.       
  44.       
  45.     @Override  
  46.     public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {  
  47.         LogHelper.i(TAG, "-----------onCreateView");  
  48.         View rootView = super.onCreateView(inflater, container, savedInstanceState);  
  49.         initUI();  
  50.         return rootView;  
  51.     }  
  52.       
  53.       
  54.     private void initUI() {  
  55.         initCameras();  
  56.     }  
  57.       
  58.     private void initCameras() {  
  59.         if (!CameraUtil.canSwitchCameras()) {  
  60.             changeCameraBtn.setVisibility(View.GONE);  
  61.         }  
  62.     }  
  63.   
  64.   
  65.     /** 
  66.      * 根据采集过程中出现的问题显示不同的loading 
  67.      * @see com.storm.durian.fragments.RecordPlayerFragment.RecordPlayerCallback#showLoadingViewCallback(int, int) 
  68.      */  
  69.     @Override  
  70.     public void showLoadingViewCallback(int loadTextStringId, int resId) {  
  71.           
  72.         showLoadingView(loadTextStringId, resId);  
  73.     }  
  74.   
  75.   
  76.     /** 
  77.      * 停止采集的时候取消定时器 
  78.      * @see com.storm.durian.fragments.RecordPlayerFragment.RecordPlayerCallback#cancelTimerCallback() 
  79.      */  
  80.     @Override  
  81.     public void stopRecordCallback() {  
  82.         cancelTimer();  
  83.           
  84.     }  
  85.       
  86.     /** 
  87.      * 用户点击切换摄像头. 
  88.      * @see com.storm.durian.fragments.LiveRecordsFragment#changeCamera() 
  89.      */  
  90.     @Override  
  91.     protected void changeCamera() {  
  92.         super.changeCamera();  
  93.         LogHelper.e(TAG, "changeCamera  canChangeCamera = "+canChangeCamera);  
  94.           
  95.             if (callback != null) {  
  96.                 callback.changeCameraFace();  
  97.             }  
  98.            
  99.     }  
  100.   
  101.     /** 
  102.      * Function: 当点击切换摄像头时触发 
  103.      * date: 2015年9月18日 下午4:04:54 
  104.      */  
  105.     public interface CameraChangeCallback{  
  106.         public void changeCameraFace();  
  107.           
  108.     }  
  109.   
  110. }  
3、RecordPlayerFragment

实现CamerChangeCallback接口

[java] view plain copy 在CODE上查看代码片派生到我的代码片
  1. public class RecordPlayerFragment extends BaseFragment implements RenderListen,CameraChangeCallback {  
  2.       
  3.     private static final String TAG = "RecordPlayerFragment";  
  4.       
  5.     private RecordPlayerCallback callback;  
  6.       
  7.     public void setCallback(RecordPlayerCallback callback) {  
  8.         this.callback = callback;  
  9.     }  
  10.   
  11.     public RecordPlayerFragment(LiveRoom room, LiveRecordsType type, int facing) {  
  12.         this.facing = facing;  
  13.         this.mRoom = room;  
  14.     }  
  15.       
  16.     @Override  
  17.     public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {  
  18.         LogHelper.i(TAG, "-----------onCreateView");  
  19.         View rootView = inflater.inflate(R.layout.fragment_record_player, null);  
  20.         //initView(rootView);  
  21.         initUI(rootView);  
  22.         return rootView;  
  23.     }  
  24.       
  25.     /** 
  26.      * 开始采集 
  27.      */  
  28.     public void startRecord(){  
  29.     ...   
  30.     }  
  31.   
  32.     /** 
  33.      * 停止采集 
  34.      */  
  35.     public void stopRecord(){  
  36.         // 停止机器人策略和录播的时间  
  37.         if (callback != null) {  
  38.             callback.stopRecordCallback();  
  39.         }  
  40.     ...  
  41.     }  
  42.       
  43.     public void endPlayAndCapture(){  
  44.         stopRecord();  
  45.     }  
  46.       
  47.       
  48.     private void restartRecord(){  
  49.         ToastUtils.toastDebug(getActivity(), "重新启动采集");  
  50.         stopRecord();  
  51.         startRecord();  
  52.     }  
  53.       
  54.     private void onCaptureError(int MsgId, String info){  
  55.         ToastUtils.toastDebug(getActivity(), "采集错误 "+info);  
  56.         if (callback != null) {  
  57.             callback.showLoadingViewCallback(R.string.p2p_start_fail, R.drawable.ic_net_error);  
  58.         }  
  59.         stopRecord();  
  60.     }  
  61.       
  62.     private void onUploadInfo(int upload_info, int time) {  
  63.         String strInfo;  
  64.         int erroInfoId = R.string.p2p_upload_fail;  
  65.         switch (upload_info) {  
  66.           
  67.         }  
  68.         ToastUtils.toastDebug(getActivity(), strInfo);  
  69.         if (callback != null) {  
  70.             callback.showLoadingViewCallback(erroInfoId, R.drawable.ic_net_error);  
  71.         }  
  72.         // stop  
  73.         stopRecord();  
  74.     }  
  75.      
  76.     /** 
  77.      * 当点击切换摄像头时触发 
  78.      * @see com.storm.durian.fragments.RecordFragment.CameraChangeCallback#changeCameraFace() 
  79.      */  
  80.     @Override  
  81.     public void changeCameraFace() {  
  82.         if(canChangeCamera){  
  83.             int otherFacing = facing;  
  84.             if (facing == Camera.CameraInfo.CAMERA_FACING_BACK) {  
  85.                 otherFacing = Camera.CameraInfo.CAMERA_FACING_FRONT;  
  86.             } else {  
  87.                 otherFacing = Camera.CameraInfo.CAMERA_FACING_BACK;  
  88.             }  
  89.   
  90.             CameraSettings settings = CameraUtil.getCameraSettingsByFacing(otherFacing);  
  91.             if (settings == null) {  
  92.                 return;  
  93.             }  
  94.             capturePlayer.switchCamera(settings.getCameraId());  
  95.             facing = otherFacing;  
  96.             canChangeCamera = false;  
  97.         }          
  98.     }  
  99.       
  100.       
  101.     /** 
  102.      * Function: 需要回调到RecordFragment中的方法 
  103.      * date: 2015年9月18日 下午4:08:18 
  104.      */  
  105.     public interface RecordPlayerCallback{  
  106.         //根据采集过程中出现的问题显示不同的loading  
  107.         public void showLoadingViewCallback(int loadTextStringId, int resId);  
  108.         //停止采集  
  109.         public void stopRecordCallback();  
  110.           
  111.     }  
  112.       
  113. }  
总结一下第一种实现方式吧

第一步：创建出RecordFragment和RecordPlayerFragment的实例，然后分别设置对方为自己的回调对象

即：

[java] view plain copy 在CODE上查看代码片派生到我的代码片
  1. //通过两者之间的回调进行通信  
  2.        recordPlayerFragment.setCallback(recordfragment);  
  3.        recordfragment.setCallback(recordPlayerFragment);  
第二步：在RecordFragment中定义自己的行为接口

即：当我们触发CamerChangeCallback回调的时候通过changeCameraFace（）方法告诉RecordPlayerFragment收到回调应该做什么事

[java] view plain copy 在CODE上查看代码片派生到我的代码片
  1. public interface CameraChangeCallback{  
  2.         public void changeCameraFace();  
  3.           
  4.     }  
第三步：在RecordPlayerFragment中定义自己的行为接口

即：当我们触发RecordPlayerCallback回调的时候通过showLoadingViewCallBack()方法和stopRecordCallback()方法告诉RecordFragment收到回调应该做什么事

[java] view plain copy 在CODE上查看代码片派生到我的代码片
  1. public interface RecordPlayerCallback{  
  2.         //根据采集过程中出现的问题显示不同的loading  
  3.         public void showLoadingViewCallback(int loadTextStringId, int resId);  
  4.         //停止采集  
  5.         public void stopRecordCallback();  
  6.           
  7.     }  
第四步：分别让RecordFragment实现RecordPlayerCallback接口以及让RecordPlayerFragment实现CameraChangeCallback接口
第五步：在各自的回调当中分别处理各自的事情


第二种实现方式

还是在RecordActivity中：

[java] view plain copy 在CODE上查看代码片派生到我的代码片
  1. private void showFragment() {        
  2.        FragmentManager manager = getSupportFragmentManager();  
  3.        FragmentTransaction transaction = manager.beginTransaction();  
  4.        recordPlayerFragment = new RecordPlayerFragment(mRoom, mType, facing);  
  5.        recordfragment = new RecordFragment(mRoom, mType, facing);  
  6.        //通过两者之间的回调进行通信  
  7.        //recordPlayerFragment.setCallback(recordfragment);  
  8.        //recordfragment.setCallback(recordPlayerFragment);  
  9.          
  10.        transaction.add(R.id.rl_live_records_detail_content, recordPlayerFragment,"record_player_fragment");  
  11.        transaction.add(R.id.rl_live_records_detail_content, recordfragment,"record_fragment");  
  12.          
  13.        transaction.commit();  
  14.        registerNetWorkReceiver();  
  15.    }  

这里我们给RecordFragment和RecordPlayerFragment分别打上了标签，即record_fragment和record_player_fragment，方便之后通过findFragmentByTag找到相应的Fragment，如果你的实现方式可以通过id区分，也可以通过使用findFragmentById

这里我们允许Fragment与它所Attach的Activity进行通信，我们在RecordFragment和RecordPlayerFragment定义的接口在Activity中实现，Fragment在onAttach()回调函数中获取接口的具体实现的对象，然后，fragment就可以调用接口中的方法实现与Activity的通信

[java] view plain copy 在CODE上查看代码片派生到我的代码片
  1. public class RecordActivity extends BaseActivity implements RecordFragment.CameraChangeCallback,RecordPlayerFragment.RecordPlayerCallback{  
  2.       
  3.     private RecordFragment recordfragment;  
  4.       
  5.     private RecordPlayerFragment recordPlayerFragment;  
  6.   
  7.       
  8.     private void showFragment() {  
  9.          
  10.     }  
  11.   
  12.     /** 
  13.      * 当点击切换摄像头时触发 
  14.      * @see com.storm.durian.fragments.RecordFragment.CameraChangeCallback#changeCameraFace() 
  15.      */  
  16.     @Override  
  17.     public void changeCameraFace() {  
  18.         RecordPlayerFragment recordPlayerFrag = (RecordPlayerFragment)  
  19.                 getSupportFragmentManager().findFragmentByTag("record_player_fragment");  
  20.         if(recordPlayerFrag != null){  
  21.             recordPlayerFrag.changeCameraFace();  
  22.         }  
  23.     }  
  24.   
  25.     /** 
  26.      * 根据采集过程中出现的问题显示不同的loading 
  27.      * @see com.storm.durian.fragments.RecordPlayerFragment.RecordPlayerCallback#showLoadingViewCallback(int, int) 
  28.      */  
  29.     @Override  
  30.     public void showLoadingViewCallback(int loadTextStringId, int resId) {  
  31.         RecordFragment recordFrag = (RecordFragment)  
  32.                 getSupportFragmentManager().findFragmentByTag("record_fragment");  
  33.         if(recordFrag != null){  
  34.             recordFrag.showLoadingViews(loadTextStringId, resId);  
  35.         }  
  36.     }  
  37.   
  38.     /** 
  39.      * TODO 停止采集的时候取消定时器. 
  40.      * @see com.storm.durian.fragments.RecordPlayerFragment.RecordPlayerCallback#stopRecordCallback() 
  41.      */  
  42.     @Override  
  43.     public void stopRecordCallback() {  
  44.         RecordFragment recordFrag = (RecordFragment)  
  45.                 getSupportFragmentManager().findFragmentByTag("record_fragment");  
  46.         if(recordFrag != null){  
  47.             recordFrag.stopRecord();  
  48.         }  
  49.     }  
  50. }  
宿主Activity可以通过调用findFragmentByTag方法获取Fragment实例，然后直接调用Fragment的公有方法，将消息传递给Fragment。
[java] view plain copy 在CODE上查看代码片派生到我的代码片
  1. public class RecordFragment extends LiveRecordsFragment{  
  2.       
  3.     private static final String TAG = "RecordFragment";  
  4.       
  5.     private int facing = Camera.CameraInfo.CAMERA_FACING_BACK; //前置摄像头还是后置摄像头  
  6.       
  7.     private boolean canChangeCamera = false;  
  8.       
  9.     private CameraChangeCallback mCallback;  
  10.       
  11.     public void setCallback(CameraChangeCallback callback) {  
  12.         this.mCallback = callback;  
  13.     }  
  14.   
  15.   
  16.     public RecordFragment(LiveRoom room, LiveRecordsType type, int facing) {  
  17.         super(room, type);  
  18.         this.facing = facing;  
  19.     }  
  20.       
  21.       
  22.     @Override  
  23.     public void onAttach(Activity activity) {  
  24.         super.onAttach(activity);  
  25.      // 这是为了保证Activity容器实现了用以回调的接口。如果没有，它会抛出一个异常。  
  26.         try {  
  27.             mCallback = (CameraChangeCallback) activity;  
  28.         } catch (ClassCastException e) {  
  29.             throw new ClassCastException(activity.toString()  
  30.                     + " must implement CameraChangeCallback");  
  31.         }  
  32.     }  
  33.      
  34.   
  35.   
  36.     /** 
  37.      * 根据采集过程中出现的问题显示不同的loading 
  38.      */  
  39.     public void showLoadingViews(int loadTextStringId, int resId) {  
  40.           
  41.         showLoadingView(loadTextStringId, resId);  
  42.     }  
  43.   
  44.   
  45.     /** 
  46.      * 停止采集的时候取消定时器 
  47.      */  
  48.     public void stopRecord() {  
  49.         cancelTimer();  
  50.           
  51.     }  
  52.       
  53.     /** 
  54.      * 用户点击切换摄像头. 
  55.      */  
  56.     @Override  
  57.     protected void changeCamera() {  
  58.         super.changeCamera();  
  59.         LogHelper.e(TAG, "changeCamera  canChangeCamera = "+canChangeCamera);  
  60.           
  61.             if (mCallback != null) {  
  62.                 mCallback.changeCameraFace();  
  63.             }  
  64.            
  65.     }  
  66.   
  67.     /** 
  68.      * Function: 当点击切换摄像头时触发 
  69.      * date: 2015年9月18日 下午4:04:54 
  70.      */  
  71.     public interface CameraChangeCallback{  
  72.         public void changeCameraFace();  
  73.           
  74.     }  
  75.   
  76. }  
[java] view plain copy 在CODE上查看代码片派生到我的代码片
  1. public class RecordPlayerFragment extends BaseFragment implements RenderListen{  
  2.       
  3.     private static final String TAG = "RecordPlayerFragment";  
  4.       
  5.     private RecordPlayerCallback mCallback;  
  6.       
  7.     public void setCallback(RecordPlayerCallback callback) {  
  8.         this.mCallback = callback;  
  9.     }  
  10.   
  11.     public RecordPlayerFragment(LiveRoom room, LiveRecordsType type, int facing) {  
  12.         this.facing = facing;  
  13.         this.mRoom = room;  
  14.     }  
  15.       
  16.     @Override  
  17.     public void onAttach(Activity activity) {  
  18.         super.onAttach(activity);  
  19.      // 这是为了保证Activity容器实现了用以回调的接口。如果没有，它会抛出一个异常。  
  20.         try {  
  21.             mCallback = (RecordPlayerCallback) activity;  
  22.         } catch (ClassCastException e) {  
  23.             throw new ClassCastException(activity.toString()  
  24.                     + " must implement RecordPlayerCallback");  
  25.         }  
  26.     }  
  27.       
  28.     @Override  
  29.      
  30.     public void stopRecord(){  
  31.         // 停止机器人策略和录播的时间  
  32.         if (mCallback != null) {  
  33.             mCallback.stopRecordCallback();  
  34.         }  
  35.         capturePlayer.captureDone();  
  36.         canChangeCamera = false;  
  37.         LogHelper.e(TAG, "LiveHandler  canChangeCamera = "+canChangeCamera);  
  38.     }  
  39.     
  40.     private void onCaptureError(int MsgId, String info){  
  41.         ToastUtils.toastDebug(getActivity(), "采集错误 "+info);  
  42.        // showLoadingView(R.string.p2p_start_fail, R.drawable.ic_net_error);  
  43.         if (mCallback != null) {  
  44.             mCallback.showLoadingViewCallback(R.string.p2p_start_fail, R.drawable.ic_net_error);  
  45.         }  
  46.         stopRecord();  
  47.     }  
  48.       
  49.     private void onUploadInfo(int upload_info, int time) {  
  50.         String strInfo;  
  51.         int erroInfoId = R.string.p2p_upload_fail;  
  52.         switch (upload_info) {}  
  53.         ToastUtils.toastDebug(getActivity(), strInfo);  
  54.         if (mCallback != null) {  
  55.             mCallback.showLoadingViewCallback(erroInfoId, R.drawable.ic_net_error);  
  56.         }  
  57.         // stop  
  58.         stopRecord();  
  59.     }  
  60.       
  61.   
  62.     /** 
  63.      * 当点击切换摄像头时触发 
  64.      */  
  65.     public void changeCameraFace() {  
  66.         if(canChangeCamera){  
  67.             int otherFacing = facing;  
  68.             if (facing == Camera.CameraInfo.CAMERA_FACING_BACK) {  
  69.                 otherFacing = Camera.CameraInfo.CAMERA_FACING_FRONT;  
  70.             } else {  
  71.                 otherFacing = Camera.CameraInfo.CAMERA_FACING_BACK;  
  72.             }  
  73.   
  74.             CameraSettings settings = CameraUtil.getCameraSettingsByFacing(otherFacing);  
  75.             if (settings == null) {  
  76.                 return;  
  77.             }  
  78.             capturePlayer.switchCamera(settings.getCameraId());  
  79.             facing = otherFacing;  
  80.             canChangeCamera = false;  
  81.         }          
  82.     }  
  83.       
  84.       
  85.     /** 
  86.      * Function: 需要回调到RecordFragment中的方法 
  87.      * date: 2015年9月18日 下午4:08:18 
  88.      */  
  89.     public interface RecordPlayerCallback{  
  90.         //根据采集过程中出现的问题显示不同的loading  
  91.         public void showLoadingViewCallback(int loadTextStringId, int resId);  
  92.         //停止采集  
  93.         public void stopRecordCallback();  
  94.           
  95.     }  
  96.       
  97. }  

整体看来，第二种方式将所有的控制都交给了宿主Activity，通过Activity实现Fragment当中定义的各种接口，然后通过回调的方式来处理Activity与Fragment之间的通信，以及通过Activity获取Fragment实例并调用Fragment共有方法的方式实现Fragment之间的通信

所以，整体来看还是建议大家使用第二种方式。

很久没写博客了，今天就到这里。欢迎拍砖！

posted @ 2016-11-18 16:56  天涯海角路  阅读(200)  评论(0)    收藏  举报