@aochuang/client-sdk 1.0.377-wework → 1.0.378-wework

package/components/wework-chat-control/text/text-quote.vue

@@ -29,9 +29,10 @@ export default {
     type: {type: String, default: 'default'},
     formatter: {type: Function},
     getQuoteMessage: {type: Function},
+    fetchQuoteUserMethod: {type: Function},
     setChatBoxFootVnode: {type: Function}
   },
-  data () { return {loading: false, quoteMessageData: null, errorMsg: null} },
+  data () { return {loading: false, quoteMessageData: null, quoteUserData: null, errorMsg: null} },
   computed: {
     contentObject () {
       return parseQuoteContent(this.content)
@@ -45,7 +46,13 @@ export default {
     quoteText () { return this.quoteInfo.text || '引用消息' },
     quoteAuthor () {
       const message = this.quoteMessageData || {}
-      return this.quoteInfo.sendName || message.userName || message.contactName || message.roomName || this.quoteInfo.sendId || '引用消息'
+      if (this.quoteUserData && this.quoteUserData.name) {
+        return this.quoteUserData.name
+      }
+      if (!this.fetchQuoteUserMethod) {
+        return this.quoteInfo.sendName || message.userName || message.contactName || message.roomName || this.quoteInfo.sendId || '引用消息'
+      }
+      return this.quoteInfo.sendId || message.sendId || message.createBy || '引用消息'
     },
     quoteControl () {
       return chatControls[this.quoteMessageData && this.quoteMessageData.msgType] || TextDefault
@@ -87,12 +94,38 @@ export default {
       content: this.quoteInfo
     }).then(data => {
       this.quoteMessageData = data && data.data ? data.data : data
-      if (!this.quoteMessageData) this.errorMsg = '未找到引用消息内容，请在手机中确认'
-      if (this.setChatBoxFootVnode) this.setChatBoxFootVnode(this.quoteFootComponent)
+      if (!this.quoteMessageData) {
+        this.errorMsg = '未找到引用消息内容，请在手机中确认'
+        return
+      }
+      return this.fetchQuoteUserData()
     }).catch(() => {
       this.errorMsg = '未找到引用消息内容，请在手机中确认'
-      if (this.setChatBoxFootVnode) this.setChatBoxFootVnode(this.quoteFootComponent)
-    }).finally(() => { this.loading = false })
+    }).finally(() => {
+      this.loading = false
+      this.refreshQuoteFoot()
+    })
+  },
+  methods: {
+    refreshQuoteFoot () {
+      if (this.setChatBoxFootVnode) {
+        this.setChatBoxFootVnode(this.quoteFootComponent)
+      }
+    },
+    fetchQuoteUserData () {
+      if (!this.fetchQuoteUserMethod || !this.quoteMessageData) {
+        return Promise.resolve()
+      }
+      return Promise.resolve(this.fetchQuoteUserMethod({
+        data: this.quoteMessageData
+      })).then(data => {
+        this.quoteUserData = data || null
+      }).catch(() => {
+        this.quoteUserData = null
+      }).finally(() => {
+        this.refreshQuoteFoot()
+      })
+    }
   }
 }
 </script>

package/components/wework-chat-control/text/text.vue

@@ -23,6 +23,7 @@ export default {
     type: {type: String, default: 'default'},
     formatter: {type: Function},
     getQuoteMessage: {type: Function},
+    fetchQuoteUserMethod: {type: Function},
     setChatBoxFootVnode: {type: Function}
   },
   computed: {
@@ -30,7 +31,10 @@ export default {
     defaultComponent () { return TextDefault },
     quoteComponent () { return TextQuote },
     componentProps () {
-      return Object.assign({}, this.$attrs, this.$props, {getQuoteMessage: this.getQuoteMessage})
+      return Object.assign({}, this.$attrs, this.$props, {
+        getQuoteMessage: this.getQuoteMessage,
+        fetchQuoteUserMethod: this.fetchQuoteUserMethod
+      })
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aochuang/client-sdk",
-  "version": "1.0.377-wework",
+  "version": "1.0.378-wework",
   "description": "",
   "files": [
     "common",

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

@@ -146,6 +146,21 @@ export default class ClientChatMessage {
 			}
 		}
 		if (fireEvent !== false) {
+			// 先执行onAddMessageSuccess再发add-message事件，保证会话的getSession轮询先由这里发起、更新会话的回调排在最前面，
+			// 外部监听add-message后再调getSession只是复用同一个轮询
+			// try/catch是为了避免回调里的异常把add-message事件吞掉（外部的新消息提醒、本地消息缓存都依赖这个事件）
+			try {
+				this.onAddMessageSuccess && this.onAddMessageSuccess({
+					data,
+					lastMessageTime,
+					isBeforeLastMessage
+				})
+			} catch (error) {
+				console.error('[client-chat-message] onAddMessageSuccess error', {
+					messageId: data.id,
+					error
+				})
+			}
 			// 如果消息包含这种情况，就不能往外发送add-message事件
 			// 因为例如群发的消息，他没有会话，导致前端在处理来了新消息通知铃声提醒，获取会话一直获取不到，然后会总是发送请求
 			if (!isBeforeLastMessage && !isAutoReadMessage(data) && !shouldIgnoreSessionByMessage(data) && !isDeletedMsg(data) && !isBlockedMsg(data)) {
@@ -153,11 +168,6 @@ export default class ClientChatMessage {
 					data
 				})	
 			}
-			this.onAddMessageSuccess && this.onAddMessageSuccess({
-				data,
-				lastMessageTime,
-				isBeforeLastMessage
-			})
 		}
 	}
 

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

@@ -242,37 +242,19 @@ export default class ClientChatSession {
 		}
 	}
 
-	_addGetSessionSerializeTask (pollRequest, serializeMethod, taskOptions = {}) {
-		if (!serializeMethod) {
-			return false
-		}
-		const messageId = taskOptions.messageId
-		if (messageId && pollRequest.serializeTaskMap[messageId]) {
-			return false
-		}
-		const task = {
-			messageId,
-			wechatTime: taskOptions.wechatTime || 0,
-			index: pollRequest.serializeTasks.length,
-			serializeMethod
-		}
-		pollRequest.serializeTasks.push(task)
-		if (messageId) {
-			pollRequest.serializeTaskMap[messageId] = task
-		}
-		return true
-	}
-
-	getSession (sessionId, serializeMethod, taskOptions = {}) {
+	getSession (sessionId, serializeMethod) {
 		if (this.sessionMap[sessionId]) {  
 			return Promise.resolve({
 				data: this.sessionMap[sessionId]
 			})
 		}
 		// 这里需要轮询从后端获取会话，后端会话更新和创建是异步的，所以要多轮训请求几次
+		// 同一个会话只会有一个轮询，轮询期间再次调用只把serializeMethod挂到这个轮询上，等结果回来后依次执行
 		let pollRequest = this.pollRequestMap[sessionId]
 		if (pollRequest && pollRequest.ps) {
-			this._addGetSessionSerializeTask(pollRequest, serializeMethod, taskOptions)
+			if (serializeMethod) {
+				pollRequest.serializeMethods.push(serializeMethod)
+			}
 			return pollRequest.ps
 		}
 
@@ -292,50 +274,33 @@ export default class ClientChatSession {
 				return Promise.reject(error)
 			})
 		})
-		pollRequest.serializeTasks = []
-		pollRequest.serializeTaskMap = {}
+		pollRequest.serializeMethods = serializeMethod ? [serializeMethod] : []
 		pollRequest.requestCount = 0
 		pollRequest.emptyResponseCount = 0
 		pollRequest.requestErrorCount = 0
 		pollRequest.lastRequestError = null
 		pollRequest.startedAt = Date.now()
-		this._addGetSessionSerializeTask(pollRequest, serializeMethod, taskOptions)
 		this.pollRequestMap[sessionId] = pollRequest
 		this._addGetSessionLog('创建会话轮询', {
-			sessionId,
-			messageId: taskOptions.messageId,
-			wechatTime: taskOptions.wechatTime,
-			taskCount: pollRequest.serializeTasks.length
+			sessionId
 		})
 		pollRequest.ps = pollRequest.start().then(rs => {
 			if (!rs.data) {
 				return Promise.reject('未找到会话' + sessionId)
 			}
 			/**
-			 * 轮询合并上下文，会依次传给每个 serializeMethod（见 client-chat.js onCmdNewMessage 里 getSession 的回调）
+			 * 轮询合并上下文，会依次传给每个 serializeMethod（见 client-chat.js onAddMessageSuccess 里 getSession 的回调）
 			 * baseLastMsgTime     服务端返回的会话 lastMsgTime，用来判断某条消息服务端是否已经算进 unreadMsgCount
-			 * processedMessageIds 本次轮询期间处理过的所有消息 id
-			 * skippedMessageIds   服务端返回的会话已经包含（wechatTime <= baseLastMsgTime）、本地不再给会话未读 +1 的消息 id
-			 * unreadMessageIds    本地给会话未读 +1 的消息 id
 			 * accountUnreadDelta  本次轮询期间需要累加到工作微信号（账号）未读数量上的条数。
-			 *                     注意它和 unreadMessageIds.length 不同：账号未读初始值是登录时取的，不包含本次收到的任何消息，
-			 *                     所以被 skip 的消息也要算进来；只有"正在看当前会话被直接标记已读"的消息不算
+			 *                     账号未读初始值是登录时取的，不包含本次收到的任何消息，所以服务端已经算进会话 unreadMsgCount 的消息也要算进来；
+			 *                     只有"正在看当前会话被直接标记已读"的消息不算
 			 */
 			const context = {
 				baseLastMsgTime: rs.data.lastMsgTime || 0,
-				processedMessageIds: [],
-				skippedMessageIds: [],
-				unreadMessageIds: [],
 				accountUnreadDelta: 0
 			}
-			const serializeTasks = pollRequest.serializeTasks.slice().sort((a, b) => {
-				return a.wechatTime - b.wechatTime || a.index - b.index
-			})
-			serializeTasks.forEach(task => {
-				rs = task.serializeMethod(rs, context) || rs
-				if (task.messageId) {
-					context.processedMessageIds.push(task.messageId)
-				}
+			pollRequest.serializeMethods.forEach(method => {
+				rs = method(rs, context) || rs
 			})
 			// wechatAccountId 传 null 表示非分页来源，onAddSession 会把未读同步到账号；
 			// 同时带上 unreadDelta，让账号只累加本次新增的条数，而不是服务端返回的整个 unreadMsgCount（那里面的存量部分账号初始值已经包含了）
@@ -353,9 +318,7 @@ export default class ClientChatSession {
 				lastMsgTime: rs.data.lastMsgTime,
 				lastMsgId: rs.data.lastMsgId,
 				unreadMsgCount: rs.data.unreadMsgCount,
-				processedMessageCount: context.processedMessageIds.length,
-				skippedMessageCount: context.skippedMessageIds.length,
-				unreadMessageCount: context.unreadMessageIds.length,
+				mergedCount: pollRequest.serializeMethods.length,
 				accountUnreadDelta: context.accountUnreadDelta,
 				hasSessionMap: !!this.sessionMap[sessionId],
 				hasAllSessionGroup: !!this._getSessionBySessionGroup(sessionId, ALL_WECHAT_ACCOUNT_ID),

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

@@ -437,22 +437,6 @@ class ClientChat {
 				}
 				const localSession = this.session.findSession(({ session }) => session.conversationId === sessionId)
 				if (!localSession) {
-					if (!this.session.pollRequestMap[sessionId]) {
-						this.socket.addLog({
-							group: 'client-chat-message:onAddMessageSuccess',
-							content: {
-								title: '未获取到会话，开始从服务端获取',
-								data: {
-									sessionId,
-									accountId,
-									wechatFriendId: data.wechatFriendId,
-									wechatAccountId: data.wechatAccountId,
-									messageId: data.id,
-									wechatTime: data.wechatTime
-								}
-							}
-						})
-					}
 					return this.session.getSession(sessionId, (rs, context) => {
 						if (rs && rs.data) {
 							const isAfterServerMessage = data.wechatTime > context.baseLastMsgTime
@@ -467,19 +451,16 @@ class ClientChat {
 							// 正在看这个会话并且允许自动标记已读
 							const isCurrentSessionRead = this.sessionManage.currentSession && this.sessionManage.currentSession.conversationId === sessionId && this.shouldMarkCurrentSessionRead(sessionId, data)
 							// 会话未读数量：isAfterServerMessage 为 true 表示这条消息比服务端返回的会话 lastMsgTime 新，
-							// 服务端返回的 unreadMsgCount 还没算它，需要本地 +1；否则服务端已经算进去了，skip 掉避免重复
+							// 服务端返回的 unreadMsgCount 还没算它，需要本地 +1；否则服务端已经算进去了，不再重复 +1
 							if (!data.isSend && isAfterServerMessage) {
 								if (isCurrentSessionRead) {
 									rs.data.unreadMsgCount = 0
 								} else {
 									rs.data.unreadMsgCount = (rs.data.unreadMsgCount || 0) + 1
-									context.unreadMessageIds.push(data.id)
 								}
-							} else {
-								context.skippedMessageIds.push(data.id)
 							}
 							// 账号未读数量：和会话未读数量的判断口径不一样。
-							// 账号未读初始值是登录时从服务端取的，不包含这条新消息，所以不管这条消息有没有被服务端算进会话的 unreadMsgCount（即不管是否被 skip），
+							// 账号未读初始值是登录时从服务端取的，不包含这条新消息，所以不管这条消息有没有被服务端算进会话的 unreadMsgCount，
 							// 账号都要 +1。唯一不加的情况是"正在看当前会话并被直接标记已读"（此时会话未读被置 0，不会再通过 onSessionReadChange 扣减账号）。
 							// 这个累计值会通过 addSession(rs.data, null, { unreadDelta }) 传给 onAddSession，账号只累加这个增量而不是整个 unreadMsgCount
 							if (!data.isSend && !(isAfterServerMessage && isCurrentSessionRead)) {
@@ -487,9 +468,6 @@ class ClientChat {
 							}
 						}
 						return rs
-					}, {
-						messageId: data.id,
-						wechatTime: data.wechatTime
 					}).catch(() => {})
 					} else {
 						this.session.updateSession(sessionId, ({ session }) => {
@@ -584,22 +562,6 @@ class ClientChat {
 				// 更新会话未读消息数量
 				const localSession = this.session.findSession(({ session }) => session.conversationId === sessionId)
 				if (!localSession) {
-					if (!this.session.pollRequestMap[sessionId]) {
-						this.socket.addLog({
-							group: 'client-chat-message:onAddMessageSuccess',
-							content: {
-								title: '未获取到会话，开始从服务端获取',
-								data: {
-									sessionId,
-									accountId,
-									wechatChatroomId: data.wechatChatroomId,
-									wechatAccountId: data.wechatAccountId,
-									messageId: data.id,
-									wechatTime: data.wechatTime
-								}
-							}
-						})
-					}
 					return this.session.getSession(sessionId, (rs, context) => {
 						if (rs && rs.data) {
 							const isAfterServerMessage = data.wechatTime > context.baseLastMsgTime
@@ -614,22 +576,19 @@ class ClientChat {
 							// 正在看这个会话并且允许自动标记已读
 							const isCurrentSessionRead = this.sessionManage.currentSession && this.sessionManage.currentSession.conversationId === sessionId && this.shouldMarkCurrentSessionRead(sessionId, data)
 							// 会话未读数量：isAfterServerMessage 为 true 表示这条消息比服务端返回的会话 lastMsgTime 新，
-							// 服务端返回的 unreadMsgCount 还没算它，需要本地 +1；否则服务端已经算进去了，skip 掉避免重复
+							// 服务端返回的 unreadMsgCount 还没算它，需要本地 +1；否则服务端已经算进去了，不再重复 +1
 							if (!data.isSend && isAfterServerMessage) {
 								if (isCurrentSessionRead) {
 									rs.data.unreadMsgCount = 0
 								} else {
 									rs.data.unreadMsgCount = (rs.data.unreadMsgCount || 0) + 1
-									context.unreadMessageIds.push(data.id)
 									if (atMessage) {
 										rs.data.lastAtMsgContent = appendLastAtMsgContent(rs.data.lastAtMsgContent, atMessage)
 									}
 								}
-							} else {
-								context.skippedMessageIds.push(data.id)
 							}
 							// 账号未读数量：和会话未读数量的判断口径不一样。
-							// 账号未读初始值是登录时从服务端取的，不包含这条新消息，所以不管这条消息有没有被服务端算进会话的 unreadMsgCount（即不管是否被 skip），
+							// 账号未读初始值是登录时从服务端取的，不包含这条新消息，所以不管这条消息有没有被服务端算进会话的 unreadMsgCount，
 							// 账号都要 +1。唯一不加的情况是"正在看当前会话并被直接标记已读"（此时会话未读被置 0，不会再通过 onSessionReadChange 扣减账号）。
 							// 这个累计值会通过 addSession(rs.data, null, { unreadDelta }) 传给 onAddSession，账号只累加这个增量而不是整个 unreadMsgCount
 							if (!data.isSend && !(isAfterServerMessage && isCurrentSessionRead)) {
@@ -637,9 +596,6 @@ class ClientChat {
 							}
 						}
 						return rs
-					}, {
-						messageId: data.id,
-						wechatTime: data.wechatTime
 					}).catch(() => {})
 					} else {
 						this.session.updateSession(sessionId, ({ session }) => {

package/services/client-chat/client-chat-wechat/docs//350/264/246/345/217/267/346/234/252/350/257/273/346/225/260/351/207/217/344/270/216/344/274/232/350/257/235/346/234/252/350/257/273/346/225/260/351/207/217/344/270/215/344/270/200/350/207/264/351/227/256/351/242/230/344/277/256/345/244/215.md

@@ -84,13 +84,15 @@ SDK 里维护着两套彼此独立的本地"账本"：
   ```js
   // 会话未读：只在服务端没算过这条消息时 +1（原逻辑不变）
   if (!data.isSend && isAfterServerMessage) { ... }
-  // 账号未读：不管是否被 skip 都 +1，只有"正在看当前会话被直接标记已读"不加
+  // 账号未读：不管服务端是否已经算进会话 unreadMsgCount 都 +1，只有"正在看当前会话被直接标记已读"不加
   if (!data.isSend && !(isAfterServerMessage && isCurrentSessionRead)) {
       context.accountUnreadDelta += 1
   }
   ```
 
-  注意 `accountUnreadDelta` **不等于** `unreadMessageIds.length`：被 skip 的消息表示服务端返回的会话已经把它算进 `unreadMsgCount`，但账号初始值是登录时取的，仍然不含这条，所以账号还是要 +1。
+  注意 `accountUnreadDelta` **不等于** 本次给会话 `unreadMsgCount` +1 的条数：`isAfterServerMessage` 为 false 的消息表示服务端返回的会话已经把它算进 `unreadMsgCount`，但账号初始值是登录时取的，仍然不含这条，所以账号还是要 +1。
+
+  `getSession(sessionId, serializeMethod)` 只按 `sessionId` 聚合：同一个会话轮询期间的所有回调按调用顺序依次执行，不再依赖消息 id / 时间做去重或排序（消息层 `addMessage` 已按 id 去重）。
 
 - `onAddSession`（第 132 行附近）：
 

package/services/client-chat/client-chat-wework/client-chat-message.js

@@ -21,8 +21,9 @@ export default class ClientChatMessage {
 		*/
 		messageData: {}
 	})
-	
+
 	messageMap = {}
+	lastMessageTimeMap = {}
 	tempMessageMap = {}
 	checkMessageSendResultTaskList = []
 	
@@ -100,6 +101,8 @@ export default class ClientChatMessage {
 			delete this.tempMessageMap[data.id]
 		}
 		const groupField = data[this.groupField]
+		const lastMessageTime = this.getLastMessageTime(groupField)
+		const isBeforeLastMessage = !data.isSend && lastMessageTime && data[this.sortField] < lastMessageTime
 		if (!this.data.messageData[groupField]) {
 			Vue.set(this.data.messageData, groupField, {})
 		}
@@ -115,14 +118,27 @@ export default class ClientChatMessage {
 		}
 		this.data.messageData[groupField][sortFields.day][sortFields.milliseconds].push(data)
 		this.messageMap[data.id] = data
+		this.setLastMessageTime(groupField, data[this.sortField], data)
 		if (data.isSend && data.status === 1 && !data._temp) this.addCheckMessageSendResultTask(data)
 		if (fireEvent !== false) {
+			try {
+				this.onAddMessageSuccess && this.onAddMessageSuccess({
+					data,
+					lastMessageTime,
+					isBeforeLastMessage
+				})
+			} catch (error) {
+				console.error('[client-chat-message] onAddMessageSuccess error', {
+					messageId: data.id,
+					error
+				})
+			}
+			if (isBeforeLastMessage) {
+				return
+			}
 			this.event && this.event.emit('add-message', {
 				data
 			})
-			this.onAddMessageSuccess && this.onAddMessageSuccess({
-				data
-			})
 		}
 	}
 	
@@ -159,7 +175,7 @@ export default class ClientChatMessage {
 			delete this.data.messageData[groupField]
 		}
 		this.event && this.event.emit('remove-message', {
-			data
+			data: message
 		})
 	}
 	
@@ -172,9 +188,44 @@ export default class ClientChatMessage {
 		if (!props) {
 			return
 		}
+		const groupField = message[this.groupField]
+		const oldSortFieldValue = message[this.sortField]
+		const oldSortFields = this.getSortField(oldSortFieldValue)
 		Object.keys(props).forEach(key => {
-			message[key] = props[key]
+			Vue.set(message, key, props[key])
 		})
+		if (typeof props[this.sortField] !== 'undefined' && props[this.sortField] !== oldSortFieldValue) {
+			const oldBucket = this.data.messageData[groupField] &&
+				this.data.messageData[groupField][oldSortFields.day] &&
+				this.data.messageData[groupField][oldSortFields.day][oldSortFields.milliseconds]
+			if (oldBucket) {
+				const index = oldBucket.findIndex(item => item.id === message.id)
+				if (index >= 0) {
+					oldBucket.splice(index, 1)
+				}
+				if (!oldBucket.length) {
+					Vue.delete(this.data.messageData[groupField][oldSortFields.day], oldSortFields.milliseconds)
+				}
+				if (!Object.keys(this.data.messageData[groupField][oldSortFields.day]).length) {
+					Vue.delete(this.data.messageData[groupField], oldSortFields.day)
+				}
+			}
+			const newSortFields = this.getSortField(message[this.sortField])
+			if (!this.data.messageData[groupField]) {
+				Vue.set(this.data.messageData, groupField, {})
+			}
+			if (!this.data.messageData[groupField][newSortFields.day]) {
+				Vue.set(this.data.messageData[groupField], newSortFields.day, {})
+			}
+			if (!this.data.messageData[groupField][newSortFields.day][newSortFields.milliseconds]) {
+				Vue.set(this.data.messageData[groupField][newSortFields.day], newSortFields.milliseconds, [])
+			}
+			const newBucket = this.data.messageData[groupField][newSortFields.day][newSortFields.milliseconds]
+			if (!newBucket.some(item => item.id === message.id)) {
+				newBucket.push(message)
+			}
+			this.setLastMessageTime(groupField, message[this.sortField], message)
+		}
 	}
 	
 	getMessage (id) {
@@ -315,6 +366,25 @@ export default class ClientChatMessage {
 		this.checkMessageSendResultTaskList.forEach(task => task.cancel())
 		this.checkMessageSendResultTaskList = []
 		this.tempMessageMap = {}
+		this.messageMap = {}
+		this.lastMessageTimeMap = {}
 		this.data.messageData = {}
 	}
+
+	getLastMessageTime (groupField) {
+		return this.lastMessageTimeMap[groupField]
+	}
+
+	setLastMessageTime (groupField, messageTime, message) {
+		if (!groupField || !messageTime || (message && message.msgType === '_EMPTY_')) {
+			return
+		}
+		if (message && message._temp) {
+			return
+		}
+		const lastMessageTime = this.getLastMessageTime(groupField)
+		if (!lastMessageTime || messageTime > lastMessageTime) {
+			this.lastMessageTimeMap[groupField] = messageTime
+		}
+	}
 }

package/services/client-chat/client-chat-wework/client-chat-session.js

@@ -1,5 +1,5 @@
 import Vue from 'vue'
-import { isEmptyObject } from '../../../utils/util.js'
+import { createPollRequest, isEmptyObject } from '../../../utils/util.js'
 
 const loopLoadAssignSessionData = (fetchFn, params) => {
 	let lastPs = null
@@ -87,6 +87,8 @@ export default class ClientChatSession {
 	})
 	
 	accountIds = []
+
+	pollRequestMap = {}
 	
 	sessionMap = {}
 	
@@ -146,6 +148,7 @@ export default class ClientChatSession {
 			groupField: null,
 			sortField: null,
 			onBeforeAddSession: null,
+			onAddSession: null,
 			loadSessionDataMethod: null, 
 			loadAssignTaskSessionDataMethod: null,
 			stickyTopSessionMethod: null,
@@ -170,6 +173,7 @@ export default class ClientChatSession {
 			throw new Error('缺少getSessionMethod配置')
 		}
 		this.onBeforeAddSession = options.onBeforeAddSession
+		this.onAddSession = options.onAddSession
 		this.loadSessionData = options.loadSessionDataMethod
 		this.updateSessionRead = options.updateSessionReadMethod
 		this.getSessionMethod = options.getSessionMethod
@@ -187,6 +191,8 @@ export default class ClientChatSession {
 			this.sessionMap = {}
 			this.data.sessionData = {}
 			this.data.sessionGroupData = {}
+			this._lastUpdateSessionMap = {}
+			this._reverseLastUpdateSessionMap = {}
 			// this.data.sessionUnreadCountMap = {}
 			this.data.sessionMuteMap = {}
 		}
@@ -202,22 +208,62 @@ export default class ClientChatSession {
 		this.checkAndUpdateLastUpdateSession()
 	}
 	
-	getSession (sessionId) {
+	getSession (sessionId, serializeMethod) {
 		if (this.sessionMap[sessionId]) {
 			return Promise.resolve({
 				data: this.sessionMap[sessionId]
 			})
 		}
-		return this.getSessionMethod({
-			id: sessionId
-		}).then(rs => {
-			if (rs.data) {
-				this.addSession(rs.data)
-				return rs
-			} else {
+		let pollRequest = this.pollRequestMap[sessionId]
+		if (pollRequest && pollRequest.promise) {
+			if (serializeMethod) {
+				pollRequest.serializeMethods.push(serializeMethod)
+			}
+			return pollRequest.promise
+		}
+		pollRequest = createPollRequest(({ done }) => {
+			return this.getSessionMethod({
+				id: sessionId
+			}).then(rs => {
+				if (rs && rs.data) {
+					done(Object.assign({}, rs, {
+						data: Object.assign({}, rs.data, {
+							id: sessionId
+						})
+					}))
+				}
+			})
+		})
+		pollRequest.serializeMethods = serializeMethod ? [serializeMethod] : []
+		this.pollRequestMap[sessionId] = pollRequest
+		pollRequest.promise = pollRequest.start().then(rs => {
+			if (!rs || !rs.data) {
 				return Promise.reject('未找到会话' + sessionId)
 			}
+			const context = {
+				baseLastMsgTime: rs.data.lastMsgTime || 0,
+				accountUnreadDelta: 0
+			}
+			pollRequest.serializeMethods.forEach(method => {
+				rs = method(rs, context) || rs
+			})
+			this.addSession(rs.data, {
+				unreadDelta: context.accountUnreadDelta
+			})
+			return rs
+		}).finally(() => {
+			if (this.pollRequestMap[sessionId] === pollRequest) {
+				delete this.pollRequestMap[sessionId]
+			}
+		})
+		return pollRequest.promise
+	}
+
+	stopGetSessionPollRequests () {
+		Object.keys(this.pollRequestMap).forEach(sessionId => {
+			this.pollRequestMap[sessionId].stop()
 		})
+		this.pollRequestMap = {}
 	}
 	
 	getSessionByLocal (sessionId) {
@@ -275,7 +321,98 @@ export default class ClientChatSession {
 			milliseconds: Math.abs(milliseconds - 86400000) // 排序，由大到小
 		}
 	}
-	
+
+	_removeSessionFromBuckets (buckets, sessionId) {
+		if (!buckets) {
+			return
+		}
+		Object.keys(buckets).forEach(topField => {
+			const dayBuckets = buckets[topField]
+			Object.keys(dayBuckets || {}).forEach(day => {
+				const timeBuckets = dayBuckets[day]
+				Object.keys(timeBuckets || {}).forEach(milliseconds => {
+					const items = timeBuckets[milliseconds]
+					if (!Array.isArray(items)) {
+						return
+					}
+					for (let index = items.length - 1; index >= 0; index -= 1) {
+						if (items[index] && items[index].id === sessionId) {
+							items.splice(index, 1)
+						}
+					}
+					if (!items.length) {
+						Vue.delete(timeBuckets, milliseconds)
+					}
+				})
+				if (isEmptyObject(timeBuckets)) {
+					Vue.delete(dayBuckets, day)
+				}
+			})
+			if (isEmptyObject(dayBuckets)) {
+				Vue.delete(buckets, topField)
+			}
+		})
+	}
+
+	_removeSessionFromDisplayData (sessionId) {
+		this._removeSessionFromBuckets(this.data.sessionData, sessionId)
+		Object.keys(this.data.sessionGroupData).forEach(groupField => {
+			this._removeSessionFromBuckets(this.data.sessionGroupData[groupField], sessionId)
+			if (isEmptyObject(this.data.sessionGroupData[groupField])) {
+				Vue.delete(this.data.sessionGroupData, groupField)
+			}
+		})
+	}
+
+	_removeSessionFromTimeMap (timeMap, sessionId) {
+		Object.keys(timeMap || {}).forEach(day => {
+			Object.keys(timeMap[day] || {}).forEach(milliseconds => {
+				const items = timeMap[day][milliseconds]
+				if (!Array.isArray(items)) {
+					return
+				}
+				for (let index = items.length - 1; index >= 0; index -= 1) {
+					if (items[index] && items[index].id === sessionId) {
+						items.splice(index, 1)
+					}
+				}
+				if (!items.length) {
+					delete timeMap[day][milliseconds]
+				}
+			})
+			if (isEmptyObject(timeMap[day])) {
+				delete timeMap[day]
+			}
+		})
+	}
+
+	_insertSessionIntoBuckets (buckets, session, topField, sortFields) {
+		if (!buckets[topField]) {
+			Vue.set(buckets, topField, {})
+		}
+		if (!buckets[topField][sortFields.day]) {
+			Vue.set(buckets[topField], sortFields.day, {})
+		}
+		if (!buckets[topField][sortFields.day][sortFields.milliseconds]) {
+			Vue.set(buckets[topField][sortFields.day], sortFields.milliseconds, [])
+		}
+		const items = buckets[topField][sortFields.day][sortFields.milliseconds]
+		if (!items.some(item => item.id === session.id)) {
+			items.push(session)
+		}
+	}
+
+	_insertSessionIntoDisplayData (session) {
+		const topField = session.stickyOnTop ? 0 : 1
+		const sortFields = this.getSortField(session[this.sortField])
+		this._insertSessionIntoBuckets(this.data.sessionData, session, topField, sortFields)
+		const groupField = session[this.groupField] || 'unkonw'
+		if (!this.data.sessionGroupData[groupField]) {
+			Vue.set(this.data.sessionGroupData, groupField, {})
+		}
+		this._insertSessionIntoBuckets(this.data.sessionGroupData[groupField], session, topField, sortFields)
+	}
+
 	/**
 	 * {
      *		"id": "3d5398c24f1ae633047202fe17276571ef5e537e",
@@ -292,7 +429,7 @@ export default class ClientChatSession {
 	 *		"wechatAccountId": "2a39a725814acf07502299ab2285fff8d44377f5"
 	 *	}
 	*/
-	addSession (data) {
+	addSession (data, options = {}) {
 		if (!data || !data.id) {
 			throw new Error('缺少必须参数id')
 		}
@@ -301,22 +438,20 @@ export default class ClientChatSession {
 		}) === false) {
 			return
 		}
-		if (this.sessionMap[data.id]) {
-			return
-		}
-		const topField = data.stickyOnTop ? 0 : 1 // 置顶
-		if (!this.data.sessionData[topField]) {
-			Vue.set(this.data.sessionData, topField, {})
-		}
-		// 所有的
-		const sortFields = this.getSortField(data[this.sortField])
-		if (!this.data.sessionData[topField][sortFields.day]) {
-			Vue.set(this.data.sessionData[topField], sortFields.day, {})
-		}
-		if (!this.data.sessionData[topField][sortFields.day][sortFields.milliseconds]) {
-			Vue.set(this.data.sessionData[topField][sortFields.day], sortFields.milliseconds, [])
+		const oldSession = this.sessionMap[data.id]
+		if (oldSession) {
+			if (oldSession.lastMsgTime && data.lastMsgTime && oldSession.lastMsgTime > data.lastMsgTime) {
+				return oldSession
+			}
+			this._removeSessionFromDisplayData(data.id)
+			this._removeSessionFromTimeMap(this._lastUpdateSessionMap, data.id)
+			this._removeSessionFromTimeMap(this._reverseLastUpdateSessionMap, data.id)
+			Object.keys(data).forEach(key => {
+				Vue.set(oldSession, key, data[key])
+			})
+			data = oldSession
 		}
-		this.data.sessionData[topField][sortFields.day][sortFields.milliseconds].push(data)
+		this._insertSessionIntoDisplayData(data)
 		// 记录lastUpdateSession的顺序，因为后续分页加载会话数据的时候，加载的参数需要获取目前会话数据中最久远的一条会话记录，作为下载加载会话的参考数据
 		const lastUpdateSortFields = this.getSortField(data.lastUpdateTime)
 		if (!this._lastUpdateSessionMap) {
@@ -341,21 +476,7 @@ export default class ClientChatSession {
 			this._reverseLastUpdateSessionMap[reverseLastUpdateSortFields.day][reverseLastUpdateSortFields.milliseconds] = []
 		}
 		this._reverseLastUpdateSessionMap[reverseLastUpdateSortFields.day][reverseLastUpdateSortFields.milliseconds].push(data)
-		// 分组的
 		const groupField = data[this.groupField] || 'unkonw'
-		if (!this.data.sessionGroupData[groupField]) {
-			Vue.set(this.data.sessionGroupData, groupField, {})
-		}
-		if (!this.data.sessionGroupData[groupField][topField]) {
-			Vue.set(this.data.sessionGroupData[groupField], topField, {})
-		}
-		if (!this.data.sessionGroupData[groupField][topField][sortFields.day]) {
-			Vue.set(this.data.sessionGroupData[groupField][topField], sortFields.day, {})
-		}
-		if (!this.data.sessionGroupData[groupField][topField][sortFields.day][sortFields.milliseconds]) {
-			Vue.set(this.data.sessionGroupData[groupField][topField][sortFields.day], sortFields.milliseconds, [])
-		}
-		this.data.sessionGroupData[groupField][topField][sortFields.day][sortFields.milliseconds].push(data)
 		this.sessionMap[data.id] = data
 		// if (typeof this.data.sessionUnreadCountMap[groupField] !== 'number') {
 		// 	Vue.set(this.data.sessionUnreadCountMap, groupField, 0)
@@ -382,6 +503,11 @@ export default class ClientChatSession {
 		if (data.lastMsgTime && (!this.lastSession || data.lastMsgTime < this.lastSession.lastMsgTime)) {
 			this.lastSession = data
 		}
+		this.onAddSession && this.onAddSession({
+			session: data,
+			unreadDelta: options.unreadDelta
+		})
+		return data
 	}
 	
 	removeSession (id, checkLastUpdateSession) {
@@ -392,6 +518,9 @@ export default class ClientChatSession {
 		if (!session) {
 			return
 		}
+		this._removeSessionFromDisplayData(id)
+		this._removeSessionFromTimeMap(this._lastUpdateSessionMap, id)
+		this._removeSessionFromTimeMap(this._reverseLastUpdateSessionMap, id)
 		const topField = session.stickyOnTop ? 0 : 1 // 置顶
 		const sortFields = this.getSortField(session[this.sortField])
 		if (this.data.sessionData[topField] && this.data.sessionData[topField][sortFields.day] && this.data.sessionData[topField][sortFields.day][sortFields.milliseconds]) {
@@ -489,7 +618,15 @@ export default class ClientChatSession {
 		}
 		// lastSession是最小的时间，就是更早的，因为加载更多是从现在的加载历史的
 		const dayKeys = Object.keys(this._lastUpdateSessionMap)
+		if (!dayKeys.length) {
+			this.lastUpdateSession = null
+			this.lastUpdateTime = null
+			return
+		}
 		const millisecondsKeys = Object.keys(this._lastUpdateSessionMap[dayKeys[dayKeys.length - 1]])
+		if (!millisecondsKeys.length) {
+			return
+		}
 		const lastSessionSort = (this._lastUpdateSessionMap[dayKeys[dayKeys.length - 1]][millisecondsKeys[millisecondsKeys.length - 1]] || []).sort((a, b) => {
 			return a.lastUpdateTime - b.lastUpdateTime
 		})
@@ -509,7 +646,15 @@ export default class ClientChatSession {
 		}
 		// lastSession是最小的时间，就是更早的，因为加载更多是从现在的加载历史的
 		const dayKeys = Object.keys(this._reverseLastUpdateSessionMap)
+		if (!dayKeys.length) {
+			this.reverseLastUpdateSession = null
+			this.reverseLastUpdateTime = null
+			return
+		}
 		const millisecondsKeys = Object.keys(this._reverseLastUpdateSessionMap[dayKeys[dayKeys.length - 1]])
+		if (!millisecondsKeys.length) {
+			return
+		}
 		const lastSessionSort = (this._reverseLastUpdateSessionMap[dayKeys[dayKeys.length - 1]][millisecondsKeys[millisecondsKeys.length - 1]] || []).sort((a, b) => {
 			return b.lastUpdateTime - a.lastUpdateTime
 		})
@@ -578,163 +723,40 @@ export default class ClientChatSession {
 		} else {
 			nextProps = callback
 		}
-		if (nextProps) {
-			// 分组的
-			const groupField = session[this.groupField] || 'unkonw'
-			const { unreadMsgCount, stickyOnTop, mute, lastMsgTime, ...nextUpdateProps } = nextProps
-			Object.keys(nextUpdateProps).forEach(k => {
-				Vue.set(session, k, nextUpdateProps[k])
-			})
-			// 处理会话时间
-			if (typeof lastMsgTime !== 'undefined') {
-				const oldSortFields = this.getSortField(session.lastMsgTime)
-				// 把老的清空
-				// 重置一下数据
-				const topFields = [0, 1]
-				topFields.forEach(topField => {
-					if (this.data.sessionData[topField] && this.data.sessionData[topField][oldSortFields.day] && this.data.sessionData[topField][oldSortFields.day][oldSortFields.milliseconds]) {
-						let index = -1
-						this.data.sessionData[topField][oldSortFields.day][oldSortFields.milliseconds].some((v, i) => {
-							if (v === session) {
-								index = i
-								return true
-							}
-						})
-						if (index >= 0) {
-							this.data.sessionData[topField][oldSortFields.day][oldSortFields.milliseconds].splice(index, 1)
-						}
-					}
-					if (this.data.sessionGroupData[groupField] && this.data.sessionGroupData[groupField][topField] && this.data.sessionGroupData[groupField][topField][oldSortFields.day] && this.data.sessionGroupData[groupField][topField][oldSortFields.day][oldSortFields.milliseconds]) {
-						let index = -1
-						this.data.sessionGroupData[groupField][topField][oldSortFields.day][oldSortFields.milliseconds].some((v, i) => {
-							if (v === session) {
-								index = i
-								return true
-							}
-						})
-						if (index >= 0) {
-							this.data.sessionGroupData[groupField][topField][oldSortFields.day][oldSortFields.milliseconds].splice(index, 1)
-						}
-					}
-				})
-				// 按照新的时间来分组排序
-				Vue.set(session, 'lastMsgTime', lastMsgTime)
-				const topField = session.stickyOnTop ? 0 : 1 // 0置顶
-				const sortFields = this.getSortField(session.lastMsgTime)
-				// 所有的
-				if (!this.data.sessionData[topField]) {
-					Vue.set(this.data.sessionData, topField, {})
-				}
-				if (!this.data.sessionData[topField][sortFields.day]) {
-					Vue.set(this.data.sessionData[topField], sortFields.day, {})
-				}
-				if (!this.data.sessionData[topField][sortFields.day][sortFields.milliseconds]) {
-					Vue.set(this.data.sessionData[topField][sortFields.day], sortFields.milliseconds, [])
+		if (!nextProps) {
+			return session
+		}
+		const oldGroupField = session[this.groupField] || 'unkonw'
+		const nextGroupField = typeof nextProps[this.groupField] === 'undefined' ? oldGroupField : (nextProps[this.groupField] || 'unkonw')
+		const shouldReindex = (typeof nextProps.lastMsgTime !== 'undefined' && nextProps.lastMsgTime !== session.lastMsgTime) ||
+			(typeof nextProps.stickyOnTop !== 'undefined' && nextProps.stickyOnTop !== session.stickyOnTop) ||
+			nextGroupField !== oldGroupField
+		if (shouldReindex) {
+			this._removeSessionFromDisplayData(sessionId)
+		}
+		if (typeof nextProps.mute !== 'undefined' || nextGroupField !== oldGroupField) {
+			Object.keys(this.data.sessionMuteMap).forEach(groupField => {
+				if (this.data.sessionMuteMap[groupField]) {
+					Vue.delete(this.data.sessionMuteMap[groupField], sessionId)
 				}
-				this.data.sessionData[topField][sortFields.day][sortFields.milliseconds].push(session)
-				// 分组的
-				if (!this.data.sessionGroupData[groupField]) {
-					Vue.set(this.data.sessionGroupData, groupField, {})
-				}
-				if (!this.data.sessionGroupData[groupField][topField]) {
-					Vue.set(this.data.sessionGroupData[groupField], topField, {})
-				}
-				if (!this.data.sessionGroupData[groupField][topField][sortFields.day]) {
-					Vue.set(this.data.sessionGroupData[groupField][topField], sortFields.day, {})
-				}
-				if (!this.data.sessionGroupData[groupField][topField][sortFields.day][sortFields.milliseconds]) {
-					Vue.set(this.data.sessionGroupData[groupField][topField][sortFields.day], sortFields.milliseconds, [])
-				}
-				this.data.sessionGroupData[groupField][topField][sortFields.day][sortFields.milliseconds].push(session)
-			}
-			// 处理未读数量逻辑
-			if (typeof unreadMsgCount !== 'undefined') {
-				const origUnreadMsgCount = session.unreadMsgCount || 0
-				Vue.set(session, 'unreadMsgCount', unreadMsgCount)
-				// let nowUnreadMsgCount = session.unreadMsgCount || 0
-				// let diffUnreadMsgCount = nowUnreadMsgCount - origUnreadMsgCount
-				// if (diffUnreadMsgCount) {
-				// 	this.data.sessionUnreadCountMap[groupField] += diffUnreadMsgCount
-				// }
-			}
-			// 处理置顶会话逻辑
-			if (typeof stickyOnTop !== 'undefined') {
-				Vue.set(session, 'stickyOnTop', stickyOnTop)
-				const topField = nextProps.stickyOnTop ? 0 : 1 // 0置顶
-				// 把已经存在的剔除，先删后插
-				// 所有的
-				const sortFields = this.getSortField(session[this.sortField])
-				// 重置一下数据
-				const topFields = [0, 1]
-				topFields.forEach(topField => {
-					if (this.data.sessionData[topField] && this.data.sessionData[topField][sortFields.day] && this.data.sessionData[topField][sortFields.day][sortFields.milliseconds]) {
-						let index = -1
-						this.data.sessionData[topField][sortFields.day][sortFields.milliseconds].some((v, i) => {
-							if (v === session) {
-								index = i
-								return true
-							}
-						})
-						if (index >= 0) {
-							this.data.sessionData[topField][sortFields.day][sortFields.milliseconds].splice(index, 1)
-						}
-					}
-					if (this.data.sessionGroupData[groupField] && this.data.sessionGroupData[groupField][topField] && this.data.sessionGroupData[groupField][topField][sortFields.day] && this.data.sessionGroupData[groupField][topField][sortFields.day][sortFields.milliseconds]) {
-						let index = -1
-						this.data.sessionGroupData[groupField][topField][sortFields.day][sortFields.milliseconds].some((v, i) => {
-							if (v === session) {
-								index = i
-								return true
-							}
-						})
-						if (index >= 0) {
-							this.data.sessionGroupData[groupField][topField][sortFields.day][sortFields.milliseconds].splice(index, 1)
-						}
-					}
-				})
-				// 所有的
-				if (!this.data.sessionData[topField]) {
-					Vue.set(this.data.sessionData, topField, {})
-				}
-				if (!this.data.sessionData[topField][sortFields.day]) {
-					Vue.set(this.data.sessionData[topField], sortFields.day, {})
-				}
-				if (!this.data.sessionData[topField][sortFields.day][sortFields.milliseconds]) {
-					Vue.set(this.data.sessionData[topField][sortFields.day], sortFields.milliseconds, [])
-				}
-				this.data.sessionData[topField][sortFields.day][sortFields.milliseconds].push(session)
-				// 分组的
-				if (!this.data.sessionGroupData[groupField]) {
-					Vue.set(this.data.sessionGroupData, groupField, {})
-				}
-				if (!this.data.sessionGroupData[groupField][topField]) {
-					Vue.set(this.data.sessionGroupData[groupField], topField, {})
-				}
-				if (!this.data.sessionGroupData[groupField][topField][sortFields.day]) {
-					Vue.set(this.data.sessionGroupData[groupField][topField], sortFields.day, {})
-				}
-				if (!this.data.sessionGroupData[groupField][topField][sortFields.day][sortFields.milliseconds]) {
-					Vue.set(this.data.sessionGroupData[groupField][topField][sortFields.day], sortFields.milliseconds, [])
-				}
-				this.data.sessionGroupData[groupField][topField][sortFields.day][sortFields.milliseconds].push(session)
+			})
+		}
+		Object.keys(nextProps).forEach(key => {
+			if (session[key] !== nextProps[key]) {
+				Vue.set(session, key, nextProps[key])
 			}
-			// 处理免打扰
-			if (typeof mute !== 'undefined') {
-				Vue.set(session, 'mute', mute)
-				if (mute) {
-					if (!this.data.sessionMuteMap[groupField]) {
-						Vue.set(this.data.sessionMuteMap, groupField, {})
-					}
-					if (!this.data.sessionMuteMap[groupField][session.id]) {
-						Vue.set(this.data.sessionMuteMap[groupField], session.id, session)
-					}
-				} else {
-					if (this.data.sessionMuteMap[groupField]) {
-						Vue.delete(this.data.sessionMuteMap[groupField], session.id)
-					}
-				}
+		})
+		if (shouldReindex) {
+			this._insertSessionIntoDisplayData(session)
+		}
+		const groupField = session[this.groupField] || 'unkonw'
+		if (session.mute) {
+			if (!this.data.sessionMuteMap[groupField]) {
+				Vue.set(this.data.sessionMuteMap, groupField, {})
 			}
+			Vue.set(this.data.sessionMuteMap[groupField], session.id, session)
 		}
+		return session
 	}
 	
 	/**
@@ -963,9 +985,12 @@ export default class ClientChatSession {
 	}
 	
 	reset () {
+		this.stopGetSessionPollRequests()
 		this.lastUpdateTime = null
 		this.lastUpdateSession = null
 		this.lastSession = null
+		this._lastUpdateSessionMap = {}
+		this._reverseLastUpdateSessionMap = {}
 		this.data.sessionData = {}
 		this.data.sessionGroupData = {}
 		this.data.sessionMuteMap = {}

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

@@ -5,7 +5,6 @@ import ClientChatContacts from './client-chat-concats.js'
 import ClientChatAccount from './client-chat-account.js'
 import ClientChatSocket from './client-chat-socket.js'
 import { createSessionId } from './utils.js'
-import { createPollRequest } from '../../../utils/util.js'
 import Event from '../../../utils/event.js'
 
 const CONNECT_STATUS = {
@@ -22,8 +21,6 @@ class ClientChat {
 		return this.data.connectStatus === CONNECT_STATUS.Loading
 	}
 	
-	_sessionPollRequestMap = {}
-	
 	constructor (options) {
 
 		options = Object.assign({
@@ -79,6 +76,14 @@ class ClientChat {
 			getSessionMethod: options.getSessionMethod,
 			loadSessionDataMethod: options.loadSessionDataMethod, 
 			deleteSessionMethod: options.deleteSessionMethod,
+			onAddSession: ({ session, unreadDelta }) => {
+				if (!unreadDelta) {
+					return
+				}
+				this.account.updateAccountUnreadMessageNum(session.qwAccountId, ({ unreadMesasgeNum }) => {
+					return (unreadMesasgeNum || 0) + unreadDelta
+				})
+			},
 			onSessionReadChange: ({ session, oldUnreadMsgCount }) => {
 				this.account.updateAccountUnreadMessageNum(session.qwAccountId, ({ unreadMesasgeNum }) => {
 					return Math.max(0, unreadMesasgeNum - oldUnreadMsgCount)
@@ -90,64 +95,69 @@ class ClientChat {
 			sortField: 'sendTime',
 			clientChat: this,
 			checkMessageSendResultMethod: options.checkMessageSendResultMethod,
-			onAddMessageSuccess: ({ data }) => {
-				const accountId = this.getLoginAccountIdMethod ? this.getLoginAccountIdMethod() : data.qwAccountId
+			onAddMessageSuccess: ({ data, isBeforeLastMessage }) => {
+				const accountId = options.getLoginAccountIdMethod ? options.getLoginAccountIdMethod() : data.qwAccountId
 				let sessionId = createSessionId(accountId, data.contactId)
 				// 更新会话
 				if (!sessionId) {
 					return
 				}
+				if (isBeforeLastMessage) {
+					return
+				}
 				const localSession = this.session.getSessionByLocal(sessionId)
 				if (!localSession) {
-					if (this._sessionPollRequestMap[sessionId]) {
-						this._sessionPollRequestMap[sessionId].stop()
-					}
-					this._sessionPollRequestMap[sessionId] = createPollRequest(({ done, fail }) => {
-						return this.session.getSession(sessionId).then(done)
-					})
-					this._sessionPollRequestMap[sessionId].start().then((rs) => {
-						// 后端更新会话是异步过程，返回的会话信息可能还未包含当前消息
-						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.sendTime
-							rs.data.lastMsgId = data.id
-							rs.data.lastUpdateTime = data.updateDate
+					return this.session.getSession(sessionId, (rs, context) => {
+						if (rs && rs.data) {
+							const isAfterServerMessage = data.sendTime > context.baseLastMsgTime
+							const isNewerMessage = data.sendTime > (rs.data.lastMsgTime || 0)
+							if (isNewerMessage) {
+								rs.data.lastMsgContent = data.content
+								rs.data.lastMsgType = data.msgType
+								rs.data.lastMsgTime = data.sendTime
+								rs.data.lastMsgId = data.id
+								rs.data.lastUpdateTime = data.updateDate
+							}
+							const isCurrentSession = this.session.currentSession && this.session.currentSession.id === sessionId
+							// 服务端返回的会话还没有包含当前消息时，本地补充会话未读数
+							if (!data.isSend && isAfterServerMessage) {
+								rs.data.unreadMsgCount = isCurrentSession ? 0 : (rs.data.unreadMsgCount || 0) + 1
+							}
+							// 账号未读只累计本次轮询期间新增的消息，避免重复累计服务端已有的未读数
+							if (!data.isSend && !(isAfterServerMessage && isCurrentSession)) {
+								context.accountUnreadDelta += 1
+							}
 						}
-						// 更新账号未读消息数量
-						this.account.updateAccountUnreadMessageNum(rs.data.qwAccountId, ({ unreadMesasgeNum }) => {
-							return unreadMesasgeNum += (rs.data.unreadMsgCount || 0)
-						})
-					}).finally(() => {
-						delete this._sessionPollRequestMap[sessionId]
-					})
+						return rs
+					}).catch(() => {})
 				} else {
 					this.session.updateSession(sessionId, ({ session }) => {
-						let unreadMsgCount = session.unreadMsgCount
-						if (!data.isSend) {
-							unreadMsgCount = unreadMsgCount + 1
-						}
-						// 如果是当前会话，那么未读消息需要设置为0
-						if (this.session.currentSession && this.session.currentSession.id === sessionId) {
-							unreadMsgCount = 0
-							// 标记已读，并且设置未读数量为0
-							this.session.setSessionRead(sessionId)
-						} else {
-							// 更新账号未读消息数量
-							this.account.updateAccountUnreadMessageNum(session.qwAccountId, ({ unreadMesasgeNum }) => {
-								return unreadMesasgeNum += 1
-							})
+						const isNewerMessage = data.sendTime > (session.lastMsgTime || 0)
+						if (!isNewerMessage) {
+							return {}
 						}
-						const nextSessin = {
+						const nextSession = {
 							lastMsgContent: data.content,
 							lastMsgType: data.msgType,
 							lastMsgTime: data.sendTime,
 							lastMsgId: data.id,
 							lastUpdateTime: data.updateDate,
-							unreadMsgCount
+							unreadMsgCount: session.unreadMsgCount || 0
 						}
-						return nextSessin
+						if (!data.isSend) {
+							if (this.session.currentSession && this.session.currentSession.id === sessionId) {
+								// 标记已读
+								nextSession.unreadMsgCount = 0
+								this.session.setSessionRead(sessionId)
+							} else {
+								nextSession.unreadMsgCount += 1
+								// 更新账号未读消息数量
+								this.account.updateAccountUnreadMessageNum(session.qwAccountId, ({ unreadMesasgeNum }) => {
+									return (unreadMesasgeNum || 0) + 1
+								})
+							}
+						}
+						return nextSession
 					})
 				}
 			},
@@ -170,65 +180,70 @@ class ClientChat {
 			sortField: 'sendTime',
 			clientChat: this,
 			checkMessageSendResultMethod: options.checkMessageSendResultMethod,
-			onAddMessageSuccess: ({ data }) => {
-				const accountId = this.getLoginAccountIdMethod ? this.getLoginAccountIdMethod() : data.qwAccountId
+			onAddMessageSuccess: ({ data, isBeforeLastMessage }) => {
+				const accountId = options.getLoginAccountIdMethod ? options.getLoginAccountIdMethod() : data.qwAccountId
 				let sessionId = createSessionId(accountId, data.roomId)
 				// 更新会话
 				if (!sessionId) {
 					return
 				}
+				if (isBeforeLastMessage) {
+					return
+				}
 				// 更新会话未读消息数量
 				const localSession = this.session.getSessionByLocal(sessionId)
 				if (!localSession) {
-					if (this._sessionPollRequestMap[sessionId]) {
-						this._sessionPollRequestMap[sessionId].stop()
-					}
-					this._sessionPollRequestMap[sessionId] = createPollRequest(({ done, fail }) => {
-						return this.session.getSession(sessionId).then(done)
-					})
-					this._sessionPollRequestMap[sessionId].start().then((rs) => {
-						// 后端更新会话是异步过程，返回的会话信息可能还未包含当前消息
-						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.sendTime
-							rs.data.lastMsgId = data.id
-							rs.data.lastUpdateTime = data.updateDate
+					return this.session.getSession(sessionId, (rs, context) => {
+						if (rs && rs.data) {
+							const isAfterServerMessage = data.sendTime > context.baseLastMsgTime
+							const isNewerMessage = data.sendTime > (rs.data.lastMsgTime || 0)
+							if (isNewerMessage) {
+								rs.data.lastMsgContent = data.content
+								rs.data.lastMsgType = data.msgType
+								rs.data.lastMsgTime = data.sendTime
+								rs.data.lastMsgId = data.id
+								rs.data.lastUpdateTime = data.updateDate
+							}
+							const isCurrentSession = this.session.currentSession && this.session.currentSession.id === sessionId
+							// 服务端返回的会话还没有包含当前消息时，本地补充会话未读数
+							if (!data.isSend && isAfterServerMessage) {
+								rs.data.unreadMsgCount = isCurrentSession ? 0 : (rs.data.unreadMsgCount || 0) + 1
+							}
+							// 账号未读只累计本次轮询期间新增的消息，避免重复累计服务端已有的未读数
+							if (!data.isSend && !(isAfterServerMessage && isCurrentSession)) {
+								context.accountUnreadDelta += 1
+							}
 						}
-						// 更新账号未读消息数量
-						this.account.updateAccountUnreadMessageNum(rs.data.qwAccountId, ({ unreadMesasgeNum }) => {
-							return unreadMesasgeNum += (rs.data.unreadMsgCount || 0)
-						})
-					}).finally(() => {
-						delete this._sessionPollRequestMap[sessionId]
-					})
+						return rs
+					}).catch(() => {})
 				} else {
 					this.session.updateSession(sessionId, ({ session }) => {
-						let unreadMsgCount = session.unreadMsgCount
-						if (!data.isSend) {
-							unreadMsgCount = unreadMsgCount + 1
+						const isNewerMessage = data.sendTime > (session.lastMsgTime || 0)
+						if (!isNewerMessage) {
+							return {}
 						}
-						// 如果是当前会话，那么未读消息需要设置为0
-						if (this.session.currentSession && this.session.currentSession.id === sessionId) {
-							unreadMsgCount = 0
-							// 标记已读，并且设置未读数量为0
-							this.session.setSessionRead(sessionId)
-						} else {
-							// 更新账号未读消息数量
-							this.account.updateAccountUnreadMessageNum(session.qwAccountId, ({ unreadMesasgeNum }) => {
-								return unreadMesasgeNum += 1
-							})
-						}
-						const nextSessin = {
+						const nextSession = {
 							lastMsgContent: data.content,
 							lastMsgType: data.msgType,
 							lastMsgTime: data.sendTime,
 							lastMsgId: data.id,
 							lastUpdateTime: data.updateDate,
-							unreadMsgCount
+							unreadMsgCount: session.unreadMsgCount || 0
 						}
-						return nextSessin
+						if (!data.isSend) {
+							if (this.session.currentSession && this.session.currentSession.id === sessionId) {
+								// 标记已读
+								nextSession.unreadMsgCount = 0
+								this.session.setSessionRead(sessionId)
+							} else {
+								nextSession.unreadMsgCount += 1
+								// 更新账号未读消息数量
+								this.account.updateAccountUnreadMessageNum(session.qwAccountId, ({ unreadMesasgeNum }) => {
+									return (unreadMesasgeNum || 0) + 1
+								})
+							}
+						}
+						return nextSession
 					})
 				}
 			},
@@ -620,12 +635,7 @@ class ClientChat {
 	
 	disconnect () {
 		this.data.connectStatus = CONNECT_STATUS.Normal
-		if (this._sessionPollRequestMap) {
-			Object.keys(this._sessionPollRequestMap).forEach(key => {
-				this._sessionPollRequestMap[key].stop()
-			})
-			this._sessionPollRequestMap = {}
-		}
+		this.session.stopGetSessionPollRequests()
 		this.contacts.reset()
 		this.account.reset()
 		this.friendMessage.reset()