orderSystemJp/raising-vue-uniapp-wx/utils/jim-util.js

/**
 * 极光操作库  https://docs.jiguang.cn/jmessage/client/im_sdk_js_v2#%E6%A6%82%E8%BF%B0
 * 极光会话未读数需要自己维护
 * 极光多端消息多端在线 https://docs.jiguang.cn/jmessage/client/im_sdk_js_v2#%E4%BC%9A%E8%AF%9D%E6%9C%AA%E8%AF%BB%E6%95%B0%E5%8F%98%E6%9B%B4%E7%9B%91%E5%90%AC%EF%BC%88%E5%A4%9A%E7%AB%AF%E5%9C%A8%E7%BA%BF%EF%BC%89
 */

import api from '@/utils/api'
import moment from '@/public/moment/moment.js' //时间日期js处理库
//极光IM jsSDK APP非常容易掉线,所以增加重连机制
const initJIM = (config) => {
    return new Promise((resolve, reject) => {
        let JIM = getApp().globalData.JIM
        console.log('<<<----------JIM初始化开始---------->>>');
        if (!JIM.isInit()) {
            // 重新进行初始化登录,超过 次就不在继续
            JIM.init(config).onSuccess(function (data) {
                getApp().globalData.JIM = JIM
                console.log('<<<----------JIM初始化成功---------->>>');
                resolve(data)
            }).onFail(function (data) {
                console.log('<<<----------JIM初始化失败---------->>>');
                // reject(data)
                uni.$emit('JIMDisconnect')
                reject()
            }).onTimeout(function (data) {
                console.log('<<<----------JIM初始化超时---------->>>');
                uni.$emit('JIMDisconnect')
                // initJIM(config) //重连
                reject(data)
            })
        } else {
            resolve()
        }

    })
}

//极光登录
const loginJIM = () => {
    return new Promise((resolve, reject) => {
        let JIM = getApp().globalData.JIM
        //获取用户信息
        let userInfo = uni.getStorageSync('wx_login_user_info')
        let thirdSession = uni.getStorageSync('third_session')
        //还不是点餐平台用户，不登录极光
        if (!userInfo || !userInfo.id || !thirdSession) {
            console.log("还不是点餐平台用户，不登录极光")
            resolve("success");
            return
        }
        let username = userInfo.id
        let password = userInfo.id
        if (JIM.isLogin() && JIM.isConnect()) {
            console.log("极光IM已经登录，无需再登录");
            resolve("success");
            return
        }
        ;
        JIM.login({
            'username': username,
            'password': password
        }).onSuccess(function (data) {
            console.log("极光IM登录成功");
            uni.$emit('JIMLogin')
            // 刷新会话未读数
            refreshConversationUnreadCount(username).then(() => {
                // 获取离线消息
                refreshOfflineMsg()
                // 极光1分钟内最新的消息数据经常会获取不到，所以登录1分钟后再获取一次
                setTimeout(() => {
                    refreshOfflineMsg()
                }, 1000 * 60)
            })
            updateJIMUserInfo(userInfo).then(res => {
                resolve("success");
            });
        }).onFail(function (data) {
            //如果用户不存在，则注册账号
            if (data.code == 880103) {
                let nickname = userInfo.nickName
                JIM.register({
                    'username': username,
                    'password': password,
                    'nickname': nickname,
                    'extras': {
                        'avatar': userInfo.headimgUrl
                    }
                }).onSuccess(function (data) {
                    console.log("极光IM注册成功");
                    //登录
                    JIM.login({
                        'username': username,
                        'password': password
                    }).onSuccess(function (data) {
                        console.log("极光IM登录成功");
                        uni.$emit('JIMLogin')
                        // 刷新会话未读数
                        refreshConversationUnreadCount(username).then(() => {
                            // 获取离线消息
                            refreshOfflineMsg()
                            // 极光1分钟内最新的消息数据经常会获取不到，所以登录1分钟后再获取一次
                            setTimeout(() => {
                                refreshOfflineMsg()
                            }, 1000 * 60)
                        })
                        updateJIMUserInfo(userInfo).then(res => {
                            resolve("success");
                        });
                    }).onFail(function (data) {
                        // 极光IM登录失败
                        console.log(data)
                        resolve("success");
                    });
                }).onFail(function (data) {
                    console.log('JIM -注册失败')
                    console.log(data)
                    resolve("success");
                });
            } else if (data.code == 880109 || data.code == 880107) {
                console.log(data)
            } else {
                console.log('极光IM登录失败')
                console.log(data)
                resolve("success");
            }
        });
    });
}
// 保存消息到本地
const saveJIMMsg = (messages, isOffline) => {
    let userInfo = uni.getStorageSync('wx_login_user_info')
    let localMsgObj = {} // 本地聊天消息,value为聊天记录Array
    for (var i = 0; i < messages.length; i++) { // 极光服务器记录与本地保存的记录比对 保存到本地
        // 极光服务器记录与本地保存的记录比对
        // 云端的记录 时间1 时间2
        // 本地 时间0 时间3
        // 保证记录完整，聊天界面查看时以本地数据为准
        let curMsg = messages[i]
        curMsg.timess = moment(curMsg.ctime_ms).format('HH:mm')
        let chatRecordLocalSaveKey = "chat_record_" + userInfo.tenantId + '_' + userInfo.id + '_';
        let fromId = ''//用一对一聊天的id作为key,
        if (curMsg.from_id == userInfo.id) {
            fromId = curMsg.target_id
        } else {
            fromId = curMsg.from_id
        }
        chatRecordLocalSaveKey = chatRecordLocalSaveKey + fromId
        let localMsgArray = localMsgObj[chatRecordLocalSaveKey]
        if (!localMsgArray) {
            let localMsgStr = uni.getStorageSync(chatRecordLocalSaveKey) // 本地消息
            localMsgObj[chatRecordLocalSaveKey] = localMsgStr ? JSON.parse(localMsgStr) : [];
            localMsgArray = localMsgObj[chatRecordLocalSaveKey]
        }
        let localMsgIds = []
        localMsgIds = localMsgArray.map(itemId => {
            return itemId.msgid
        })
        let curIndex = -1;
        let localMsgArrayLength = localMsgArray.length - 1;
        if (localMsgArray.length > 0 && localMsgIds.indexOf(curMsg.msgid) == -1) { //当前消息是否存在，如果不存在就插入
            if (curMsg.msg_ctime < localMsgArray[0].msg_ctime) { //插入到最前面
                curIndex = 0
            } else {
                localMsgArray.map((itemMsg, index) => {
                    if (localMsgArrayLength == index) {
                        curIndex = index
                    } else if (curMsg.msg_ctime > itemMsg.msg_ctime && curMsg.msg_ctime <
                        localMsgArray[index + 1].msg_ctime) {
                        curIndex = index //插入到指定位置
                        return
                    }
                })
            }
        }
        if (localMsgArray.length > 0) {
            if (curIndex > -1) {
                if (localMsgArrayLength == curIndex) {
                    localMsgArray.push(curMsg)
                    if (isOffline) {
                        // 会话数+1
                        // 刷新会话未读数
                        // 存储的会话数据
                        let conversationDB = uni.getStorageSync("conversation_unread_count_data" + userInfo.id)
                        // 使用对象存储会话未读数，方便更新未读数
                        let conversationsObj = conversationDB ? JSON.parse(conversationDB) : {};
                        // 会话未读数
                        if (conversationsObj[fromId]) {
                            conversationsObj[fromId] = conversationsObj[fromId] + 1
                        } else {
                            conversationsObj[fromId] = 1
                        }
                        uni.setStorageSync("conversation_unread_count_data" + userInfo.id, JSON.stringify(
                            conversationsObj)) //保存会话
                    }
                } else {
                    localMsgArray.splice(curIndex, 0, curMsg)
                }
            }
        } else {
            localMsgArray.push(curMsg)
            if (isOffline) {
                // 会话数+1
                // 刷新会话未读数
                // 存储的会话数据
                let conversationDB = uni.getStorageSync("conversation_unread_count_data" + userInfo.id)
                // 使用对象存储会话未读数，方便更新未读数
                let conversationsObj = conversationDB ? JSON.parse(conversationDB) : {};
                // 会话未读数
                if (conversationsObj[fromId]) {
                    conversationsObj[fromId] = conversationsObj[fromId] + 1
                } else {
                    conversationsObj[fromId] = 1
                }
                uni.setStorageSync("conversation_unread_count_data" + userInfo.id, JSON.stringify(conversationsObj)) //保存会话
            }
        }
    }
    // 保存聊天数据
    for (let key in localMsgObj) {
        uni.setStorageSync(key, JSON.stringify(localMsgObj[key]));
        // uni.removeStorageSync(key) //清空聊天消息
    }
    console.log('保存消息成功')
}

const refreshOfflineMsg = () => {
    // 获取离线消息
    getJIMOfflineMsg().then(() => {
        // 更新消息未读数
        getJIMUnreadMsgCnt()
        // 消息接收通知
        uni.$emit('msg_ol')
    })
}
// 获取极光离线消息保存到本地【注意：这个接口2分钟内的消息数据是没有的】

const getJIMOfflineMsg = () => {
    return new Promise((resolve, reject) => {
        //获取用户信息
        let userInfo = uni.getStorageSync('wx_login_user_info')
        // 拉取极光服务器消息数据
        let end_time = moment().format('YYYY-MM-DD HH:mm:ss');
        // 极光免费版只能获取7天内的聊天记录
        let begin_time = moment().subtract(7, "days").format('YYYY-MM-DD HH:mm:ss');
        api.getJiguangMessages({
            userName: userInfo.id,
            beginTime: begin_time,
            endTime: end_time
        }).then(res => {
            let lszs = JSON.parse(res.data).messages; // 极光的聊天记录，包含了所有人的
            console.log("离线消息")
            // console.log(lszs)
            if (lszs) {
                saveJIMMsg(lszs, true)
                console.log('保存离线消息成功')
                resolve()
            } else {
                reject()
            }
        }).catch(() => {
            console.log('保存离线消息失败')
            reject()
        })
    })

}
// 刷新会话未读数
const refreshConversationUnreadCount = (userId) => {
    return new Promise((resolve, reject) => {
        // 会话未读数需要开发者自己维护 https://community.jiguang.cn/question/248440
        // 如果极光的未读数有值那么就用极光的，否则就用本地的未读数的值表示本地的消息未读过
        let JIM = getApp().globalData.JIM
        JIM.getConversation().onSuccess(function (data) {
            // 极光的会话数据
            let conversation = data.conversations.reverse()
            console.log('获取极光的会话数据成功')
            // 本地存储的会话数据
            // let conversationUnreadDB = uni.getStorageSync("conversation_unread_count_data")
            let conversationsObj = {};
            conversation.map((item) => {
                conversationsObj[item.username] = 0
            })
            uni.setStorageSync("conversation_unread_count_data" + userId, JSON.stringify(
                conversationsObj)) //保存会话
            // uni.setStorageSync("conversation_unread_count_data","") //清空会话
            resolve(conversation)
        }).onFail(function (data) {
            console.log('JIM fail:' + data)
            reject()
        });
    })
}
//刷新会话未读数
const getJIMUnreadMsgCnt = () => {
    //获取用户信息
    let userInfo = uni.getStorageSync('wx_login_user_info')
    let count = 0
    if (userInfo) {
        // 存储的会话数据
        let conversationUnreadDB = uni.getStorageSync("conversation_unread_count_data" + userInfo.id)
        let conversationsObj = conversationUnreadDB ? JSON.parse(conversationUnreadDB) : {};
        for (const key in conversationsObj) {
            count = count + conversationsObj[key]
        }
    }
    // 设置tabbar未读数量
    uni.setTabBarBadge({
        index: 2,
        text: count + ''
    });
}
//更新极光IM用户信息
const updateJIMUserInfo = (userInfo) => {
    let username = userInfo.id
    return new Promise((resolve, reject) => {
        let JIM = getApp().globalData.JIM;
        JIM.getUserInfo({
            'username': username,
        }).onSuccess(function (data) {
            console.log('获取IM用户信息成功')
            let nickname = userInfo.nickName
            if (data.user_info.nickname != nickname || data.user_info.extras.avatar != userInfo
                .headimgUrl) {
                console.log('更新JIM用户信息')
                JIM.updateSelfInfo({
                    'nickname': nickname,
                    'extras': {
                        'avatar': userInfo.headimgUrl
                    }
                }).onSuccess(function (data) {
                    //data.code 返回码
                    //data.message 描述
                    resolve("success");
                }).onFail(function (data) {
                    console.log('updataJIMUserInfo fail:' + data)
                    resolve("success");
                });
            } else {
                resolve("success");
            }
        }).onFail(function (data) {
            //data.code 返回码
            //data.message 描述
            resolve("success");
        });
    });
}
const clearConversationMsgUnread = (chatId) => {
    //获取用户信息
    let userInfo = uni.getStorageSync('wx_login_user_info')
    if (userInfo) {
        // 会话未读数数清零
        let conversationUnreadDB = uni.getStorageSync("conversation_unread_count_data" + userInfo.id)
        if (conversationUnreadDB) {
            let conversationsObj = conversationUnreadDB ? JSON.parse(conversationUnreadDB) : {};
            conversationsObj[chatId] = 0;
            uni.setStorageSync("conversation_unread_count_data" + userInfo.id, JSON.stringify(conversationsObj)) //保存会话
        }
    }
}

// 创建一条消息，用于本地缓存消息
const createLocalMessage = (msgid, msg_ctime, msgContent) => {

    return {
        ...msgContent,
        msgid,
        msg_ctime,
        is_local_msg: true //是否是本地缓存的消息
    }
}

module.exports = {
    initJIM,
    loginJIM,
    saveJIMMsg,
    refreshOfflineMsg,
    getJIMOfflineMsg,
    refreshConversationUnreadCount,
    getJIMUnreadMsgCnt,
    updateJIMUserInfo,
    clearConversationMsgUnread,
    createLocalMessage,

}