封装sdk——包装模式

最近在升级环信的sdk，一打开旧版的代码，坑爹的，都是直接调用sdk的接口，没有任何封装，连续吐血两个星期来算替换完成，为了后人重蹈覆辙，我决定升级的过程中用包装模式对sdk进行封装，搞一个中间层来做转换，把业务和sdk的api分离，以后升级sdk的话，直接在这个中间层进行修改即可。

先说说包装模式

简单来说是一个管理器，不继承任何的类，而是直接持有被调用api的对象，然暴露方法给外界间接地调用api

模版：

public class LiClient {

    volatile public static LiClient instance;

    private EMConnectionListener mConnectionListener;

    private List<LiConnectionListener> mLiConnectionListeners;

    private EMClient mClient;

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

        return instance;
    }

    private LiClient() {
        mClient = EMClient.getInstance();
        mLiConnectionListeners = new ArrayList<>();
        mConnectionListener = new EMConnectionListener() {
            @Override
            public void onConnected() {
                for (LiConnectionListener listener : mLiConnectionListeners) {
                    listener.onConnected();
                }
            }

            @Override
            public void onDisconnected(int errorCode) {
                for (LiConnectionListener listener : mLiConnectionListeners) {
                    listener.onDisconnected(errorCode);
                }
            }
        };
        mClient.addConnectionListener(mConnectionListener);
    }

    public void login(String userName, String password,final LiCallback callback) {
        mClient.login(userName, password, new EMCallBack() {
            @Override
            public void onSuccess() {
                if (null == callback || callback.isCancel()) {
                    return;
                }
                callback.onSuccess(1, null);
            }

            @Override
            public void onError(int i, String s) {
                if (null == callback || callback.isCancel()) {
                    return;
                }
                callback.onError(i, LiException.create(i, s));
            }

            @Override
            public void onProgress(int i, String s) {
            }
        });
    }

    public void logout(final LiCallback callback) {
        EMClient.getInstance().logout(true, new EMCallBack() {
            @Override
            public void onSuccess() {
                if (null != callback) {
                    callback.onSuccess(1, null);
                }
            }

            @Override
            public void onError(int i, String s) {
                if (null != callback) {
                    callback.onError(1, LiException.create(i, s));
                }
            }

            @Override
            public void onProgress(int i, String s) {

            }
        });
    }

    public void addConnectionListener(LiConnectionListener listener) {
        if (null != listener && !mLiConnectionListeners.contains(listener)) {
            mLiConnectionListeners.add(listener);
        }
    }

    public void removeConnectionListener(LiConnectionListener listener) {
        if (null != listener && mLiConnectionListeners.contains(listener)) {
            mLiConnectionListeners.remove(listener);
        }
    }

    public interface LiConnectionListener {
        void onConnected();
        void onDisconnected(final int errorCode);
    }
}

暴露出去的方法，基本都是做一下转化，

如果涉及到监听接口或者回调，就照搬过来，换上自己的名字