`

融云接口

 
阅读更多 
public class RongCloudMethodUtil {  
    /** 
     * 获取token 
     *  
     * @param userId 
     * @param name 
     * @param portraitUri 
     */  
    public static String getToken(String userId, String name, String portraitUri) {  
        String getToken = "https://api.cn.rong.io/user/getToken.json";  
        Map<String, String> params = new HashMap<String, String>();  
        params.put("userId", userId);  
        params.put("name", name);  
        params.put("portraitUri", portraitUri);  
        byte[] resultArray;  
        String token = null;  
        try {  
            resultArray = RongCloudUtil.post(getToken, params, "UTF-8", 20000);  
            String result = new String(resultArray);  
            JSONObject obj = JSONObject.fromObject(result);  
            token = obj.get("token").toString();  
        } catch (Exception e) {  
            e.printStackTrace();  
            System.out.println("没获取到token");  
        }  
        return token;  
    }  
  
    /** 
     * 推送系统信息 
     *  
     * @param content 消息内容 
     * @param fromUserId 1 
     * @param toUserId  userId 
     * @param objectName  RC:TxtMsg  
     * @param pushContent 消息标题 
     * @param pushData 空-安卓  非空：苹果 
     */  
    public static void pushSystemMessage(String content, String fromUserId,  
            String toUserId, String objectName, String pushContent,  
            String pushData) {  
  
        String systemMessage = "https://api.cn.rong.io/message/system/publish.json";  
        Map<String, String> params = new HashMap<String, String>();  
        // String content="{\"content\":\"2\"}";  
        params.put("content", content);  
        params.put("fromUserId", fromUserId);  
        params.put("toUserId", toUserId);  
        params.put("objectName", objectName);  
        params.put("pushContent", pushContent);  
        params.put("pushData", pushData);  
        byte[] resultArray;  
        try {  
            resultArray = RongCloudUtil.post(systemMessage, params, "UTF-8",  
                    20000);  
            String result = new String(resultArray);  
            System.out.println(result);  
        } catch (Exception e) {  
            System.out.println("发送信息出错了");  
        }  
  
    }  
  
    /** 
     * 刷新个人信息 
     *  
     * @param userId 
     * @param name 
     * @param portraitUri 
     */  
    public static void refreshUserInformation(String userId, String name,  
            String portraitUri) {  
        String refresh = "https://api.cn.rong.io/user/refresh.json";  
        Map<String, String> params = new HashMap<String, String>();  
        params.put("userId", userId);  
        params.put("name", name);  
        params.put("portraitUri", portraitUri);  
        byte[] resultArray;  
        try {  
            resultArray = RongCloudUtil.post(refresh, params, "UTF-8", 20000);  
            String result = new String(resultArray);  
            System.out.println(result);  
        } catch (Exception e) {  
            System.out.println("哎呀，刷新没成功");  
        }  
    }  
  
    /** 
     * 检查某人是否在线 
     *  
     * @param userId 
     */  
    public static void checkOnline(String userId) {  
        String checkOnline = "https://api.cn.rong.io/user/checkOnline.json";  
        Map<String, String> params = new HashMap<String, String>();  
        params.put("userId", userId);  
        byte[] resultArray;  
        try {  
            resultArray = RongCloudUtil.post(checkOnline, params, "UTF-8",  
                    20000);  
            String result = new String(resultArray);  
            System.out.println(result);  
        } catch (Exception e) {  
            System.out.println("系统维护");  
        }  
    }  
  
    /** 
     * 禁言 
     */  
    public static void block(String userId, String minute) {  
        String block = "https://api.cn.rong.io/user/block.json";  
        Map<String, String> params = new HashMap<String, String>();  
        params.put("userId", userId);  
        params.put("minute", minute);// 禁言时间，单位为分钟  
        byte[] resultArray;  
        try {  
            resultArray = RongCloudUtil.post(block, params, "UTF-8", 20000);  
            String result = new String(resultArray);  
            System.out.println(result);  
        } catch (Exception e) {  
            System.out.println("禁言没成功");  
        }  
    }  
  
    /** 
     * 解禁用户 
     *  
     * @param userId 
     */  
    public static void unblock(String userId) {  
        String unblock = "https://api.cn.rong.io/user/unblock.json";  
        Map<String, String> params = new HashMap<String, String>();  
        params.put("userId", userId);  
        byte[] resultArray;  
        try {  
            resultArray = RongCloudUtil.post(unblock, params, "UTF-8", 20000);  
            String result = new String(resultArray);  
            System.out.println(result);  
        } catch (Exception e) {  
            System.out.println("解禁没成功");  
        }  
    }  
  
    /** 
     * 查询被禁人员 
     */  
    public static void queryBlack() {  
        String query = "https://api.cn.rong.io/user/block/query.json";  
        byte[] resultArray;  
        try {  
            resultArray = RongCloudUtil.post(query, null, "UTF-8", 20000);  
            String result = new String(resultArray);  
            System.out.println(result);  
        } catch (Exception e) {  
            System.out.println("查询没成功");  
        }  
    }  
  
    /** 
     * 添加黑名单 
     */  
    public static void addBlack(String userId, String blackUserId) {  
        String add = "https://api.cn.rong.io/user/blacklist/add.json";  
        Map<String, String> params = new HashMap<String, String>();  
        params.put("userId", userId);  
        params.put("blackUserId", blackUserId);  
        byte[] resultArray;  
        try {  
            resultArray = RongCloudUtil.post(add, params, "UTF-8", 20000);  
            String result = new String(resultArray);  
            System.out.println(result);  
        } catch (Exception e) {  
            System.out.println("添加没成功");  
        }  
    }  
  
    /** 
     * 删除黑名单 
     *  
     * @param userId 
     * @param blackUserId 
     */  
    public static void removeBlack(String userId, String blackUserId) {  
        String remove = "https://api.cn.rong.io/user/blacklist/remove.json";  
        Map<String, String> params = new HashMap<String, String>();  
        params.put("userId", userId);  
        params.put("blackUserId", blackUserId);  
        byte[] resultArray;  
        try {  
            resultArray = RongCloudUtil.post(remove, params, "UTF-8", 20000);  
            String result = new String(resultArray);  
            System.out.println(result);  
        } catch (Exception e) {  
            System.out.println("删除没成功");  
        }  
    }  
  
    /** 
     * 查询所有加黑用户 
     */  
    public static void blacklist(String userId, String blackUserId) {  
        String blacklist = "https://api.cn.rong.io/user/blacklist/query.json";  
        Map<String, String> params = new HashMap<String, String>();  
        params.put("userId", userId);  
        params.put("blackUserId", blackUserId);  
        byte[] resultArray;  
        try {  
            resultArray = RongCloudUtil.post(blacklist, params, "UTF-8", 20000);  
            String result = new String(resultArray);  
            System.out.println(result);  
        } catch (Exception e) {  
            System.out.println("查询加黑名单异常");  
        }  
    }  
  
    /** 
     * 单聊 
     */  
    public static void oneToOneMessege(String content, String fromUserId,  
            String toUserId, String objectName, String pushContent,  
            String pushData) {  
        String oneToOne = "https://api.cn.rong.io/message/private/publish.json";  
        Map<String, String> params = new HashMap<String, String>();  
        // String content="{\"content\":\"2\"}";  
        params.put("content", content);  
        params.put("fromUserId", fromUserId);  
        params.put("toUserId", toUserId);  
        params.put("objectName", objectName);  
        params.put("pushContent", pushContent);  
        params.put("pushData", pushData);  
        byte[] resultArray;  
        try {  
            resultArray = RongCloudUtil.post(oneToOne, params, "UTF-8", 20000);  
            String result = new String(resultArray);  
            System.out.println(result);  
        } catch (Exception e) {  
            System.out.println("单聊信息发送异常");  
        }  
    }  
  
    /** 
     * 发送群信息 
     *  
     * @param content 
     * @param fromUserId 
     * @param toGroupId 
     * @param objectName 
     * @param pushContent 
     * @param pushData 
     */  
    public static void groupMessege(String content, String fromUserId,  
            String toGroupId, String objectName, String pushContent,  
            String pushData) {  
        String groupMessege = "https://api.cn.rong.io/message/group/publish.json";  
        Map<String, String> params = new HashMap<String, String>();  
        // String content="{\"content\":\"2\"}";  
        params.put("content", content);  
        params.put("fromUserId", fromUserId);  
        params.put("toGroupId", toGroupId);  
        params.put("objectName", objectName);  
        params.put("pushContent", pushContent);  
        params.put("pushData", pushData);  
        byte[] resultArray;  
        try {  
            resultArray = RongCloudUtil.post(groupMessege, params, "UTF-8",  
                    20000);  
            String result = new String(resultArray);  
            System.out.println(result);  
        } catch (Exception e) {  
            System.out.println("群组信息发送异常");  
        }  
    }  
  
    /** 
     * 发送聊天室消息 
     *  
     * @param content 
     * @param fromUserId 
     * @param toGroupId 
     * @param objectName 
     * @param pushContent 
     * @param pushData 
     */  
    public static void chatroom(String content, String fromUserId,  
            String toGroupId, String objectName, String pushContent,  
            String pushData) {  
        String chatroom = "https://api.cn.rong.io/message/chatroom/publish.json";  
        Map<String, String> params = new HashMap<String, String>();  
        // String content="{\"content\":\"2\"}";  
        params.put("content", content);  
        params.put("fromUserId", fromUserId);  
        params.put("toGroupId", toGroupId);  
        params.put("objectName", objectName);  
        params.put("pushContent", pushContent);  
        params.put("pushData", pushData);  
        byte[] resultArray;  
        try {  
            resultArray = RongCloudUtil.post(chatroom, params, "UTF-8", 20000);  
            String result = new String(resultArray);  
            System.out.println(result);  
        } catch (Exception e) {  
            System.out.println("聊天信息发送异常");  
        }  
    }  
  
    /** 
     * 发送广播消息 
     */  
    public static void broadcast(String content, String fromUserId,  
            String objectName, String pushContent, String pushData) {  
        String broadcast = "https://api.cn.rong.io/message/broadcast.json";  
        Map<String, String> params = new HashMap<String, String>();  
        // String content="{\"content\":\"2\"}";  
        params.put("content", content);  
        params.put("fromUserId", fromUserId);  
        params.put("objectName", objectName);  
        params.put("pushContent", pushContent);  
        params.put("pushData", pushData);  
        byte[] resultArray;  
        try {  
            resultArray = RongCloudUtil.post(broadcast, params, "UTF-8", 20000);  
            String result = new String(resultArray);  
            System.out.println(result);  
        } catch (Exception e) {  
            System.out.println("广播发送异常");  
        }  
    }  
  
    /** 
     * 查某个时段会话历史 
     */  
    public static void history(String date) {  
        String history = "https://api.cn.rong.io/message/history.json";  
        Map<String, String> params = new HashMap<String, String>();  
        params.put("date", date);  
        byte[] resultArray;  
        try {  
            resultArray = RongCloudUtil.post(history, params, "UTF-8", 20000);  
            String result = new String(resultArray);  
            System.out.println(result);  
        } catch (Exception e) {  
            System.out.println("查找历史记录异常");  
        }  
    }  
  
    /** 
     * 删除信息记录 
     */  
    public static void deleteHistory(String date) {  
        String deleteHistory = "https://api.cn.rong.io/message/history/delete.json";  
        Map<String, String> params = new HashMap<String, String>();  
        params.put("date", date);  
        byte[] resultArray;  
        try {  
            resultArray = RongCloudUtil.post(deleteHistory, params, "UTF-8",  
                    20000);  
            String result = new String(resultArray);  
            System.out.println(result);  
        } catch (Exception e) {  
            System.out.println("删除群组异常");  
        }  
    }  
  
    /** 
     * 同步群组信息 
     *  
     * @param group 
     * @param userId 
     */  
    public static void groupSync(String[] group, String userId) {  
        String groupSync = "https://api.cn.rong.io/group/sync.json";  
        Map<String, String> params = new HashMap<String, String>();  
        params.put("userId", "1");  
        for (int i = 0; i < group.length; i++) {  
            params.put("group[" + i + "]", group[i]);  
        }  
        byte[] resultArray;  
        try {  
            resultArray = RongCloudUtil.post(groupSync, params, "UTF-8", 20000);  
            String result = new String(resultArray);  
            System.out.println(result);  
        } catch (Exception e) {  
            System.out.println("同步群组信息异常");  
        }  
    }  
  
    /** 
     * 创建群组 
     */  
    public static void createGroup(String userId, String groupId,  
            String groupName) {  
        String createGroup = "https://api.cn.rong.io/group/create.json";  
        Map<String, String> params = new HashMap<String, String>();  
        params.put("userId", userId);  
        params.put("groupId", groupId);  
        params.put("groupName", groupName);  
        byte[] resultArray;  
        try {  
            resultArray = RongCloudUtil.post(createGroup, params, "UTF-8",  
                    20000);  
            String result = new String(resultArray);  
            System.out.println(result);  
        } catch (Exception e) {  
            System.out.println("创建群组异常");  
        }  
    }  
  
    /** 
     * 加入群组 
     */  
    public static void joinGroup(String userId, String groupId, String groupName) {  
        String joinGroup = "https://api.cn.rong.io/group/join.json";  
        Map<String, String> params = new HashMap<String, String>();  
        params.put("userId", userId);  
        params.put("groupId", groupId);  
        params.put("groupName", groupName);  
        byte[] resultArray;  
        try {  
            resultArray = RongCloudUtil.post(joinGroup, params, "UTF-8", 20000);  
            String result = new String(resultArray);  
            System.out.println(result);  
        } catch (Exception e) {  
            System.out.println("加入群组异常");  
        }  
    }  
  
    /** 
     * 退出群组 
     */  
    public static void quitGroup(String userId, String groupId) {  
        String quitGroup = "https://api.cn.rong.io/group/quit.json";  
        Map<String, String> params = new HashMap<String, String>();  
        params.put("userId", userId);  
        params.put("groupId", groupId);  
        byte[] resultArray;  
        try {  
            resultArray = RongCloudUtil.post(quitGroup, params, "UTF-8", 20000);  
            String result = new String(resultArray);  
            System.out.println(result);  
        } catch (Exception e) {  
            System.out.println("退出群组异常");  
        }  
    }  
  
    /** 
     * 解散群组 
     */  
    public static void dismissGroup(String userId, String groupId) {  
        String dismissGroup = "https://api.cn.rong.io/group/dismiss.json";  
        Map<String, String> params = new HashMap<String, String>();  
        params.put("userId", userId);  
        params.put("groupId", groupId);  
        byte[] resultArray;  
        try {  
            resultArray = RongCloudUtil.post(dismissGroup, params, "UTF-8",  
                    20000);  
            String result = new String(resultArray);  
            System.out.println(result);  
        } catch (Exception e) {  
            System.out.println("解散群组异常");  
        }  
    }  
  
    /** 
     * 刷新群组 
     */  
    public static void refreshGroup(String userId, String groupId,  
            String groupName) {  
        String refreshGroup = "https://api.cn.rong.io/group/refresh.json";  
        Map<String, String> params = new HashMap<String, String>();  
        params.put("userId", userId);  
        params.put("groupId", groupId);  
        params.put("groupName", groupName);  
        byte[] resultArray;  
        try {  
            resultArray = RongCloudUtil.post(refreshGroup, params, "UTF-8",  
                    20000);  
            String result = new String(resultArray);  
            System.out.println(result);  
        } catch (Exception e) {  
            System.out.println("刷新群组异常");  
        }  
    }  
  
    /** 
     * 创建聊天室 
     *  
     * @param chartroom 
     */  
    public static void createChatroom(String[] chartroom) {  
        String refreshGroup = "https://api.cn.rong.io/chatroom/create.json";  
        Map<String, String> params = new HashMap<String, String>();  
        for (int i = 0; i < chartroom.length; i++) {  
            params.put("chartroom[" + i + "]", "testChartRoom" + i);  
        }  
        byte[] resultArray;  
        try {  
            resultArray = RongCloudUtil.post(refreshGroup, params, "UTF-8",  
                    20000);  
            String result = new String(resultArray);  
            System.out.println(result);  
        } catch (Exception e) {  
            System.out.println("创建聊天室异常");  
        }  
    }  
  
    /** 
     * 注销聊天室 
     */  
    public static void destroyChatroom(String chatroomId) {  
        String destroyChatroom = "https://api.cn.rong.io/chatroom/destroy.json";  
        Map<String, String> params = new HashMap<String, String>();  
        params.put("chatroomId", chatroomId);  
        byte[] resultArray;  
        try {  
            resultArray = RongCloudUtil.post(destroyChatroom, params, "UTF-8",  
                    20000);  
            String result = new String(resultArray);  
            System.out.println(result);  
        } catch (Exception e) {  
            System.out.println("注销异常");  
        }  
    }  
  
    /** 
     * 查询某个聊天室 
     *  
     * @param chatroomId 
     */  
    public static void queryChatroom(String chatroomId) {  
        String queryChatroom = "https://api.cn.rong.io/chatroom/query.json";  
        Map<String, String> params = new HashMap<String, String>();  
        params.put("chatroomId", chatroomId);  
        byte[] resultArray;  
        try {  
            resultArray = RongCloudUtil.post(queryChatroom, params, "UTF-8",  
                    20000);  
            String result = new String(resultArray);  
            System.out.println(result);  
        } catch (Exception e) {  
            System.out.println("查询聊天室异常");  
        }  
    }  
}  


















public class RongCloudUtil {  
  
    private final static String appkey = "";// 申请的融云key  
    private final static String appSecret = "";// 申请的的云secret  
    private final static int[] abcde = { 0x67452301, 0xefcdab89, 0x98badcfe,  
            0x10325476, 0xc3d2e1f0 };// sha1加密产参数  
    // 摘要数据存储数组  
    private static int[] digestInt = new int[5];  
    // 计算过程中的临时数据存储数组  
    private static int[] tmpData = new int[80];  
  
    // 计算sha-1摘要  
    private static int process_input_bytes(byte[] bytedata) {  
        // 初试化常量  
        System.arraycopy(abcde, 0, digestInt, 0, abcde.length);  
        // 格式化输入字节数组，补10及长度数据  
        byte[] newbyte = byteArrayFormatData(bytedata);  
        // 获取数据摘要计算的数据单元个数  
        int MCount = newbyte.length / 64;  
        // 循环对每个数据单元进行摘要计算  
        for (int pos = 0; pos < MCount; pos++) {  
            // 将每个单元的数据转换成16个整型数据，并保存到tmpData的前16个数组元素中  
            for (int j = 0; j < 16; j++) {  
                tmpData[j] = byteArrayToInt(newbyte, (pos * 64) + (j * 4));  
            }  
            // 摘要计算函数  
            encrypt();  
        }  
        return 20;  
    }  
  
    // 格式化输入字节数组格式  
    private static byte[] byteArrayFormatData(byte[] bytedata) {  
        // 补0数量  
        int zeros = 0;  
        // 补位后总位数  
        int size = 0;  
        // 原始数据长度  
        int n = bytedata.length;  
        // 模64后的剩余位数  
        int m = n % 64;  
        // 计算添加0的个数以及添加10后的总长度  
        if (m < 56) {  
            zeros = 55 - m;  
            size = n - m + 64;  
        } else if (m == 56) {  
            zeros = 63;  
            size = n + 8 + 64;  
        } else {  
            zeros = 63 - m + 56;  
            size = (n + 64) - m + 64;  
        }  
        // 补位后生成的新数组内容  
        byte[] newbyte = new byte[size];  
        // 复制数组的前面部分  
        System.arraycopy(bytedata, 0, newbyte, 0, n);  
        // 获得数组Append数据元素的位置  
        int l = n;  
        // 补1操作  
        newbyte[l++] = (byte) 0x80;  
        // 补0操作  
        for (int i = 0; i < zeros; i++) {  
            newbyte[l++] = (byte) 0x00;  
        }  
        // 计算数据长度，补数据长度位共8字节，长整型  
        long N = (long) n * 8;  
        byte h8 = (byte) (N & 0xFF);  
        byte h7 = (byte) ((N >> 8) & 0xFF);  
        byte h6 = (byte) ((N >> 16) & 0xFF);  
        byte h5 = (byte) ((N >> 24) & 0xFF);  
        byte h4 = (byte) ((N >> 32) & 0xFF);  
        byte h3 = (byte) ((N >> 40) & 0xFF);  
        byte h2 = (byte) ((N >> 48) & 0xFF);  
        byte h1 = (byte) (N >> 56);  
        newbyte[l++] = h1;  
        newbyte[l++] = h2;  
        newbyte[l++] = h3;  
        newbyte[l++] = h4;  
        newbyte[l++] = h5;  
        newbyte[l++] = h6;  
        newbyte[l++] = h7;  
        newbyte[l++] = h8;  
        return newbyte;  
    }  
  
    private static int f1(int x, int y, int z) {  
        return (x & y) | (~x & z);  
    }  
  
    private static int f2(int x, int y, int z) {  
        return x ^ y ^ z;  
    }  
  
    private static int f3(int x, int y, int z) {  
        return (x & y) | (x & z) | (y & z);  
    }  
  
    private static int f4(int x, int y) {  
        return (x << y) | x >>> (32 - y);  
    }  
  
    // 单元摘要计算函数  
    private static void encrypt() {  
        for (int i = 16; i <= 79; i++) {  
            tmpData[i] = f4(tmpData[i - 3] ^ tmpData[i - 8] ^ tmpData[i - 14]  
                    ^ tmpData[i - 16], 1);  
        }  
        int[] tmpabcde = new int[5];  
        for (int i1 = 0; i1 < tmpabcde.length; i1++) {  
            tmpabcde[i1] = digestInt[i1];  
        }  
        for (int j = 0; j <= 19; j++) {  
            int tmp = f4(tmpabcde[0], 5)  
                    + f1(tmpabcde[1], tmpabcde[2], tmpabcde[3]) + tmpabcde[4]  
                    + tmpData[j] + 0x5a827999;  
            tmpabcde[4] = tmpabcde[3];  
            tmpabcde[3] = tmpabcde[2];  
            tmpabcde[2] = f4(tmpabcde[1], 30);  
            tmpabcde[1] = tmpabcde[0];  
            tmpabcde[0] = tmp;  
        }  
        for (int k = 20; k <= 39; k++) {  
            int tmp = f4(tmpabcde[0], 5)  
                    + f2(tmpabcde[1], tmpabcde[2], tmpabcde[3]) + tmpabcde[4]  
                    + tmpData[k] + 0x6ed9eba1;  
            tmpabcde[4] = tmpabcde[3];  
            tmpabcde[3] = tmpabcde[2];  
            tmpabcde[2] = f4(tmpabcde[1], 30);  
            tmpabcde[1] = tmpabcde[0];  
            tmpabcde[0] = tmp;  
        }  
        for (int l = 40; l <= 59; l++) {  
            int tmp = f4(tmpabcde[0], 5)  
                    + f3(tmpabcde[1], tmpabcde[2], tmpabcde[3]) + tmpabcde[4]  
                    + tmpData[l] + 0x8f1bbcdc;  
            tmpabcde[4] = tmpabcde[3];  
            tmpabcde[3] = tmpabcde[2];  
            tmpabcde[2] = f4(tmpabcde[1], 30);  
            tmpabcde[1] = tmpabcde[0];  
            tmpabcde[0] = tmp;  
        }  
        for (int m = 60; m <= 79; m++) {  
            int tmp = f4(tmpabcde[0], 5)  
                    + f2(tmpabcde[1], tmpabcde[2], tmpabcde[3]) + tmpabcde[4]  
                    + tmpData[m] + 0xca62c1d6;  
            tmpabcde[4] = tmpabcde[3];  
            tmpabcde[3] = tmpabcde[2];  
            tmpabcde[2] = f4(tmpabcde[1], 30);  
            tmpabcde[1] = tmpabcde[0];  
            tmpabcde[0] = tmp;  
        }  
        for (int i2 = 0; i2 < tmpabcde.length; i2++) {  
            digestInt[i2] = digestInt[i2] + tmpabcde[i2];  
        }  
        for (int n = 0; n < tmpData.length; n++) {  
            tmpData[n] = 0;  
        }  
    }  
  
    // 4字节数组转换为整数  
    private static int byteArrayToInt(byte[] bytedata, int i) {  
        return ((bytedata[i] & 0xff) << 24) | ((bytedata[i + 1] & 0xff) << 16)  
                | ((bytedata[i + 2] & 0xff) << 8) | (bytedata[i + 3] & 0xff);  
    }  
  
    // 整数转换为4字节数组  
    private static void intToByteArray(int intValue, byte[] byteData, int i) {  
        byteData[i] = (byte) (intValue >>> 24);  
        byteData[i + 1] = (byte) (intValue >>> 16);  
        byteData[i + 2] = (byte) (intValue >>> 8);  
        byteData[i + 3] = (byte) intValue;  
    }  
  
    // 将字节转换为十六进制字符串  
    private static String byteToHexString(byte ib) {  
        char[] Digit = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A',  
                'B', 'C', 'D', 'E', 'F' };  
        char[] ob = new char[2];  
        ob[0] = Digit[(ib >>> 4) & 0X0F];  
        ob[1] = Digit[ib & 0X0F];  
        String s = new String(ob);  
        return s;  
    }  
  
    // 将字节数组转换为十六进制字符串  
    private static String byteArrayToHexString(byte[] bytearray) {  
        String strDigest = "";  
        for (int i = 0; i < bytearray.length; i++) {  
            strDigest += byteToHexString(bytearray[i]);  
        }  
        return strDigest;  
    }  
  
    // 计算sha-1摘要，返回相应的字节数组  
    public static byte[] getDigestOfBytes(byte[] byteData) {  
        process_input_bytes(byteData);  
        byte[] digest = new byte[20];  
        for (int i = 0; i < digestInt.length; i++) {  
            intToByteArray(digestInt[i], digest, i * 4);  
        }  
        return digest;  
    }  
  
    // 计算sha-1摘要，返回相应的十六进制字符串  
    public static String getDigestOfString(byte[] byteData) {  
        return byteArrayToHexString(getDigestOfBytes(byteData));  
    }  
  
    /** 
     * 发送post请求 
     *  
     * @param path 
     *            url地址 
     * @param params 
     *            参数集合 
     * @param encode 
     *            请求编码 
     * @param timeout 
     *            超时时间（秒） 
     * @return byte[] byte数组 
     * @throws Exception 
     */  
    public static byte[] post(String path, Map<String, String> params,  
            String encode, int timeout) throws Exception {  
        byte[] resultBuffer = null;  
        Double nonce = Math.floor(Math.random() * 100000 + 100000);  
        Long timestamp = Timestamp.valueOf("2015-3-18 00:00:00").getTime();  
        String signature = getDigestOfString((appSecret + nonce + timestamp)  
                .getBytes());  
        StringBuilder parambuilder = new StringBuilder("");  
        if (params != null && !params.isEmpty()) {  
            for (Map.Entry<String, String> entry : params.entrySet()) {  
                parambuilder.append(entry.getKey()).append("=")  
                        .append(URLEncoder.encode(entry.getValue(), encode))  
                        .append("&");  
            }  
            parambuilder.deleteCharAt(parambuilder.length() - 1);  
        }  
        byte[] data = parambuilder.toString().getBytes();  
        URL url = new URL(path);  
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();  
        conn.setDoOutput(true);  
        conn.setUseCaches(false);  
        conn.setConnectTimeout(timeout * 1000);  
        conn.setReadTimeout(timeout * 1000);  
        conn.setRequestMethod("POST");  
        conn.setRequestProperty(  
                "Accept",  
                "image/gif, image/jpeg, image/pjpeg, image/pjpeg, application/x-shockwave-flash, application/xaml+xml, application/vnd.ms-xpsdocument, application/x-ms-xbap, application/x-ms-application, application/vnd.ms-excel, application/vnd.ms-powerpoint, application/msword, */*");  
        conn.setRequestProperty("Accept-Language", "zh-CN");  
        conn.setRequestProperty("App-Key", appkey);  
        conn.setRequestProperty("Nonce", nonce + "");  
        conn.setRequestProperty("Timestamp", timestamp + "");  
        conn.setRequestProperty("Signature", signature);  
        conn.setRequestProperty(  
                "User-Agent",  
                "Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 5.2; Trident/4.0; .NET CLR 1.1.4322; .NET CLR 2.0.50727; .NET CLR 3.0.04506.30; .NET CLR 3.0.4506.2152; .NET CLR 3.5.30729)");  
        conn.setRequestProperty("Content-Type",  
                "application/x-www-form-urlencoded");  
        conn.setRequestProperty("Content-Length", String.valueOf(data.length));  
        conn.setRequestProperty("Connection", "Keep-Alive");  
        DataOutputStream outStream = new DataOutputStream(  
                conn.getOutputStream());  
        outStream.write(data);  
        outStream.flush();  
        outStream.close();  
        if (conn.getResponseCode() == 200) {  
            resultBuffer = readStream(conn.getInputStream());  
        }  
        conn.disconnect();  
        return resultBuffer;  
    }  
  
    /**  
     * 解析输入流  
     *   
     * @param inStream  
     *            输入流  
     * @return byte[] byte数组  
     * @throws Exception  
     */  
    private static byte[] readStream(InputStream inStream) throws Exception {  
        ByteArrayOutputStream outSteam = new ByteArrayOutputStream();  
        byte[] buffer = new byte[1024];  
        int len = -1;  
        while ((len = inStream.read(buffer)) != -1) {  
            outSteam.write(buffer, 0, len);  
        }  
        outSteam.close();  
        inStream.close();  
        return outSteam.toByteArray();  
    }  
}

分享到：
| MySQL 无法启动
评论
1 楼 沈寅麟 2017-04-12  

注册用户：RongCloudMethodUtil.getToken("用户唯一标示", "", "") 


消息内容   服务器id  用户id  消息类型    消息标题   空-推送安卓，非空-推送苹果 

推送消息：RongCloudMethodUtil.pushSystemMessage(content, fromUserId, toUserId, objectName, pushContent, pushData); 
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    php调用融云demo

    综上所述，PHP调用融云接口涉及的主要知识点包括融云API的使用、HTTP请求的发送、错误处理、安全性以及用户体验的优化。通过这些技术，开发者可以构建出具有即时通讯功能的应用，满足用户的各种聊天需求。

    融云php Api文档

    融云php Api文档

    基于融云H5网页实时聊天

    融云是一家提供即时通讯服务的公司，其API为开发者提供了丰富的接口，使得集成聊天功能变得简单高效。 首先，我们需要了解H5（HTML5）的基础知识。HTML5是超文本标记语言的最新版本，它增强了网页的交互性和多媒体...

    uniapp集成融云IM，简单的demo

    登录时需要传递`token`，这个token需要在服务器端通过融云的接口获取： ```javascript // 登录 RongIM.login('用户token').then(() =&gt; { // 登录成功 }).catch(err =&gt; { // 登录失败 }) // 注销 RongIM....

    融云实现一对一通话和IM功能

    接着，在客户端集成融云SDK，通过SDK提供的接口建立和管理通话。当一方发起视频通话请求时，另一方会收到呼入通知，可以通过接听或拒绝对呼叫进行响应。在通话过程中，可以调整摄像头、麦克风设置，甚至实现美颜、...

    融云实现单聊

    融云提供了丰富的API接口和多语言SDK，如Java、iOS、Android等，使得开发者能够方便地集成到自己的应用中。在实现单聊时，主要涉及到以下几个关键API： 1. 用户注册与登录：首先，需要为每个用户创建一个融云账号，...

    融云及时聊天Demo

    融云SDK提供了丰富的API接口，使得开发者可以轻松地在应用中添加文本、语音、图片、位置等多种消息类型，以及群聊、音视频通话等功能。这个".7z"压缩包是为了减小文件体积，方便传输和下载，因为原始文件可能包含了...

    融云通讯工具实例

    融云提供了丰富的API接口，包括用户管理、会话管理、消息发送接收、群组管理等，开发者可以通过调用这些API在自己的应用中集成聊天功能。例如，`rongcloud-web-im-sdk`是融云为Web端提供的SDK，包含了登录、创建...

    融云demo集成

    融云是中国领先的即时通讯云服务提供商，为开发者提供丰富的通讯功能接口，如文本消息、语音通话、视频聊天、群聊管理等。"融云demo集成"是一个实例项目，旨在帮助那些初次接触融云平台或者在集成过程中遇到困难的...

    融云简易demo

    4. **即时通讯接口**：融云提供了丰富的API接口，如发送文本消息、图片消息、语音消息等。在demo中，我们会看到如何调用这些接口，以及如何处理接收到的消息。 5. **聊天界面设计**：为了展示聊天功能，需要设计...

    聊天（融云）

    - **创建会话**：开发者可以创建单人或群组会话，融云提供了会话管理接口，支持会话的创建、查询和删除。 - **发送与接收消息**：融云SDK支持文本、图片、语音、视频等多种类型的消息，开发者可以通过调用发送和...

    融云的使用demo

    在Android中，可以通过实现`RongIMClient.ConnectionStatusListener`和`RongIMClient.MessageObserver`接口；在iOS中，可遵循`RCIMConnectionStatusDelegate`和`RCIMMessageObserver`协议。 6. **实时推送**： ...

    最新融云SDK集成单聊

    在`RongYunDemo`这个示例应用中，你应该能找到以上所有功能的具体实现，包括各个接口调用、事件监听和界面布局。通过阅读和分析这个示例代码，你将更深入地理解融云SDK的集成步骤和使用方法。 总的来说，融云SDK为...

    基于融云实现的聊天

    4. **实现登录和登出**：使用融云SDK提供的接口完成用户的登录和登出操作，通常需要传递用户的唯一标识（如手机号或用户名）。 5. **创建和接收消息**：通过SDK的API发送和接收各种类型的消息，包括文本、图片、...

    融云自定义消息demo,红包为例

    融云提供了一套完整的API接口，用于处理用户之间的消息传递、群组管理、消息存储以及实时网络状态监控等。在SDK中，内置了多种常见消息类型，如文本、图片、语音等。然而，对于像红包这样的特殊业务需求，我们需要...

    Android融云集成demo

    融云SDK提供了对应的接口供开发者调用。例如，发送文本消息： ```java RongIM.getInstance().sendMessage( TextMessage.obtain("你好，这是测试消息"), conversationType, targetId, new RongIM....

    融云智能聊天工具

    4. 扩展性：为了满足不同业务需求，融云可能提供自定义消息类型、插件机制和开放接口，允许开发者进行二次开发和功能扩展。 5. 群聊与聊天室：支持创建多人聊天室，便于用户进行团队协作或社交活动。 6. 消息历史...

    融云聊天Demo

    4. **会话管理**：融云提供了会话管理接口，允许开发者创建、查询和管理不同的会话类型，如单聊、群聊。你可以通过这些接口获取会话列表、创建新会话或者更新已有的会话。 5. **消息发送与接收**：核心的聊天功能...

    融云 +MUI整合web聊天

    在Web聊天场景中，融云通常提供WebSocket接口，开发者可以通过这些接口实现实时的消息收发。融云API不仅支持一对一聊天，还支持群聊、讨论组等功能，同时具备消息回执、在线状态查询等辅助功能。 其次，**MUI**是...

    融云即时通信IMKIT的集成代码

    - `RCIM`类：是融云IM的主要接口，包含了用户登录、登出、接收消息、创建会话等功能。 - `RCMessage`对象：表示一条消息，包含发送者、接收者、消息内容等信息。 - `RCConversation`对象：代表一个会话，包括会话...

Magicbox
Global site tag (gtag.js) - Google Analytics