CNLive Android Team / CNChatSDK · Files

package io.rong.imlib;

import android.content.Context;
import android.net.Uri;

import org.json.JSONException;
import org.json.JSONObject;

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.Conversation;
import io.rong.imlib.model.Message;
import io.rong.imlib.model.MessageContent;
import io.rong.imlib.model.UserInfo;
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 OnConnectStatusListener mConnectStatusListener;
    private OnMessageListener mOnMessageListener;
    private OnChatRoomActionListener mOnChatRoomActionListener;

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

    private static String APP_KEY = "e5t4ouvpe5qea";
    private static String APP_SECRET = "N16VJFIPE22p";


    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) {
        RongIMClient.init(context, APP_KEY);
        roomIdList = new ArrayList<>();
    }

    public void connect(CNUserInfo cnUserInfo) {
        String userId;
        String userName;
        String headUrl;
        if (cnUserInfo == null) {
            //TODO UUID 头像地址
            userId = UUID.randomUUID().toString().replaceAll("-", "");
            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));
        }
        getToken(cnUserInfo, new HttpUtil.OnResponse() {
            @Override
            public void onResponse(int code, String body) {
                if (code != 200) return;
                String token;
                try {
                    JSONObject jsonObject = new JSONObject(body);
                    token = jsonObject.getString("token");
                } catch (JSONException e) {
                    e.printStackTrace();
                    return;
                }
                connect(token);
            }
        });
    }

    //获得token
    public 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);
    }

    //连接融云服务器
    public void connect(String 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 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());
            }
        });
    }

    //加入聊天室，如果存在则加入，如果不存在则加入失败
    public void joinExistChatRoom(String roomId, int messageCount) {
        defMessageCount = messageCount;
        currentRoomId = roomId;
        roomIdList.add(currentRoomId);
        RongIMClient.getInstance().joinChatRoom(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) {
        final TextMessage content = TextMessage.obtain(message);
        if (conversationType.equals(IChat.PRIVATE)) {
            sendPrivateMessage(targetId, content);
        } else if (conversationType.equals(IChat.CHATROOM)) {
            sendChatRoomMessage(targetId, content);
        }
    }

    //切换用户
    public void exchangeUser(CNUserInfo userInfo) {
        disconnect(false);
        connect(userInfo);
        joinChatRoom(currentRoomId, -1);
    }

    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 setOnMessageListener(OnMessageListener 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 UserInfo getCurrentUser() {
        return currentUser;
    }

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

    public static CNUserInfo getCurrentCNUser() {
        return currentCNUser;
    }

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