@aochuang/client-sdk 1.0.278

package/services/client-chat/client-chat-wechat/client-chat.js

@@ -0,0 +1,1065 @@
+import Vue from 'vue'
+import ClientChatSession from './client-chat-session.js'
+import ClientChatMessage from './client-chat-message.js'
+import ClientChatContacts from './client-chat-concats.js'
+import ClientChatAccount from './client-chat-account.js'
+import ClientChatSocket from './client-chat-socket.js'
+import ClientChatDraft from './client-chat-draft.js'
+import { createSessionId } from '../../../utils/string.js'
+import Event from '../../../utils/event.js'
+import { createSerialQueue } from '../../../utils/queue'
+import ClientChatSessionManage from './client-chat-session-manage.js'
+
+const CONNECT_STATUS = {
+	Normal: 'normal',
+	Loading: 'loading',
+	Complete: 'complete'
+}
+
+function shouldIgnoreSessionByMessage (data) {
+	// 群发消息的不处理会话
+	// public enum MsgSubTypeEnum {
+	// 	/*0：普通的聊天*/
+	// 	COMMON,
+	// 	/*1：分配记录消息*/
+	// 	ALLOT_MSG,
+	// 	/*2：批量发送*/
+	// 	BATCH_SEND,
+	// 	/*3：通过好友恢复*/
+	// 	ACCEPT_REPLY,
+	// 	/*4：自动回复*/
+	// 	AUTO_REPLY,
+	// 	// 5：入群欢迎语
+	// 	CHATROOM_WELCOME,
+	// 	//6：指定时间段内自动回复消息
+	// 	AUTO_REPLY_INTIME,
+	// 	//7：群自动回复
+	// 	CHATROOM_REPLY
+	// }
+	if (data.msgSubType === 2) {
+		return true
+	}
+	return data && data.msgType === 10000 && data.content && ['消息已发出，但被对方拒收了', '请先发送朋友验证请求，对方验证通过后，才能聊天'].some(v => data.content.indexOf(v) >= 0)
+}
+
+function isAutoReadMessage (data) {
+	return !!(data && data.id && data.id.indexOf('AUTO-READ-') === 0)
+}
+
+class ClientChat {
+	data = Vue.observable({
+		connectStatus: CONNECT_STATUS.Normal
+	})
+	
+	get connecting () {
+		return this.data.connectStatus === CONNECT_STATUS.Loading
+	}
+	
+	constructor (options) {
+		options = Object.assign({
+			socket: null,
+			checkSocketEventNotifyMethod: null,
+			getLoginUserIdMethod: null,
+			getLoginUserTokenMethod: null,
+			loadAccountDataMethod: null,
+			getLoginAccountIdMethod: null, // 因为1.0有帮聊逻辑，帮聊消息以及通讯录的accountId不是登录用户的accountId，会导致找到的会话出现问题，所以这里提供一个方法让外部传入
+			getAccountUnreadMessageNumMethod: null,
+			updateAccountMessageReadMethod: null,
+			deleteAccountSessionMethod: null,
+			getAccountGreetingUnreadMsgCountMethod: null,
+			clearAccountGreetingUnreadMsgCountMethod: null,
+			loadContactsRoomGroupDataMethod: null,
+			loadContactsFriendGroupDataMethod: null,
+			loadContactsFriendDataMethod: null,
+			loadContactsRoomDataMethod: null,
+			loadContactsRoomMemberDataMethod: null,
+			getContactsFriendGroupCountMethod: null,
+			getContactsRoomGroupCountMethod: null,
+			getContactsFriendMethod: null,
+			getContactsRoomMethod: null, 
+			stickyTopSessionMethod: null,
+			muteNotificationSessionMethod: null,
+			deleteSessionMethod: null,
+			getNextUnreadSessionMethod: null,
+			loadSessionDataMethod: null, 
+			loadAssignTaskSessionDataMethod: null,
+			updateSessionReadMethod: null,
+			loadStarSessionDataMethod: null,
+			loadUnreadSessionDataMethod: null,
+			starSessionMethod: null,
+			unstarSessionMethod: null,
+			getSessionMethod: null,
+			loadFriendMessageDataMethod: null, 
+			loadRoomMessageDataMethod: null,
+			checkMessageSendResultMethod: null,
+			loadLossRoomMessageDataMethod: null,
+			loadLossFriendMessageDataMethod: null,
+			onOverwriteFriendInfoChange: null // 为了兼容1.0拉取会话逻辑加的，1.0暂时不支持根据taskId拉取
+		}, options)
+		if (!options.loadFriendMessageDataMethod) {
+			throw new Error('loadFriendMessageDataMethod不能为空')
+		} 
+		if (!options.loadRoomMessageDataMethod) {
+			throw new Error('loadRoomMessageDataMethod不能为空')
+		} 
+		this.onOverwriteFriendInfoChange = options.onOverwriteFriendInfoChange
+		this.event = new Event({
+			checkOnMethod: (name) => {
+				if (name === 'ready') {
+					if (this.data.connectStatus === CONNECT_STATUS.Complete) {
+						this.event.emit('ready')
+					}
+				}
+			}
+		})
+		const mergeSessionCommonOptions = (options, instance) => {
+			let updateSessioning = false
+			let deleteSessioning = false
+			options.onAddSession = ({ session }) => {
+				// 同步未读会话
+				if (instance !== this.sessionUnread && session.unreadMsgCount > 0) {
+					const localSession = this.sessionUnread.findSession((localSession) => localSession.conversationId === session.conversationId)
+					if (!localSession) {
+						this.sessionUnread.addSession(Object.assign({}, session))
+					} else {
+						this.sessionUnread.updateSession(session.conversationId, session)
+					}
+				}
+			}
+			options.onUpdateSession = ({ session, updateProps, changeProps }) => {
+				if (updateSessioning) {
+					return
+				}
+				updateSessioning = true
+				try {
+					if (changeProps && changeProps.mute) {
+						this.account.refreshAccountUnreadMessageNum({
+							wechatAccountId: session.wechatAccountId
+						})
+					}
+					if (changeProps && changeProps.starMark) {
+						if (changeProps.starMark.after === true) {
+							this.sessionStar.addSession(Object.assign({}, session))
+						} else {
+							this.sessionStar.removeSession(session.conversationId, false)
+						}
+					}
+					// 同步未读会话，如果是从最近会话更新的才同步，否则会导致从未读会话标记已读马上就删除了
+					if (instance === this.session && changeProps && changeProps.unreadMsgCount && changeProps.unreadMsgCount.after > 0) {
+						const localSession = this.sessionUnread.findSession((localSession) => localSession.conversationId === session.conversationId)
+						if (!localSession) {
+							this.sessionUnread.addSession(Object.assign({}, session))
+						} else {
+							this.sessionUnread.updateSession(session.conversationId, session)
+						}
+					}
+					const sessionInstances = this.sessionManage.getSessionInstacesBySessionId(session.conversationId)
+					sessionInstances.forEach(sessionInstance => {
+						if (instance === sessionInstance) {
+							return
+						}
+						// 同步其他session实例
+						sessionInstance.updateSession(session.conversationId, updateProps)
+					})
+				} catch (error) {
+					console.error('[client-chat] onUpdateSession sync error', {
+						instance: instance && instance.name,
+						sessionId: session && session.conversationId,
+						updateProps,
+						changeProps,
+						error
+					})
+					throw error
+				} finally {
+					updateSessioning = false
+				}
+			}
+			options.onRemoveSession = ({ session }) => {
+				// 移除不做同步，例如未读会话，前端会自己删除已读的会话，这个时候不能做同步，否则会把最近会话也移除了
+			}
+			options.onDeleteSession = ({ session }) => {
+				if (!session) {
+					return
+				}
+				if (deleteSessioning) {
+					return
+				}
+				deleteSessioning = true
+				try {
+					this.account.updateAccountUnreadMessageNum(session.wechatAccountId, ({ unreadMesasgeNum, unreadMessageMuteNum }) => {
+						// 如果是免打扰的会话
+						if (session.mute) {
+							return {
+								num: Math.max((unreadMesasgeNum || 0) - (session.unreadMsgCount || 0), 0),
+								muteNum: Math.max((unreadMessageMuteNum || 0) - (session.unreadMsgCount || 0), 0)
+							}
+						} else {
+							return {
+								num: Math.max((unreadMesasgeNum || 0) - (session.unreadMsgCount || 0), 0),
+								muteNum: unreadMessageMuteNum
+							}
+						}
+					})
+					// 删除会话会同步删除所有的实例，所以需要做这个检查
+					if (this.sessionManage.currentSession && this.sessionManage.currentSession.conversationId === session.conversationId) {
+						this.sessionManage.setCurrentSession(null)
+					}
+					const sessionInstances = this.sessionManage.getSessionInstacesBySessionId(session.conversationId)
+					sessionInstances.forEach(sessionInstance => {
+						if (instance === sessionInstance) {
+							return
+						}
+						// 移除前先把未读消息数量设置为0，否则后面微信号的未读数量会重复扣减
+						sessionInstance.updateSession(session.conversationId, {
+							unreadMsgCount: 0
+						})
+						// 同步其他session实例
+						sessionInstance.removeSession(session.conversationId)
+					})
+				} catch (error) {
+					console.error('[client-chat] onDeleteSession sync error', {
+						instance: instance && instance.name,
+						sessionId: session && session.conversationId,
+						error
+					})
+					throw error
+				} finally {
+					deleteSessioning = false
+				}
+			}
+			options.onClearVirtualSession = ({ virtualSessionData }) => {
+				const selectedVirtualSession = virtualSessionData.find(v => this.sessionManage.currentSession && v.conversationId === this.sessionManage.currentSession.conversationId)
+				if (selectedVirtualSession) {
+					this.sessionManage.setCurrentSession(null)
+				}
+				// 还要更新未读消息数量
+			}
+			options.onSessionReadChange = ({ session, oldUnreadMsgCount }) => {
+				const isMute = session.mute
+				this.account.updateAccountUnreadMessageNum(session.wechatAccountId, ({ unreadMesasgeNum, unreadMessageMuteNum }) => {
+					// 如果是免打扰的会话
+					if (isMute) {
+						return {
+							num: Math.max(0, unreadMesasgeNum - oldUnreadMsgCount),
+							muteNum: Math.max(0, unreadMessageMuteNum - oldUnreadMsgCount)
+						}
+					} else {
+						return {
+							num: Math.max(0, unreadMesasgeNum - oldUnreadMsgCount),
+							muteNum: unreadMessageMuteNum
+						}
+					}
+				})
+			}
+		}
+		this.session = new ClientChatSession({
+			groupField: 'wechatAccountId',
+			sortField: 'lastMsgTime',
+			name: 'session',
+			loadAssignTaskSessionDataMethod: options.loadAssignTaskSessionDataMethod,
+			loadSessionDataMethod: options.loadSessionDataMethod, 
+			updateSessionReadMethod: options.updateSessionReadMethod,
+			getSessionMethod: options.getSessionMethod,
+			stickyTopSessionMethod: options.stickyTopSessionMethod,
+			muteNotificationSessionMethod: options.muteNotificationSessionMethod,
+			getNextUnreadSessionMethod: options.getNextUnreadSessionMethod,
+			deleteSessionMethod: options.deleteSessionMethod,
+			starSessionMethod: options.starSessionMethod,
+			unstarSessionMethod: options.unstarSessionMethod,
+			onBeforeCreate: ({ options, instance }) => {
+				mergeSessionCommonOptions(options, instance)
+			}
+		})
+		this.sessionFilter = new ClientChatSession({
+			groupField: 'wechatAccountId',
+			sortField: 'lastMsgTime',
+			name: 'sessionFilter',
+			loadAssignTaskSessionDataMethod: options.loadAssignTaskSessionDataMethod,
+			loadSessionDataMethod: options.loadSessionDataMethod, 
+			updateSessionReadMethod: options.updateSessionReadMethod,
+			getSessionMethod: options.getSessionMethod,
+			stickyTopSessionMethod: options.stickyTopSessionMethod,
+			muteNotificationSessionMethod: options.muteNotificationSessionMethod,
+			deleteSessionMethod: options.deleteSessionMethod,
+			starSessionMethod: options.starSessionMethod,
+			unstarSessionMethod: options.unstarSessionMethod,
+			onBeforeCreate: ({ options, instance }) => {
+				mergeSessionCommonOptions(options, instance)
+			}
+		})
+		this.sessionStar = new ClientChatSession({
+			groupField: 'wechatAccountId',
+			sortField: 'lastMsgTime',
+			name: 'sessionStar',
+			loadAssignTaskSessionDataMethod: options.loadAssignTaskSessionDataMethod,
+			loadSessionDataMethod: (params, context) => {
+				if (!options.loadStarSessionDataMethod) {
+					return Promise.resolve({
+						data: []
+					})
+				}
+				return options.loadStarSessionDataMethod(params, context)
+			}, 
+			updateSessionReadMethod: options.updateSessionReadMethod,
+			getSessionMethod: options.getSessionMethod,
+			stickyTopSessionMethod: options.stickyTopSessionMethod,
+			muteNotificationSessionMethod: options.muteNotificationSessionMethod,
+			deleteSessionMethod: options.deleteSessionMethod,
+			starSessionMethod: options.starSessionMethod,
+			unstarSessionMethod: options.unstarSessionMethod,
+			onBeforeCreate: ({ options, instance }) => {
+				mergeSessionCommonOptions(options, instance)
+			}
+		})
+		this.sessionUnread = new ClientChatSession({
+			groupField: 'wechatAccountId',
+			sortField: 'lastMsgTime',
+			name: 'sessionUnread',
+			loadAssignTaskSessionDataMethod: options.loadAssignTaskSessionDataMethod,
+			loadSessionDataMethod: (params, context) => {
+				if (!options.loadUnreadSessionDataMethod) {
+					return Promise.resolve({
+						data: []
+					})
+				}
+				return options.loadUnreadSessionDataMethod(params, context)
+			}, 
+			updateSessionReadMethod: options.updateSessionReadMethod,
+			getSessionMethod: options.getSessionMethod,
+			stickyTopSessionMethod: options.stickyTopSessionMethod,
+			muteNotificationSessionMethod: options.muteNotificationSessionMethod,
+			deleteSessionMethod: options.deleteSessionMethod,
+			starSessionMethod: options.starSessionMethod,
+			unstarSessionMethod: options.unstarSessionMethod,
+			onBeforeCreate: ({ options, instance }) => {
+				mergeSessionCommonOptions(options, instance)
+			}
+		})
+		this.sessionManage = new ClientChatSessionManage({
+			sessionInstanceList: [
+				this.session,
+				this.sessionFilter,
+				this.sessionStar,
+				this.sessionUnread
+			],
+			onCurrentSessionChange: (evt) => {
+				if (evt && evt.sessionId) {
+					// 获取所有会话实例集合
+					const sessionInstances = this.sessionManage.getSessionInstacesBySessionId(evt.sessionId)
+					// 标记会话已读
+					// 只给第一个设置就行了，后面会同步已读状态的
+					if (sessionInstances && sessionInstances.length) {
+						sessionInstances[0].setSessionRead(evt.sessionId)
+					}
+				}
+			}
+		})
+		this.friendMessage = new ClientChatMessage({
+			groupField: 'wechatFriendId',
+			sortField: 'wechatTime',
+			clientChat: this,
+			checkMessageSendResultMethod: options.checkMessageSendResultMethod,
+			loadLossMessageDataMethod: options.loadLossFriendMessageDataMethod,
+			onAddMessageSuccess: ({ data }) => {
+				const accountId = options.getLoginAccountIdMethod ? options.getLoginAccountIdMethod() : data.accountId
+				let sessionId = createSessionId(accountId, data.wechatFriendId)
+				// 更新会话
+				if (!sessionId) {
+					return
+				}
+				if (isAutoReadMessage(data)) {
+					return this.handleAutoReadMessageSession(sessionId)
+				}
+				// 如果消息包含这种情况，就不加入会话列表
+				if (shouldIgnoreSessionByMessage(data)) {
+					return
+				}
+				const localSession = this.session.findSession(({ session }) => session.conversationId === sessionId)
+				if (!localSession) {
+					this.socket.addLog({
+						group: 'client-chat-message:onAddMessageSuccess',
+						content: {
+							title: '未获取到会话，开始从服务端获取',
+							data: {
+								sessionId,
+								accountId,
+								wechatFriendId: data.wechatFriendId
+							}
+						}
+					})
+					return this.session.getSession(sessionId, rs => {
+						// https://vs.rpa.cn/zentao/bug-view-2411.html
+						// 如果后端返回的未读数量是0，那么前端先自己兼容一下，因为后端更新会话是异步过程，有可能这里获取到的会话信息还是老的，并不是这个消息更新之后的信息，得看后端会不会异步改成同步
+						if (rs && rs.data && !rs.data.unreadMsgCount) {
+							rs.data.unreadMsgCount = data.isSend ? 0 : 1
+							rs.data.lastMsgContent = data.content
+							rs.data.lastMsgType = data.msgType
+							rs.data.lastMsgTime = data.wechatTime
+							rs.data.lastMsgId = data.id
+							rs.data.lastUpdateTime = data.updateDate
+						}
+						return rs
+					}).then((rs) => {
+						// 更新账号未读消息数量
+						this.account.updateAccountUnreadMessageNum(rs.data.wechatAccountId, ({ unreadMesasgeNum, unreadMessageMuteNum }) => {
+							if (rs.data.mute) {
+								return {
+									num: (unreadMesasgeNum || 0) + (rs.data.unreadMsgCount || 0),
+									muteNum: (unreadMessageMuteNum || 0) + (rs.data.unreadMsgCount || 0)
+								}
+							} else {
+								return {
+									num: (unreadMesasgeNum || 0) + (rs.data.unreadMsgCount || 0),
+									muteNum: unreadMessageMuteNum
+								}
+							}
+						})
+					}, (error) => {
+						this.socket.addLog({
+							group: 'client-chat-message:onAddMessageSuccess',
+							content: {
+								title: '未获取到会话，从服务端获取失败',
+								data: {
+									error: error && (error.message || error.errMsg || error.toString && error.toString()) || error,
+									sessionId,
+									accountId,
+									wechatFriendId: data.wechatFriendId
+								}
+							}
+						})
+					})
+				} else {
+					this.session.updateSession(sessionId, ({ session }) => {
+						const nextSession = {
+							lastMsgContent: data.content,
+							lastMsgType: data.msgType,
+							lastMsgTime: data.wechatTime,
+							lastMsgId: data.id,
+							lastUpdateTime: data.updateDate,
+							unreadMsgCount: session.unreadMsgCount
+						}
+						if (!data.isSend) {
+							if (this.sessionManage.currentSession && this.sessionManage.currentSession.conversationId === sessionId) {
+								// 标记已读
+								this.session.setSessionRead(sessionId)
+							} else {
+								nextSession.unreadMsgCount = session.unreadMsgCount + 1
+								// 更新账号未读消息数量
+								this.account.updateAccountUnreadMessageNum(session.wechatAccountId, ({ unreadMesasgeNum, unreadMessageMuteNum }) => {
+									if (session.mute) {
+										return {
+											num: (unreadMesasgeNum || 0) + 1,
+											muteNum: (unreadMessageMuteNum || 0) + 1
+										}
+									} else {
+										return {
+											num: (unreadMesasgeNum || 0) + 1,
+											muteNum: unreadMessageMuteNum
+										}
+									}
+								})
+							}
+						}
+						return nextSession
+					})
+				}
+			},
+			queryMethod: (params) => {
+				return options.loadFriendMessageDataMethod(params)
+			}
+		})
+		this.friendMessageFilter = new ClientChatMessage({
+			groupField: 'wechatFriendId',
+			sortField: 'wechatTime',
+			clientChat: this,
+			checkMessageSendResultMethod: options.checkMessageSendResultMethod,
+			loadLossMessageDataMethod: options.loadLossFriendMessageDataMethod,
+			queryMethod: (params) => {
+				return options.loadFriendMessageDataMethod(params)
+			}
+		})
+		this.friendMessageContext = new ClientChatMessage({
+			groupField: 'wechatFriendId',
+			sortField: 'wechatTime',
+			clientChat: this,
+			checkMessageSendResultMethod: options.checkMessageSendResultMethod,
+			loadLossMessageDataMethod: options.loadLossFriendMessageDataMethod,
+			queryMethod: (params) => {
+				return options.loadFriendMessageDataMethod(params)
+			}
+		})
+		this.roomMessage = new ClientChatMessage({
+			groupField: 'wechatChatroomId',
+			sortField: 'wechatTime',
+			clientChat: this,
+			checkMessageSendResultMethod: options.checkMessageSendResultMethod,
+			loadLossMessageDataMethod: options.loadLossRoomMessageDataMethod,
+			onAddMessageSuccess: ({ data }) => {
+				const accountId = options.getLoginAccountIdMethod ? options.getLoginAccountIdMethod() : data.accountId
+				let sessionId = createSessionId(accountId, data.wechatChatroomId)
+				// 更新会话
+				if (!sessionId) {
+					return
+				}
+				if (isAutoReadMessage(data)) {
+					return this.handleAutoReadMessageSession(sessionId)
+				}
+				// 如果消息包含这种情况，就不加入会话列表
+				if (shouldIgnoreSessionByMessage(data)) {
+					return
+				}
+				// 更新会话未读消息数量
+				const localSession = this.session.findSession(({ session }) => session.conversationId === sessionId)
+				if (!localSession) {
+					this.socket.addLog({
+						group: 'client-chat-message:onAddMessageSuccess',
+						content: {
+							title: '未获取到会话，开始从服务端获取',
+							data: {
+								sessionId,
+								accountId,
+								wechatChatroomId: data.wechatChatroomId
+							}
+						}
+					})
+					this.session.getSession(sessionId, (rs) => {
+						// https://vs.rpa.cn/zentao/bug-view-2411.html
+						// 如果后端返回的未读数量是0，那么前端先自己兼容一下，因为后端更新会话是异步过程，有可能这里获取到的会话信息还是老的，并不是这个消息更新之后的信息，得看后端会不会异步改成同步
+						if (rs && rs.data && !rs.data.unreadMsgCount) {
+							rs.data.unreadMsgCount = data.isSend ? 0 : 1
+							rs.data.lastMsgContent = data.content
+							rs.data.lastMsgType = data.msgType
+							rs.data.lastMsgTime = data.wechatTime
+							rs.data.lastMsgId = data.id
+							rs.data.lastUpdateTime = data.updateDate
+						}
+						return rs
+					}).then((rs) => {
+						// 更新账号未读消息数量
+						this.account.updateAccountUnreadMessageNum(rs.data.wechatAccountId, ({ unreadMesasgeNum, unreadMessageMuteNum }) => {
+							if (rs.data.mute) {
+								return {
+									num: (unreadMesasgeNum || 0) + (rs.data.unreadMsgCount || 0),
+									muteNum: (unreadMessageMuteNum || 0) + (rs.data.unreadMsgCount || 0)
+								}
+							} else {
+								return {
+									num: (unreadMesasgeNum || 0) + (rs.data.unreadMsgCount || 0),
+									muteNum: unreadMessageMuteNum
+								}
+							}
+						})
+					}, (error) => {
+						this.socket.addLog({
+							group: 'client-chat-message:onAddMessageSuccess',
+							content: {
+								title: '未获取到会话，从服务端获取失败',
+								data: {
+									error: error && (error.message || error.errMsg || error.toString && error.toString()) || error,
+									sessionId,
+									accountId,
+									wechatChatroomId: data.wechatChatroomId
+								}
+							}
+						})
+					})
+				} else {
+					this.session.updateSession(sessionId, ({ session }) => {
+						const nextSession = {
+							lastMsgContent: data.content,
+							lastMsgType: data.msgType,
+							lastMsgTime: data.wechatTime,
+							lastMsgId: data.id,
+							lastUpdateTime: data.updateDate,
+							unreadMsgCount: session.unreadMsgCount
+						}
+						if (!data.isSend) {
+							if (this.sessionManage.currentSession && this.sessionManage.currentSession.conversationId === sessionId) {
+								// 标记已读
+								this.session.setSessionRead(sessionId)
+							} else {
+								nextSession.unreadMsgCount = session.unreadMsgCount + 1
+								// 更新账号未读消息数量
+								this.account.updateAccountUnreadMessageNum(session.wechatAccountId, ({ unreadMesasgeNum, unreadMessageMuteNum }) => {
+									if (session.mute) {
+										return {
+											num: (unreadMesasgeNum || 0) + 1,
+											muteNum: (unreadMessageMuteNum || 0) + 1
+										}
+									} else {
+										return {
+											num: (unreadMesasgeNum || 0) + 1,
+											muteNum: unreadMessageMuteNum
+										}
+									}
+								})
+							}
+						}
+						return nextSession
+					})
+				}
+			},
+			queryMethod: (params) => {
+				return options.loadRoomMessageDataMethod(params)
+			}
+		})
+		this.roomMessageFilter = new ClientChatMessage({
+			groupField: 'wechatChatroomId',
+			sortField: 'wechatTime',
+			clientChat: this,
+			checkMessageSendResultMethod: options.checkMessageSendResultMethod,
+			loadLossMessageDataMethod: options.loadLossRoomMessageDataMethod,
+			queryMethod: (params) => {
+				return options.loadRoomMessageDataMethod(params)
+			}
+		})
+		this.roomMessageContext = new ClientChatMessage({
+			groupField: 'wechatChatroomId',
+			sortField: 'wechatTime',
+			clientChat: this,
+			checkMessageSendResultMethod: options.checkMessageSendResultMethod,
+			loadLossMessageDataMethod: options.loadLossRoomMessageDataMethod,
+			queryMethod: (params) => {
+				return options.loadRoomMessageDataMethod(params)
+			}
+		})
+		this.contacts = new ClientChatContacts({
+			loadContactsRoomGroupDataMethod: options.loadContactsRoomGroupDataMethod,
+			loadContactsFriendGroupDataMethod: options.loadContactsFriendGroupDataMethod,
+			loadContactsFriendDataMethod: options.loadContactsFriendDataMethod,
+			loadContactsRoomDataMethod: options.loadContactsRoomDataMethod,
+			loadContactsRoomMemberDataMethod: options.loadContactsRoomMemberDataMethod,
+			getContactsFriendMethod: options.getContactsFriendMethod,
+			getContactsRoomMethod: options.getContactsRoomMethod,
+			getContactsFriendGroupCountMethod: options.getContactsFriendGroupCountMethod,
+			getContactsRoomGroupCountMethod: options.getContactsRoomGroupCountMethod,
+			onContactsRoomRemoved: ({ room }) => {
+				const accountId = options.getLoginAccountIdMethod ? options.getLoginAccountIdMethod() : room.accountId
+				let sessionId = createSessionId(accountId, room.id)
+				if (sessionId) {
+					this.session.removeSession(sessionId)
+				}
+			},
+			onLoadRoomGroupData: () => {
+				if (this.account.currentAccount) {
+					this.contacts.refreshAllRoomGroupCount({
+						wechatAccountId: this.account.currentAccount.id
+					})
+				}
+			},
+			onLoadFriendGroupData: () => {
+				if (this.account.currentAccount) {
+					this.contacts.refreshAllFriendGroupCount({
+						wechatAccountId: this.account.currentAccount.id
+					})
+				}
+			},
+			onUpdateFriend: ({ friend, updateProps, changeProps }) => {
+				this.contactsFilter.updateFriend(friend.id, updateProps)
+			},
+			onUpdateRoom: ({ room, updateProps }) => {
+				this.contactsFilter.updateRoom(room.id, updateProps)
+			}
+		})
+		this.contactsFilter = new ClientChatContacts({
+			loadContactsRoomGroupDataMethod: options.loadContactsRoomGroupDataMethod,
+			loadContactsFriendGroupDataMethod: options.loadContactsFriendGroupDataMethod,
+			loadContactsFriendDataMethod: options.loadContactsFriendDataMethod,
+			loadContactsRoomDataMethod: options.loadContactsRoomDataMethod,
+			loadContactsRoomMemberDataMethod: options.loadContactsRoomMemberDataMethod,
+			getContactsFriendMethod: options.getContactsFriendMethod,
+			getContactsRoomMethod: options.getContactsRoomMethod,
+			getContactsFriendGroupCountMethod: options.getContactsFriendGroupCountMethod,
+			getContactsRoomGroupCountMethod: options.getContactsRoomGroupCountMethod,
+			onUpdateFriend: ({ friend, updateProps }) => {
+				this.contacts.updateFriend(friend.id, updateProps)
+			},
+			onUpdateRoom: ({ room, updateProps }) => {
+				this.contacts.updateRoom(room.id, updateProps)
+			}
+		})
+		this.account = new ClientChatAccount({
+			loadAccountDataMethod: options.loadAccountDataMethod,
+			getAccountUnreadMessageNumMethod: options.getAccountUnreadMessageNumMethod,
+			updateAccountMessageReadMethod: options.updateAccountMessageReadMethod,
+			deleteAccountSessionMethod: options.deleteAccountSessionMethod,
+			getAccountGreetingUnreadMsgCountMethod: options.getAccountGreetingUnreadMsgCountMethod,
+			clearAccountGreetingUnreadMsgCountMethod: options.clearAccountGreetingUnreadMsgCountMethod,
+			onAccountAdded: ({ account }) => {
+				return this.account.refreshAccountUnreadMessageNum({
+					wechatAccountId: account.id
+				})
+			},
+			onAccountLoaded: () => {
+				this.socket.doHeartbeat()
+			},
+			onCurrentAccountChange: ({ currentAccount }) => {
+				// 如果群分组数据加载了再去刷成员数量，这样可以做到按需
+				if (this.contacts.friendGroupData && this.contacts.friendGroupData.length) {
+					this.contacts.refreshAllFriendGroupCount({
+						wechatAccountId: currentAccount ? currentAccount.id : null
+					})
+				}
+				if (this.contacts.roomGroupData && this.contacts.roomGroupData.length) {
+					this.contacts.refreshAllRoomGroupCount({
+						wechatAccountId: currentAccount ? currentAccount.id : null
+					})
+				}
+			},
+			onUnreadMessageNumChange: ({ accountId, unreadMessageNum }) => {
+				if (unreadMessageNum === 0) {
+					// 将账号下的所有已拉取的会话标记已读
+					this.session.setAccountSessionRead(accountId)
+				}
+			},
+			onDeleteAccountSession: ({ accountId }) => {
+				// 删除账号会话后，将所有账号的会话数据删除
+				this.session.clearAccountSession(accountId)
+			}
+		})
+		this.draft = new ClientChatDraft({
+			clientChat: this
+		})
+		this.socket = new ClientChatSocket({
+			socket: options.socket,
+			getLoginUserIdMethod: options.getLoginUserIdMethod,
+			getLoginUserTokenMethod: options.getLoginUserTokenMethod,
+			checkSocketEventNotifyMethod: options.checkSocketEventNotifyMethod,
+			beforeFireCallback: () => {
+				return this.connectPromise
+			},
+			onCmdMessageRecalled: ({ data }) => {
+				if (data.wechatFriendId) {
+					const friendMessage = this.friendMessage.findMessage(({ message }) => {
+						return message.msgId == data.msgId
+					})
+					if (!friendMessage) {
+						return
+					}
+					this.friendMessage.updateMessage(friendMessage.id, {
+						recalled: true
+					})
+				} else if (data.wechatChatroomId) {
+					const roomMessage = this.roomMessage.findMessage(({ message }) => {
+						return message.msgId == data.msgId
+					})
+					if (!roomMessage) {
+						return
+					}
+					this.roomMessage.updateMessage(roomMessage.id, {
+						recalled: true
+					})
+				}
+			},
+			// 接受新消息
+			onCmdNewMessage: ({ data }) => {
+				// 插入消息
+				if (data.friendMessage) {
+					this.friendMessage.addMessage(data.friendMessage)
+					this.friendMessage.setLastReceiveMessageTime(data.friendMessage.wechatTime)
+				} else if (data.chatroomMessage) {
+					this.roomMessage.addMessage(data.chatroomMessage)
+					this.roomMessage.setLastReceiveMessageTime(data.chatroomMessage.wechatTime)
+				}
+			},
+			// 发送消息结果，状态回刷
+			onCmdSendMessageResult: ({ data }) => {
+				const { cmdType, friendMessageId, chatroomMessageId, errMsg, seq, ...nextData } = data
+				if (friendMessageId) {
+					this.friendMessage.updateMessage(friendMessageId, Object.assign(nextData, {
+						resultMsg: errMsg
+					}))
+				} else {
+					this.roomMessage.updateMessage(chatroomMessageId, Object.assign(nextData, {
+						resultMsg: errMsg
+					}))
+				}
+			},
+			// 群聊有变化，如分配的情况
+			onCmdChatroomInfoChanged: ({ data }) => {
+				// 移除群聊
+				if (data.changeType === 3) {
+					this.contacts.removeRoom(data.wechatChatroomId)
+				} else {
+					// 其他情况就重新刷新一下群信息
+					if (this.sessionManage.currentSession && this.sessionManage.currentSession.targetId === data.wechatChatroomId) {
+						this.contacts.getRoom(data.wechatChatroomId, true) // 强制刷新群数据
+						this.contacts.loadRoomMemberData(data.wechatChatroomId, {  // 强制刷新群成员数据，因为有可能群主变化了
+							wechatChatroomId: data.wechatChatroomId
+						}, true)
+					}
+				}
+			},
+			onCmdChatroomMemberInfoChanged: ({ data }) => {
+				// 如果没有changeType的时候，目前看应该是群成员或者群信息变化了，需要重新刷新一下群成员和群信息
+				if (this.sessionManage.currentSession && this.sessionManage.currentSession.targetId === data.wechatChatroomId) {
+					this.contacts.loadRoomMemberData(data.wechatChatroomId, {  // 强制刷新群成员数据
+						wechatChatroomId: data.wechatChatroomId
+					}, true)
+				}
+			},
+			// 邀请成员
+			onCmdChatroomInvite: ({ data }) => {
+				// 如果没有changeType的时候，目前看应该是群成员或者群信息变化了，需要重新刷新一下群成员和群信息
+				if (this.sessionManage.currentSession && this.sessionManage.currentSession.targetId === data.wechatChatroomId) {
+					this.contacts.loadRoomMemberData(data.wechatChatroomId, {  // 强制刷新群成员数据
+						wechatChatroomId: data.wechatChatroomId
+					}, true)
+				}
+			},
+			// 群聊有变化，如分配的情况
+			onCmdChatroomInfoChangedBatch: ({ data }) => {
+				// 增量拉取通讯录
+				// this.contacts.refresh().then(() => {
+				// 	// 增量拉取会话
+				// 	this.session.refresh() 
+				// })
+			},
+			// 好友有变化，如分配的情况
+			onCmdFriendInfoChanged: ({ data }) => {
+				if (!this.socketFriendInfoChangedSerialQueue) {
+					this.socketFriendInfoChangedSerialQueue = createSerialQueue()
+				}
+				this.socketFriendInfoChangedSerialQueue.add(() => {
+					// 配分好友
+					if (data.changeType === 4) { 
+						if (this.onOverwriteFriendInfoChange) {
+							return this.onOverwriteFriendInfoChange({
+								data,
+								reverseLastUpdateTime: this.session.reverseLastUpdateTime,
+								accountIds: (this.account.accountData || []).map(v => v.id)
+							})
+						} else {
+							// 增量拉取分配产生的会话
+							return this.session.loadAssignTaskSessionData({
+								taskId: data.taskId
+							}).then((rs) => {
+								const wechatAccountIds = Object.keys((rs || []).reduce((rs, v) => {
+									rs[v.wechatAccountId] = true
+									return rs
+								}, {}))
+								if (!wechatAccountIds || !wechatAccountIds.length) {
+									return
+								}
+								// 统计任务返回的会话数据来按需刷新分组数量
+								// 更新当前微信号分组统计数量
+								return Promise.all([].concat(wechatAccountIds.reduce((rs, v) => {
+									rs.push(
+										this.contacts.refreshAllRoomGroupCount({
+											wechatAccountId: v
+										}, true)
+									)
+									rs.push(
+										this.contacts.refreshAllFriendGroupCount({
+											wechatAccountId: v
+										}, true)
+									)
+									return rs
+								}, [
+									// 刷新一下微信号
+									this.account.reloadData()
+								]))).then(() => {
+									this.contacts.markModify() // 标记通讯录修改
+								})
+							})
+						}
+					}
+					// 删除好友
+					else if (data.changeType === 3) {
+						// 删除会话
+						const session = this.session.findSession(({ session }) => {
+							return session.targetId === data.wechatFriendId
+						})
+						if (session) {
+							this.session.removeSession(session.conversationId)
+						}
+						// 删除好友
+						this.contacts.removeFriend(data.wechatFriendId)
+						// todo 刷新一下微信号，如果微信号一个好友都没了，应该要删除掉的
+						this.contacts.markModify() // 标记通讯录修改
+					} 
+					// 更新好友
+					else if (data.changeType === 2) {
+						this.contacts.getFriend(data.wechatFriendId, true).then(rs => {
+							this.contacts.updateFriend(data.wechatFriendId, rs.data)
+						})
+					}
+				})
+			},
+			// 群聊有变化，如分配的情况
+			onCmdChatroomInfoChanged: ({ data }) => {
+				// 配分群聊
+				if (data.changeType === 4) {
+					// 增量拉取通讯录
+					// this.contacts.refresh().then(() => {
+					// 	// 增量拉取会话
+					// 	this.session.refresh()
+					// })
+				}
+				// 删除群聊
+				else if (data.changeType === 3) {
+					// 删除会话
+					const session = this.session.findSession(({ session }) => {
+						return session.targetId === data.wechatChatroomId
+					})
+					if (session) {
+						this.session.removeSession(session.conversationId)
+					}
+					// 删除好友
+					this.contacts.removeRoom(data.wechatChatroomId)
+				} 
+				// 更新好友
+				else if (data.changeType === 2) {
+					this.contacts.getRoom({
+						wechatAccountId: data.wechatAccountId,
+						wechatChatroomId: data.wechatChatroomId
+					}).then(rs => {
+						this.contacts.updateRoom(data.wechatChatroomId, rs.data)
+					})
+				}
+			},
+			// 下载视频任务
+			onCmdDownloadVideoResult: ({ data }) => {
+				if (data.friendMessageId && data.friendMessageId !== '0') {
+					this.friendMessage.updateMessage(data.friendMessageId, {
+						content: data.url
+					})
+				} else if (data.chatroomMessageId && data.chatroomMessageId !== '0') {
+					this.roomMessage.updateMessage(data.chatroomMessageId, {
+						content: data.url
+					})
+				}
+			},
+			// 打招呼有变化
+			onCmdNewGreetingMsg: ({ data }) => {
+				// {
+				// 	"cmdType": "CmdNewGreetingMsg",
+				// 	"seq": 440013669,
+				// 	"traceId": "a54c7704960f1708ec332238c9fba7cc",
+				// 	"unreadGreetingMsgCount": 1,
+				// 	"wechatAccountId": "e8aade993e66748cbb845d127ea8e2e067465de7"
+				// }
+				this.account.setAccountGreetingUnreadMsgCount({
+					wechatAccountId: data.wechatAccountId,
+					unreadGreetingMsgCount: data.unreadGreetingMsgCount
+				})
+			},
+			onHeartbeatCheck: ({ mergeParams }) => {
+				const ids = this.account.getAccountData().map(v => v.id)
+				mergeParams({
+					wechatAccountIds: ids
+				})
+			},
+			onHeartbeatSuccess: ({ data }) => {
+				if (!data) { 
+					return
+				}
+				const onlineMap = data || {}
+				Object.keys(onlineMap).forEach(k => {
+					this.account.updateAccount(k, {
+						wechatAlive: onlineMap[k]
+					})
+				})
+			},
+			onSendMessage: ({ data, onCallback }) => {
+				// onCallback((res) => {
+				// 	// 如果发送转发的消息时，也需要检查并创建会话，和newMessage逻辑类似，先只管成功的情况
+				// 	if (data && data.cmdType === 'CmdForwardMessage') {
+				// 		if (res && res.data && res.data.data) {
+				// 			if (res.data.data.wechatFriendId) {
+				// 				// 插入消息
+				// 				this.friendMessage.addMessage(res.data.data)
+				// 			} else {
+				// 				this.roomMessage.addMessage(res.data.data)
+				// 			}
+				// 		}
+				// 	}
+				// })
+			},
+			onReceiveMessage: ({ data }) => {
+				
+			},
+			onSocketOpen: () => {
+				const ps = []
+				if (this.friendMessage.lastReceiveMessageTime) {
+					ps.push(this.friendMessage.loadLossMessageData())
+				}
+				if (this.roomMessage.lastReceiveMessageTime) {
+					ps.push(this.roomMessage.loadLossMessageData())
+				}
+				Promise.all(ps).finally(() => {
+					this.friendMessage.setLastReceiveMessageTime(Date.now())
+					this.roomMessage.setLastReceiveMessageTime(Date.now())
+				})
+			}, 
+			onSocketClose: (evt) => {
+			}, 
+			onSocketKickOut: () => {
+				// 关闭socket连接
+				// https://vs.rpa.cn/zentao/bug-view-2493.html
+				this.socket.close({
+					code: 1000,
+					reason: 'kickOut时主动关闭socket'
+				})
+				// 一般可能同一个账号在其他设备登录，这种情况需要重新登录
+				this.event.emit('kickout')
+			}
+		})
+	}
+	
+	connect () {
+		if (this.data.connectStatus === CONNECT_STATUS.Complete) {
+			return Promise.resolve()
+		}
+		if (this.data.connectStatus === CONNECT_STATUS.Loading) {
+			return this.connectPromise
+		}
+		this.data.connectStatus = CONNECT_STATUS.Loading
+		this.connectPromise = Promise.all([
+			this.socket.reconnect()
+		]).then(() => {
+			this.data.connectStatus = CONNECT_STATUS.Complete
+			this.event.emit('ready')
+		})
+		return this.connectPromise
+	}
+	
+	disconnect () {
+		this.data.connectStatus = CONNECT_STATUS.Normal
+		this.contacts.reset()
+		this.account.reset()
+		this.session.reset()
+		this.friendMessage.reset()
+		this.roomMessage.reset()
+		this.friendMessageFilter.reset()
+		this.roomMessageFilter.reset()
+		this.friendMessageContext.reset()
+		this.roomMessageContext.reset()
+		this.socket.disconnect()
+		this.socketFriendInfoChangedSerialQueue && this.socketFriendInfoChangedSerialQueue.clear()
+		this.event.off('ready')
+	}
+
+	handleAutoReadMessageSession (sessionId) {
+		if (!sessionId) {
+			return
+		}
+		const sessionInstances = this.sessionManage.getSessionInstacesBySessionId(sessionId)
+		const readPromise = Promise.resolve(this.session.updateSessionRead({
+			conversationId: sessionId
+		}))
+		return readPromise.finally(() => {
+			if (sessionInstances && sessionInstances.length) {
+				sessionInstances[0].markSessionRead(sessionId)
+				sessionInstances.forEach(sessionInstance => {
+					sessionInstance.removeSession(sessionId)
+				})
+			}
+			if (this.sessionManage.currentSession && this.sessionManage.currentSession.conversationId === sessionId) {
+				this.sessionManage.setCurrentSession(null)
+			}
+		})
+	}
+}
+
+export default ClientChat