|
|
/*
|
|
|
* @Author: ch
|
|
|
* @Date: 2022-05-18 14:54:47
|
|
|
* @LastEditors: ch
|
|
|
* @LastEditTime: 2022-06-14 11:49:08
|
|
|
* @Description: file content
|
|
|
*/
|
|
|
import { CreateUUID, FormatDate, ToAsyncAwait } from "@/plugins/utils";
|
|
|
import './potoReq';
|
|
|
import './protoRsp';
|
|
|
const connect = Symbol('connect');
|
|
|
const send = Symbol('send');
|
|
|
const onMessage = Symbol('onMessage');
|
|
|
const fromatPotoReq = (traceId, traceType, content) => {
|
|
|
let messageModel = new proto.ReqModel();
|
|
|
messageModel.setTraceid(traceId);
|
|
|
messageModel.setTracetype(traceType);
|
|
|
content && messageModel.setContent(JSON.stringify(content));
|
|
|
return messageModel.serializeBinary();
|
|
|
},
|
|
|
fromatPotoRsp = (data) => {
|
|
|
const res = proto.RspModel.deserializeBinary(new Uint8Array(data));
|
|
|
let ctx = res.getContent();
|
|
|
ctx = ctx ? JSON.parse(ctx) : {};
|
|
|
if (ctx.payload) {
|
|
|
ctx.payload = JSON.parse(ctx.payload);
|
|
|
}
|
|
|
return {
|
|
|
content: ctx,
|
|
|
traceId: res.getTraceid(),
|
|
|
traceType: res.getTracetype(),
|
|
|
code: res.getCode(),
|
|
|
message: res.getMessage(),
|
|
|
};
|
|
|
};
|
|
|
|
|
|
class MsbIm {
|
|
|
defaultOption = {
|
|
|
ioKey: 'traceId',
|
|
|
reconnect: true,
|
|
|
};
|
|
|
socket = null;
|
|
|
isOpen = false;
|
|
|
queue = {};
|
|
|
interceptors = {
|
|
|
dataChangeBefore: null,
|
|
|
dataChangeAfter: null,
|
|
|
onClose: null,
|
|
|
onMessage: null,
|
|
|
};
|
|
|
sessionData = [];
|
|
|
curSessionId = null;
|
|
|
constructor(option) {
|
|
|
this.option = {
|
|
|
...this.defaultOption,
|
|
|
...option,
|
|
|
};
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* 创建连接返回一个Promise 创建成功并成功打开连接算连接成功
|
|
|
* @param {*} option
|
|
|
*/
|
|
|
[connect](option) {
|
|
|
return new Promise((resolve, reject) => {
|
|
|
const open = () => {
|
|
|
console.log('[im] open');
|
|
|
this.isOpen = true;
|
|
|
resolve(this.socket);
|
|
|
};
|
|
|
const message = async (res) => {
|
|
|
const result = fromatPotoRsp(res.data);
|
|
|
this.interceptors.onMessage && this.interceptors.onMessage(result);
|
|
|
// 处理服务端主动推送的消息
|
|
|
this[onMessage](result);
|
|
|
|
|
|
// 如果再消息堆里有此消息回调，则执行回调，并删除
|
|
|
const cbk = this.queue[result[this.option.ioKey]];
|
|
|
|
|
|
if (cbk) {
|
|
|
cbk(result.code !== 200 ? { error: result } : { result: result });
|
|
|
delete this.queue[result[this.option.ioKey]];
|
|
|
}
|
|
|
};
|
|
|
const close = () => {
|
|
|
console.log('[im] close');
|
|
|
this.interceptors.onClose && this.interceptors.onClose();
|
|
|
};
|
|
|
let isUni = false;
|
|
|
try {
|
|
|
isUni = uni;
|
|
|
} catch (e) {
|
|
|
isUni = false;
|
|
|
}
|
|
|
if (isUni) {
|
|
|
this.socket = uni.connectSocket({
|
|
|
...this.option,
|
|
|
fail(e) {
|
|
|
reject(e);
|
|
|
},
|
|
|
});
|
|
|
this.socket.onOpen(() => {
|
|
|
open();
|
|
|
this.socket.onMessage((res) => {
|
|
|
message(res);
|
|
|
});
|
|
|
});
|
|
|
this.socket.onClose(() => {
|
|
|
close();
|
|
|
});
|
|
|
} else if (WebSocket) {
|
|
|
try {
|
|
|
this.socket = new WebSocket(this.option.url);
|
|
|
this.socket.binaryType = 'arraybuffer';
|
|
|
this.socket.onopen = () => {
|
|
|
open();
|
|
|
};
|
|
|
this.socket.onmessage = (res) => {
|
|
|
message(res);
|
|
|
};
|
|
|
this.socket.onclose = () => {
|
|
|
close();
|
|
|
};
|
|
|
} catch (e) {
|
|
|
reject(e);
|
|
|
}
|
|
|
}
|
|
|
});
|
|
|
}
|
|
|
/**
|
|
|
* 向服务端发送消息||请求，返回一个Promise对象，收到ioKey对应的消息会算一个同步完成
|
|
|
* @param {*} data
|
|
|
*/
|
|
|
[send](data) {
|
|
|
return new Promise((resolve, reject) => {
|
|
|
if (!this.isOpen) {
|
|
|
return reject('连接未打开');
|
|
|
}
|
|
|
this.queue[data[this.option.ioKey]] = ({ result, error }) => {
|
|
|
if (result) {
|
|
|
resolve(result);
|
|
|
} else {
|
|
|
reject(error);
|
|
|
}
|
|
|
};
|
|
|
|
|
|
const par = fromatPotoReq(data.traceId, data.traceType, data.content);
|
|
|
|
|
|
let isUni = false;
|
|
|
try {
|
|
|
isUni = uni;
|
|
|
} catch (e) {
|
|
|
isUni = false;
|
|
|
}
|
|
|
if (isUni) {
|
|
|
this.socket.send({
|
|
|
data: par,
|
|
|
fail(e) {
|
|
|
reject({ error: e });
|
|
|
},
|
|
|
});
|
|
|
} else if (WebSocket) {
|
|
|
this.socket.send(par);
|
|
|
}
|
|
|
});
|
|
|
}
|
|
|
/**
|
|
|
* 服务端推送消息，只处理服务端主动推送的消息
|
|
|
* @param {*} data
|
|
|
*/
|
|
|
[onMessage](data) {
|
|
|
// 判断非服务端主动推送消息不做处理
|
|
|
if (data[this.option.ioKey] || data.code !== 200) {
|
|
|
return false;
|
|
|
}
|
|
|
console.log('[im] 主动接收的消息', data);
|
|
|
let ctx = data.content;
|
|
|
let historyData = [...this.sessionData],
|
|
|
newData = [];
|
|
|
const hisIndex = historyData.findIndex((i) => i.id === ctx.sessionId);
|
|
|
if (hisIndex >= 0) {
|
|
|
// 存在会话往现有会话增加一条消息,并修改最后一条消息为当前消息
|
|
|
const curHisData = historyData[hisIndex];
|
|
|
curHisData.messageList.push(ctx);
|
|
|
curHisData.lastMessage = ctx;
|
|
|
// 不在当前会话窗口则向会话消息加1条未读
|
|
|
if (ctx.sessionId !== this.curSessionId) {
|
|
|
curHisData.unreadCount++;
|
|
|
} else {
|
|
|
this.setRead({
|
|
|
content: {
|
|
|
sessionId: this.curSessionId,
|
|
|
},
|
|
|
});
|
|
|
}
|
|
|
newData = historyData;
|
|
|
} else {
|
|
|
// 会话列表不存在，则创建一个会话
|
|
|
newData = [
|
|
|
...historyData,
|
|
|
{
|
|
|
fromAvatar: ctx.session.fromAvatar,
|
|
|
fromId: ctx.fromId,
|
|
|
fromNickname: ctx.session.fromNickname,
|
|
|
id: ctx.sessionId,
|
|
|
lastMessage: ctx,
|
|
|
messageList: [ctx],
|
|
|
updateTimeStamp: ctx.createTimeStamp,
|
|
|
unreadCount: 1,
|
|
|
},
|
|
|
];
|
|
|
}
|
|
|
this.setSessionData(newData);
|
|
|
}
|
|
|
init(config) {
|
|
|
return new Promise((resolve, reject) => {
|
|
|
const heart = () => {
|
|
|
// 要优化 心跳没回复需要重连
|
|
|
setTimeout(async () => {
|
|
|
if (this.isOpen) {
|
|
|
await this[send]({
|
|
|
traceId: CreateUUID(),
|
|
|
traceType: 0,
|
|
|
content: { text: 'ping' },
|
|
|
});
|
|
|
}
|
|
|
heart();
|
|
|
}, 1000);
|
|
|
};
|
|
|
this.option = {
|
|
|
...this.option,
|
|
|
...config,
|
|
|
};
|
|
|
this[connect]()
|
|
|
.then((res) => {
|
|
|
resolve(res);
|
|
|
heart();
|
|
|
})
|
|
|
.catch((e) => {
|
|
|
console.log('eeeee', e);
|
|
|
});
|
|
|
});
|
|
|
}
|
|
|
/**
|
|
|
* 设置数据
|
|
|
*/
|
|
|
setSessionData(data) {
|
|
|
let newData = JSON.parse(JSON.stringify(data));
|
|
|
this.interceptors.dataChangeBefore && this.interceptors.dataChangeBefore(newData, this.sessionData);
|
|
|
this.sessionData = newData;
|
|
|
this.interceptors.dataChangeAfter && this.interceptors.dataChangeAfter(this.sessionData);
|
|
|
}
|
|
|
/**
|
|
|
* 设置当前聊天窗口
|
|
|
* Data为Session数据
|
|
|
* @param {*} data
|
|
|
*/
|
|
|
setCurSessionId(id) {
|
|
|
this.curSessionId = id;
|
|
|
}
|
|
|
/**
|
|
|
* 获取会话列表
|
|
|
* @param {*} params
|
|
|
*/
|
|
|
async getSessionList(params) {
|
|
|
const par = {
|
|
|
traceId: CreateUUID(),
|
|
|
traceType: 1,
|
|
|
...params,
|
|
|
};
|
|
|
|
|
|
console.log('[im] 获取会话列表--start', par);
|
|
|
let { error, result } = await ToAsyncAwait(this[send](par));
|
|
|
console.log('[im] 获取会话列表--end', result, error);
|
|
|
if (error) {
|
|
|
return Promise.reject(error);
|
|
|
}
|
|
|
const { content } = result;
|
|
|
// let newData = [];
|
|
|
|
|
|
content.sessionVOS.forEach((item) => {
|
|
|
if (item.lastMessage) {
|
|
|
item.lastMessage.payload = JSON.parse(item.lastMessage.payload || {});
|
|
|
}
|
|
|
let historyData = this.sessionData;
|
|
|
let hisIndex = historyData.findIndex((i) => i.id === item.id);
|
|
|
if (hisIndex < 0) {
|
|
|
item.messageList = [];
|
|
|
}
|
|
|
// let historyData = this.sessionData;
|
|
|
// let hisIndex = historyData.findIndex((i) => i.id === item.id);
|
|
|
// if (hisIndex >= 0) {
|
|
|
// historyData[hisIndex].lastMessage = item.lastMessage;
|
|
|
// historyData[hisIndex].unreadCount++;
|
|
|
// newData.push(historyData[hisIndex]);
|
|
|
// } else {
|
|
|
// item.messageList = [];
|
|
|
// newData = [...newData, item];
|
|
|
// }
|
|
|
});
|
|
|
this.setSessionData(content.sessionVOS);
|
|
|
return Promise.resolve(result);
|
|
|
}
|
|
|
/**
|
|
|
* 获取会话的历史消息记录
|
|
|
* @param {*} params
|
|
|
*/
|
|
|
async getHistoryMsg() {
|
|
|
const curSessionIdx = this.sessionData.findIndex((i) => i.id === this.curSessionId);
|
|
|
const curSession = this.sessionData[curSessionIdx];
|
|
|
console.log(curSession, this.curSessionId,'this.curSessionId');
|
|
|
const msgList = curSession.messageList || [];
|
|
|
const par = {
|
|
|
traceId: CreateUUID(),
|
|
|
traceType: 2,
|
|
|
content: {
|
|
|
sessionId: this.curSessionId,
|
|
|
topMessageId: msgList.length ? msgList[0].id : null,
|
|
|
},
|
|
|
};
|
|
|
console.log('[im] 获取会话历史消息--start', par);
|
|
|
const { error, result } = await ToAsyncAwait(this[send](par));
|
|
|
console.log('[im] 获取会话历史消息--end', result, error);
|
|
|
if (error) {
|
|
|
return Promise.reject(error);
|
|
|
}
|
|
|
const { content } = result;
|
|
|
if (content.length) {
|
|
|
let newData = this.sessionData;
|
|
|
content.forEach((item) => {
|
|
|
item.payload = JSON.parse(item.payload);
|
|
|
});
|
|
|
newData[curSessionIdx].messageList = content.concat(newData[curSessionIdx].messageList);
|
|
|
this.setSessionData(newData);
|
|
|
}
|
|
|
return Promise.resolve(result);
|
|
|
}
|
|
|
/**
|
|
|
* 会话已读
|
|
|
* @param {*} params
|
|
|
*/
|
|
|
async setRead(params) {
|
|
|
const par = {
|
|
|
traceId: CreateUUID(),
|
|
|
traceType: '6',
|
|
|
...params,
|
|
|
};
|
|
|
console.log('[im] 会话已读--start', par);
|
|
|
const { error, result } = await this[send](par);
|
|
|
console.log('[im] 会话已读--end', result, error);
|
|
|
|
|
|
let newData = this.sessionData.map((item) => {
|
|
|
if (item.id == params.content.sessionId) {
|
|
|
item.unreadCount = 0;
|
|
|
}
|
|
|
return item;
|
|
|
});
|
|
|
|
|
|
this.setSessionData(newData);
|
|
|
}
|
|
|
/**
|
|
|
* 发送消息
|
|
|
* @param {*} params
|
|
|
*/
|
|
|
async sendMsg(params) {
|
|
|
const index = this.sessionData.findIndex((i) => i.id === this.curSessionId);
|
|
|
let curSession = this.sessionData[index];
|
|
|
// 临时消息体
|
|
|
let par = {
|
|
|
...params,
|
|
|
traceId: CreateUUID(),
|
|
|
traceType: 3,
|
|
|
};
|
|
|
let msgCtx = {
|
|
|
...params.content,
|
|
|
...par,
|
|
|
createTimeStamp: new Date().getTime(),
|
|
|
sendStatus: 'loading',
|
|
|
};
|
|
|
if (typeof msgCtx.payload === 'string') {
|
|
|
msgCtx.payload = JSON.parse(msgCtx.payload);
|
|
|
}
|
|
|
// 点发送，立即把消息加入消息列表，标记为发送中状态
|
|
|
curSession.messageList.push(msgCtx);
|
|
|
this.setSessionData(this.sessionData);
|
|
|
|
|
|
// 超过时间未返回视为发送失败
|
|
|
this.timerStatus(msgCtx);
|
|
|
|
|
|
console.log('[im] 发送消息--start', par);
|
|
|
const { error, result } = await ToAsyncAwait(this[send](par));
|
|
|
console.log('[im] 发送消息--end', result, error);
|
|
|
// 接到通知，标记消息是否发送成功
|
|
|
for (let i = curSession.messageList.length; i--; ) {
|
|
|
const item = curSession.messageList[i];
|
|
|
if (item[this.option.ioKey] === par[this.option.ioKey]) {
|
|
|
curSession.messageList[i].sendStatus = msgCtx.sendStatus = error ? 'fail' : 'success';
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
let newData = [...this.sessionData];
|
|
|
newData[index] = curSession;
|
|
|
this.setSessionData(newData);
|
|
|
if (error) {
|
|
|
return Promise.reject(error);
|
|
|
}
|
|
|
|
|
|
return Promise.resolve(result);
|
|
|
}
|
|
|
/**
|
|
|
* 发送失败时，重新发送
|
|
|
* @param {*} params
|
|
|
*/
|
|
|
async resend(params) {
|
|
|
params.sendStatus = 'loading';
|
|
|
this.timerStatus(params);
|
|
|
|
|
|
console.log('[im] 重新发送消息--start', params);
|
|
|
const { error, result } = await ToAsyncAwait(
|
|
|
this[send]({
|
|
|
traceId: params.traceId,
|
|
|
traceType: params.traceType,
|
|
|
content: params.content,
|
|
|
})
|
|
|
);
|
|
|
console.log('[im] 重新发送消息--end', result, error);
|
|
|
params.createTimeStamp = result.createTimeStamp;
|
|
|
if (error) {
|
|
|
params.sendStatus = 'fail';
|
|
|
return Promise.reject(error);
|
|
|
}
|
|
|
params.sendStatus = 'success';
|
|
|
return Promise.resolve(result);
|
|
|
}
|
|
|
timerStatus(msg) {
|
|
|
setTimeout(() => {
|
|
|
if (msg.sendStatus === 'loading') {
|
|
|
msg.sendStatus = 'fail';
|
|
|
delete this.queue[msg.traceId];
|
|
|
}
|
|
|
}, 3000);
|
|
|
}
|
|
|
/**
|
|
|
* 主动创建会话
|
|
|
* @param {*} params
|
|
|
*/
|
|
|
async createSession(params) {
|
|
|
const par = {
|
|
|
traceId: CreateUUID(),
|
|
|
traceType: 9,
|
|
|
...params,
|
|
|
};
|
|
|
console.log('[im] 主动创建会话--start', par);
|
|
|
const { result, error } = await ToAsyncAwait(this[send](par));
|
|
|
console.log('[im] 主动创建会话--end', result, error);
|
|
|
if (error) {
|
|
|
return Promise.reject(error);
|
|
|
}
|
|
|
const { content } = result;
|
|
|
let historyData = this.sessionData;
|
|
|
let curSession = historyData.find((i) => i.id === content.id);
|
|
|
if (!curSession) {
|
|
|
curSession = {
|
|
|
...content,
|
|
|
unreadCount: 0,
|
|
|
messageList: [],
|
|
|
};
|
|
|
const newData = [...historyData, curSession];
|
|
|
this.setSessionData(newData);
|
|
|
}
|
|
|
return Promise.resolve(result);
|
|
|
}
|
|
|
close() {
|
|
|
this.socket.close();
|
|
|
this.socket = null;
|
|
|
this.isOpen = false;
|
|
|
this.setSessionData([]);
|
|
|
}
|
|
|
}
|
|
|
export default MsbIm; |
