CNLive Android Team / CNChatSDK · Files

package io.rong.imlib;

import android.content.Context;
import android.net.Uri;
import android.telephony.TelephonyManager;
import android.text.TextUtils;
import android.util.Log;

import com.cnlive.libs.util.Config;
import com.cnlive.libs.util.NetUtil;
import com.cnlive.libs.util.data.okhttp3.Call;
import com.cnlive.libs.util.data.okhttpUtil.callback.GenericsCallback;

import org.apache.http.HttpResponse;
import org.json.JSONException;
import org.json.JSONObject;

import java.lang.annotation.Target;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;

import io.rong.imlib.base.IChat;
import io.rong.imlib.model.CNMessage;
import io.rong.imlib.model.CNUserInfo;
import io.rong.imlib.model.ConnectionStatus;
import io.rong.imlib.model.Conversation;
import io.rong.imlib.model.DataEntity;
import io.rong.imlib.model.Message;
import io.rong.imlib.model.MessageContent;
import io.rong.imlib.model.UserInfo;
import io.rong.imlib.network.HttpRequest;
import io.rong.imlib.network.HttpUtil;
import io.rong.message.TextMessage;

/**
 * Created by Lynn on 2/9/2017.
 */

public class Chat implements IChat {
    //当前登录用户id
    public static UserInfo currentUser;

    public static CNUserInfo currentCNUser;

    public static int defMessageCount;

    //当前聊天室房间id
    private static String currentRoomId;

    private String token;

    private Context context;


    private OnConnectStatusListener mConnectStatusListener;
    private OnReceiveMessageListener mOnMessageListener;
    private OnChatRoomActionListener mOnChatRoomActionListener;

    private OnSendMessageListener mOnSendMessageListener;
    private OnConnectListener mOnConnectionListener;
    private OnOperationListener mOnOperationListener;
    private OnResultListener mOnResultListener;
    private OnLatestMessageListener mOnLatestMessageListener;

    private OnCNChatListener mOnCNListener;
//    private OnInfoListener mOnInfoListener;

    private String sid;

    private static String APP_KEY = "8brlm7uf8bqz3";


    private static Chat chat;

    private List<String> roomIdList;

    protected static Chat getInstance() {
        if (chat == null)
            chat = new Chat();
        return chat;
    }

    private Chat() {

    }


    //初始化方法
    public void init(Context context) {
        this.context = context;
        RongIMClient.init(context, APP_KEY);
        roomIdList = new ArrayList<>();
    }

    public void connect(CNUserInfo cnUserInfo) {
        String userId;
        String userName;
        String headUrl;
        if (cnUserInfo == null) {
            //TODO UUID 头像地址
            TelephonyManager telephonyManager = (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE);
            userId = telephonyManager.getDeviceId();
            userName = "游客" + System.currentTimeMillis();
            headUrl = "";
            cnUserInfo = new CNUserInfo(userId, userName, headUrl);
            currentUser = new UserInfo(userId, userName, Uri.parse(headUrl));
        } else {
            userId = cnUserInfo.getUserId() == null ? "" : cnUserInfo.getUserId();
            userName = cnUserInfo.getUserName() == null ? "" : cnUserInfo.getUserName();
            headUrl = cnUserInfo.getHeadUrl() == null ? "" : cnUserInfo.getHeadUrl();
            currentUser = new UserInfo(userId, userName, Uri.parse(headUrl));
        }
        sid = currentUser.getUserId();
        getToken(cnUserInfo);
    }

//    //获得token
//    private static void getToken(CNUserInfo user, HttpUtil.OnResponse callback) {
//        final String HTTP_GET_TOKEN = "https://api.cn.ronghub.com/user/getToken.json";
//        HttpUtil.Header header = HttpUtil.getRcHeader(APP_KEY, APP_SECRET);
//        String body = "userId=" + user.getUserId() + "&name=" + user.getUserName() + "&portraitUri=" + Uri.parse(user.getHeadUrl());
//        HttpUtil httpUtil = new HttpUtil();
//        httpUtil.post(HTTP_GET_TOKEN, header, body, callback);
//    }

    private void getToken(CNUserInfo userInfo) {
        Log.e("DemoView", userInfo.getUserId() + " : " + userInfo.getUserName() + " : " + userInfo.getHeadUrl());
        HttpRequest.getToken(userInfo, new GenericsCallback<DataEntity>() {
            @Override
            public void onError(Call call, Exception e) {
                if (!NetUtil.checkNetwork(Config.getContext())) {
                    if (mOnCNListener != null)
                        mOnCNListener.onError(IChat.ERROR_GET_TOKEN_NETWORK, IChat.MSG_GET_TOKEN_NETWORK);
                } else {
                    if (mOnCNListener != null)
                        mOnCNListener.onError(IChat.ERROR_GET_TOKEN_OTHER, IChat.MSG_GET_TOKEN_OTHER);
                }
                if (e != null) Log.e("Chat", "error ", e);

            }

            @Override
            public void onResponse(DataEntity dataEntity, Exception e) {
                if (dataEntity != null && "0".equals(dataEntity.getErrorCode())) {
                    if (mOnCNListener != null)
                        mOnCNListener.onInfo(SUCCESS_GET_TOKEN, dataEntity.getErrorMessage());
                    token = dataEntity.getData().getToken();
                    connect(token);
                } else if (dataEntity != null && !TextUtils.isEmpty(dataEntity.getErrorCode())) {
                    if (mOnCNListener != null)
                        mOnCNListener.onError(IChat.ERROR_GET_TOKEN, IChat.MSG_GET_TOKEN + dataEntity.getErrorMessage());
                } else {
                    onError(null, e);
                }
            }
        });
    }

    //连接融云服务器
    private void connect(String token) {
        Log.e("DemoView", token);
        RongIMClient.connect(token, new RongIMClient.ConnectCallback() {
            @Override
            public void onTokenIncorrect() {
                //TODO token错误
                mOnConnectionListener.onTokenIncorrect();
            }

            @Override
            public void onSuccess(String s) {
                //TODO 连接成功
                mOnConnectionListener.onSuccess(s);
                setCurrentUser(currentUser);
            }

            @Override
            public void onError(RongIMClient.ErrorCode errorCode) {
                //TODO 连接失败
                mOnConnectionListener.onError(errorCode.getValue(), errorCode.getMessage());
            }
        });
    }

    //断开与融云服务器的连接，传入true：可以接收push消息；传入false：不能接收push消息
    public void disconnect(boolean isReceivePush) {
        if (isReceivePush) RongIMClient.getInstance().disconnect();
        else RongIMClient.getInstance().logout();
    }

    //用户鉴权成功后加入已经存在聊天室
    public void joinExistChatRoom(final String roomId, final int defMessageCount) {
        HttpRequest.getRoomAuthCheck(roomId, sid, new GenericsCallback<DataEntity>() {
            @Override
            public void onError(Call call, Exception e) {
                if (!NetUtil.checkNetwork(Config.getContext())) {
                    if (mOnCNListener != null)
                        mOnCNListener.onError(ERROR_CHECK_AUTH_NETWORK, MSG_CHECK_AUTH_NETWORK);
                } else {
                    if (mOnCNListener != null)
                        mOnCNListener.onError(ERROR_CHECK_AUTH_OTHER, MSG_CHECK_AUTH_OTHER);
                }
                if (e != null) Log.e("Chat", "error ", e);
            }

            @Override
            public void onResponse(DataEntity dataEntity, Exception e) {
                if (dataEntity != null && "0".equals(dataEntity.getErrorCode())) {
                    if (mOnCNListener != null)
                        mOnCNListener.onInfo(SUCCESS_CHECK_AUTH, dataEntity.getErrorMessage());
                    joinExistChatroom(roomId, defMessageCount);
                } else if (dataEntity != null && !TextUtils.isEmpty(dataEntity.getErrorCode())) {
                    if (mOnCNListener != null)
                        mOnCNListener.onError(ERROR_CHECK_AUTH, MSG_CHECK_AUTH + dataEntity.getErrorMessage());

                } else {
                    onError(null, e);
                }
            }
        });
    }

    //用户鉴权成功后加入已经存在聊天室
    public void joinChatRoom(final String roomId, final int defMessageCount) {
        HttpRequest.getRoomAuthCheck(roomId, sid, new GenericsCallback<DataEntity>() {
            @Override
            public void onError(Call call, Exception e) {
                if (!NetUtil.checkNetwork(Config.getContext())) {
                    if (mOnCNListener != null)
                        mOnCNListener.onError(ERROR_CHECK_AUTH_NETWORK, MSG_CHECK_AUTH_NETWORK);
                } else {
                    if (mOnCNListener != null)
                        mOnCNListener.onError(ERROR_CHECK_AUTH_OTHER, MSG_CHECK_AUTH_OTHER);
                }
                if (e != null) Log.e("Chat", "error ", e);
            }

            @Override
            public void onResponse(DataEntity dataEntity, Exception e) {
                if (dataEntity != null && "0".equals(dataEntity.getErrorCode())) {
                    if (mOnCNListener != null)
                        mOnCNListener.onInfo(SUCCESS_CHECK_AUTH, dataEntity.getErrorMessage());
                    joinChatroom(roomId, defMessageCount);
                } else if (dataEntity != null && !TextUtils.isEmpty(dataEntity.getErrorCode())) {
                    if (mOnCNListener != null)
                        mOnCNListener.onError(ERROR_CHECK_AUTH, MSG_CHECK_AUTH + dataEntity.getErrorMessage());
                } else {
                    onError(null, e);
                }
            }
        });
    }

    //加入聊天室，如果存在则加入，如果不存在，则创建
    private void joinChatroom(String roomId, int messageCount) {
        defMessageCount = messageCount;
        currentRoomId = roomId;
        RongIMClient.getInstance().joinChatRoom(currentRoomId, defMessageCount, new RongIMClient.OperationCallback() {
            @Override
            public void onSuccess() {
                //TODO 加入聊天室成功
                mOnOperationListener.onSuccess(IChat.SUCCESS_JOIN_CHATROOM, IChat.MSG_SUCCESS_JOIN_CHATROOM);
            }

            @Override
            public void onError(RongIMClient.ErrorCode errorCode) {
                //TODO 加入聊天室失败
                mOnOperationListener.onError(errorCode.getValue(), errorCode.getMessage());
            }
        });
    }

    //加入聊天室，如果存在则加入，如果不存在则加入失败
    private void joinExistChatroom(String roomId, int messageCount) {
        defMessageCount = messageCount;
        currentRoomId = roomId;
        roomIdList.add(currentRoomId);
        RongIMClient.getInstance().joinExistChatRoom(currentRoomId, defMessageCount, new RongIMClient.OperationCallback() {
            @Override
            public void onSuccess() {
                mOnOperationListener.onSuccess(IChat.SUCCESS_JOIN_EXIST_CHATROOM, MSG_SUCCESS_JOIN_EXIST_CHATROOM);
            }

            @Override
            public void onError(RongIMClient.ErrorCode errorCode) {
                mOnOperationListener.onError(errorCode.getValue(), errorCode.getMessage());
            }
        });
    }

    //退出聊天室，不再接收其消息
    public void quitChatRoom(String roomId) {
        for (int i = 0; i < roomIdList.size(); i++) {
            if (roomIdList.get(i).equals(roomId)) {
                roomIdList.remove(i);
            }
        }
        RongIMClient.getInstance().quitChatRoom(roomId, new RongIMClient.OperationCallback() {
            @Override
            public void onSuccess() {
                //TODO 退出聊天室成功
                mOnOperationListener.onSuccess(IChat.SUCCESS_QUIT_CHATROOM, IChat.MSG_SUCCESS_QUIT_CHATROOM);
            }

            @Override
            public void onError(RongIMClient.ErrorCode errorCode) {
                //TODO 退出聊天室失败
                mOnOperationListener.onError(errorCode.getValue(), errorCode.getMessage());
            }
        });
    }

    //向当前聊天室发送消息
    public void sendMessage(String conversationType, String targetId, String message) {
        //TODO 判断token是否获取成功
        final TextMessage content = TextMessage.obtain(message);
        if (conversationType.equals(IChat.PRIVATE)) {
            sendPrivateMessage(targetId, content);
        } else if (conversationType.equals(IChat.CHATROOM)) {
            sendChatRoomMessage(targetId, content);
        }
    }

    //主动获取当前连接状态
    public ConnectionStatus getCurrentConnectionStatus() {
        ConnectionStatus connectionStatus = new ConnectionStatus();
        connectionStatus.setValue(RongIMClient.getInstance().getCurrentConnectionStatus().getValue());
        connectionStatus.setMessage(RongIMClient.getInstance().getCurrentConnectionStatus().getMessage());
        return connectionStatus;
    }

    private void sendChatRoomMessage(String targetId, final MessageContent msgContent) {
        if (currentUser == null) {
            throw new RuntimeException("currentUser should not be null.");
        }

        msgContent.setUserInfo(currentUser);
        final Message msg = Message.obtain(targetId, Conversation.ConversationType.CHATROOM, msgContent);
        RongIMClient.getInstance().sendMessage(msg, null, null, new RongIMClient.SendMessageCallback() {
            @Override
            public void onError(Integer integer, RongIMClient.ErrorCode errorCode) {
                //TODO
                mOnSendMessageListener.onError(integer, errorCode.getValue(), errorCode.getMessage());
            }

            @Override
            public void onSuccess(Integer integer) {
                //TODO
                mOnSendMessageListener.onSuccess(integer);
            }
        }, new RongIMClient.ResultCallback<Message>() {
            @Override
            public void onSuccess(Message message) {

                mOnResultListener.onSuccess(cnMessage(message));
            }

            @Override
            public void onError(RongIMClient.ErrorCode errorCode) {
                //TODO
                mOnResultListener.onError(errorCode.getValue(), errorCode.getMessage());
            }
        });
    }

    //单聊
    private void sendPrivateMessage(String targetId, final MessageContent message) {
        if (currentUser == null) {
            throw new RuntimeException("currentUser should not be null.");
        }

        message.setUserInfo(currentUser);

        final Message msg = Message.obtain(targetId, Conversation.ConversationType.PRIVATE, message);
        RongIMClient.getInstance().sendMessage(msg, null, null, new RongIMClient.SendMessageCallback() {
            @Override
            public void onError(Integer integer, RongIMClient.ErrorCode errorCode) {
                //TODO
                mOnSendMessageListener.onError(integer, errorCode.getValue(), errorCode.getMessage());
            }

            @Override
            public void onSuccess(Integer integer) {
                //TODO
                mOnSendMessageListener.onSuccess(integer);
            }
        }, new RongIMClient.ResultCallback<Message>() {
            @Override
            public void onSuccess(Message message) {
                //TODO
                mOnResultListener.onSuccess(cnMessage(message));
            }

            @Override
            public void onError(RongIMClient.ErrorCode errorCode) {
                //TODO
                mOnResultListener.onError(errorCode.getValue(), errorCode.getMessage());
            }
        });
    }

    private void setConnectStatusListener(RongIMClient.ConnectionStatusListener listener) {
        RongIMClient.setConnectionStatusListener(listener);
    }

    private RongIMClient.ConnectionStatusListener connectionStatusListener = new RongIMClient.ConnectionStatusListener() {
        @Override
        public void onChanged(ConnectionStatus connectionStatus) {
            //TODO
            switch (connectionStatus) {
                case NETWORK_UNAVAILABLE:
                    mConnectStatusListener.onConnectStatus(NETWORK_UNAVAILABLE, STATUS_NETWORK_UNAVAILABLE);
                    break;
                case CONNECTED:
                    mConnectStatusListener.onConnectStatus(CONNECTED, STATUS_CONNECTED);
                    break;
                case CONNECTING:
                    mConnectStatusListener.onConnectStatus(CONNECTING, STATUS_CONNECTING);
                    break;
                case DISCONNECTED:
                    mConnectStatusListener.onConnectStatus(DISCONNECTED, STATUS_DISCONNECTED);
                    break;
                case KICKED_OFFLINE_BY_OTHER_CLIENT:
                    mConnectStatusListener.onConnectStatus(KICKED_OFFLINE_BY_OTHER_CLIENT, STATUS_KICKED_OFFLINE_BY_OTHER_CLIENT);
                    break;
                case TOKEN_INCORRECT:
                    mConnectStatusListener.onConnectStatus(TOKEN_INCORRECT, STATUS_TOKEN_INCORRECT);
                    break;
                case SERVER_INVALID:
                    mConnectStatusListener.onConnectStatus(SERVER_INVALID, STATUS_SERVER_INVALID);
                    break;
            }
        }
    };

    private void setOnReceiveMessageListener(RongIMClient.OnReceiveMessageListener onReceiveMessageListener) {
        RongIMClient.setOnReceiveMessageListener(onReceiveMessageListener);
    }

    private void setChatRoomActionListener(RongIMClient.ChatRoomActionListener chatRoomActionListener) {
        RongIMClient.setChatRoomActionListener(chatRoomActionListener);
    }

    private RongIMClient.ChatRoomActionListener chatRoomActionListener = new RongIMClient.ChatRoomActionListener() {
        @Override
        public void onJoining(String s) {
            mOnChatRoomActionListener.onJoining(s);
        }

        @Override
        public void onJoined(String s) {
            mOnChatRoomActionListener.onJoined(s);
        }

        @Override
        public void onQuited(String s) {
            mOnChatRoomActionListener.onQuited(s);
        }

        @Override
        public void onError(String s, RongIMClient.ErrorCode errorCode) {
            mOnChatRoomActionListener.onError(s, errorCode.getValue(), errorCode.getMessage());
        }
    };

    private RongIMClient.OnReceiveMessageListener onReceiveMessageListener = new RongIMClient.OnReceiveMessageListener() {
        @Override
        public boolean onReceived(Message message, int i) {
            //TODO
            mOnMessageListener.processMessage(cnMessage(message));
            return false;
        }
    };

    private CNMessage cnMessage(Message message) {
        //将融云的message转换为我们自己的message
        String content;
        String userId;
        String userName;
        String headUrl;
        CNMessage mMessage = new CNMessage();
        TextMessage msg = (TextMessage) (message.getContent() == null ? "" : message.getContent());
        content = msg.getContent();
        mMessage.setContent(content);

        userId = message.getContent().getUserInfo().getUserId() == null ? "" : message.getContent().getUserInfo().getUserId();
        userName = message.getContent().getUserInfo().getName() == null ? "" : message.getContent().getUserInfo().getName();
        headUrl = message.getContent().getUserInfo().getPortraitUri().toString() == null ? "" : message.getContent().getUserInfo().getPortraitUri().toString();

        currentCNUser = new CNUserInfo();
        currentCNUser.setUserId(userId);
        currentCNUser.setUserName(userName);
        currentCNUser.setHeadUrl(headUrl);
        mMessage.setUserInfo(currentCNUser);
        return mMessage;
    }

    //获取单聊历史消息
    public void getLatestMessages(String targetId, int count) {
        RongIMClient.getInstance().getLatestMessages(Conversation.ConversationType.PRIVATE, targetId, count, new RongIMClient.ResultCallback<List<Message>>() {
            @Override
            public void onSuccess(List<Message> messages) {
                List<CNMessage> cnMessages = new ArrayList<CNMessage>();
                for (Message message : messages) {
                    cnMessages.add(cnMessage(message));
                }
                mOnLatestMessageListener.onSuccess(cnMessages);
            }

            @Override
            public void onError(RongIMClient.ErrorCode errorCode) {
                mOnLatestMessageListener.onError(errorCode.getValue(), errorCode.getMessage());
            }
        });
    }

    public void setConnectStatusListener(OnConnectStatusListener listener) {
        this.mConnectStatusListener = listener;
        setConnectStatusListener(connectionStatusListener);
    }

    public void setOnChatRoomActionListener(OnChatRoomActionListener listener) {
        this.mOnChatRoomActionListener = listener;
        setChatRoomActionListener(chatRoomActionListener);
    }

    public void setOnReceiveMessageListener(OnReceiveMessageListener listener) {
        this.mOnMessageListener = listener;
        setOnReceiveMessageListener(onReceiveMessageListener);
    }

    public void setOnSendMessageListener(OnSendMessageListener listener) {
        this.mOnSendMessageListener = listener;

    }

    public void setOnConnectionListener(OnConnectListener listener) {
        this.mOnConnectionListener = listener;
    }

    public void setOnOperationListener(OnOperationListener listener) {
        this.mOnOperationListener = listener;
    }

    public void setOnResultListener(OnResultListener listener) {
        this.mOnResultListener = listener;
    }

    public void setOnLatestMessageListener(OnLatestMessageListener listener) {
        this.mOnLatestMessageListener = listener;
    }

    public void setOnCNChatListener(OnCNChatListener listener) {
        this.mOnCNListener = listener;
    }

//    public void setOnInfoListener(OnInfoListener listener) {
//        this.mOnInfoListener = listener;
//    }

    private UserInfo getCurrentUser() {
        return currentUser;
    }

    private void setCurrentUser(UserInfo user) {
        currentUser = user;
    }

    private static CNUserInfo getCurrentCNUser() {
        return currentCNUser;
    }

    public void modifyUser(String userName, String headUrl) {
//        currentCNUser = currentCNUserInfo;
        currentUser.setName(userName);
        currentUser.setPortraitUri(Uri.parse(headUrl));
        setCurrentUser(currentUser);
    }

    //切换用户
    public void exchangeUser(CNUserInfo userInfo) {
        disconnect(false);
        connect(userInfo);
        //TODO 在token获取成功时做连接操作，连接成功之后做加入聊天室操作
        joinExistChatRoom(currentRoomId, -1);
    }
}