Android中使用空白Fragment作为中间层的使用(未整理)

场景:

在日常开发中，常常遇到类似的场景：

• 权限申请，使我们通常在两个地方做权限通过与未通过的判断
• startActivityForResult来在两个页面间接收数据
• 微信SDK的相关操作，通常在一个专门的页面接收微信返回的数据，然后再通过一些方式传递给自己需要的页面。

…

当以上某个场景多次出现时候，会使代码变的额外的难以维护。而通过空白Fragment作为中间层，使返回的结果统一在Fragment中进行处理，可以使代码做到较好的解耦，另外在使用包装类对Fragment进行处理后，可以做到在一个地方做到数据的请求和回调，而不用写到两个地方。

参考链接:

https://github.com/qinhaihang/BaseLib

该文章使用空白Fragment对微信登录进行封装和处理进行演示：

使用方式：

  WXApiHelp.getInstance().init(this).wxLogin(new RouterWXCallBack() {
                    @Override
                    public void callBack(Map<String, String> map) {
                      //请求结果
                    }
                });

源码:

RouterWXCallBack.java

/**
 * 微信SDK回调
 */
public interface RouterWXCallBack {
    void callBack(Map<String,String> callBack);
}

RouterFragment.java

public class RouterFragment extends Fragment implements QCObserver {
    private List<WXApiHelp.WXCallBack> mCallBacks = new ArrayList<>();
    private IWXAPI api;
    public RouterFragment() {
    }

    public static RouterFragment getInstance(){
        return new RouterFragment();
    }

    @Override
    public void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setRetainInstance(true);
        MsgMgr.getInstance().attach(this);
    }

    public void wxLogin(WXApiHelp.WXCallBack wxCallBack){
        mCallBacks.add(wxCallBack);
        if (null == api){
            api = WXAPIFactory.createWXAPI(getContext(), BuildConfig.WX_PAY_APPID, false);
            api.registerApp(BuildConfig.WX_PAY_APPID);
        }
        if (!api.isWXAppInstalled()){
            DqToast.showShort("您还未安装微信客户端！");
            return;
        }
        final SendAuth.Req req = new SendAuth.Req();
        req.scope = "snsapi_userinfo";
        req.state = "dqApp";
        api.sendReq(req);
    }
	
    //微信请求回的结果会返回到这里，使用方式可以参考EventBus
    @Override
    public void onMessage(String key, Object value) {
        DqLog.e("YM------------>收到回调返回状态:"+key);
        DqLog.e("YM------------>mCallBacks是否为null:"+mCallBacks.isEmpty());
        switch (key){
            case MsgType.WX_USER_INFO:
                //收到消息
                if (!mCallBacks.isEmpty()){
                    WXApiHelp.WXCallBack routerWXCallBack = mCallBacks.get(0);
                    routerWXCallBack.callBack(value.toString());
                    mCallBacks.clear();
                }
                break;
        }
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        MsgMgr.getInstance().detach(this);
    }
}

WXApiHelp.java

public class WXApiHelp {
    private static final String REQUEST_CAPTURE = "request_capture";
    private WeakReference<FragmentActivity> mWeakActivityRef;
    private static WXApiHelp instance;

    public static WXApiHelp getInstance() {
        if (instance == null) {
            synchronized (WXApiHelp.class) {
                if (instance == null) {
                    instance = new WXApiHelp();
                }
            }
        }
        return instance;
    }

    public WXApiHelp init(FragmentActivity activity){
        mWeakActivityRef = new WeakReference<>(activity);
        return instance;
    }

    private RouterFragment getFragment(){

        FragmentManager manager = mWeakActivityRef.get().getSupportFragmentManager();
        RouterFragment fragment = (RouterFragment)manager.findFragmentByTag(REQUEST_CAPTURE);

        if(fragment == null){
            fragment = RouterFragment.getInstance();
            manager.beginTransaction()
                    .add(fragment,REQUEST_CAPTURE)
                    .commitAllowingStateLoss();
            manager.executePendingTransactions();
        }

        return fragment;
    }

    public void release(){

        if(mWeakActivityRef != null && mWeakActivityRef.get() != null){

            FragmentManager manager = mWeakActivityRef.get().getSupportFragmentManager();
            RouterFragment fragment = (RouterFragment)manager.findFragmentByTag(REQUEST_CAPTURE);

            if(fragment != null){
                fragment = RouterFragment.getInstance();
                manager.beginTransaction()
                        .remove(fragment)
                        .commitAllowingStateLoss();
                manager.executePendingTransactions();
            }
            instance = null;
            mWeakActivityRef.clear();

        }
    }

    public void wxLogin(RouterWXCallBack routerWXCallBack){
        getFragment().wxLogin(new WXCallBack() {
            @Override
            public void callBack(String callBack) {
                Map<String,String> map = new HashMap<>();
                try {
                    JSONObject jsonObject = new JSONObject(callBack);
                    Iterator<String> iterable = jsonObject.keys();
                    while (iterable.hasNext()){
                        String jsonKey = iterable.next();
                        String jsonValue = jsonObject.optString(jsonKey,"");
                        map.put(jsonKey,jsonValue);
                    }
                } catch (JSONException e) {
                    e.printStackTrace();
                }
                if (null != routerWXCallBack){
                    routerWXCallBack.callBack(map);
                }
            }
        });
    }

    public interface WXCallBack{
        void callBack(String callBack);
    }

}