@aochuang/client-sdk 1.0.367 → 1.0.369

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aochuang/client-sdk",
-  "version": "1.0.367",
+  "version": "1.0.369",
   "description": "",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"

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

@@ -30,7 +30,8 @@ export default class ClientChatAccount {
 			onAccountRemoved: null,
 			onUnreadMessageNumChange: null,
 			onDeleteAccountSession: null,
-			onAccountLoaded: null
+			onAccountLoaded: null,
+			onUnreadMessageNumLog: null
 		}, options)
 		if (!options.loadAccountDataMethod) {
 			throw new Error('缺少loadAccountDataMethod配置')
@@ -51,6 +52,19 @@ export default class ClientChatAccount {
 		this.onUnreadMessageNumChange = options.onUnreadMessageNumChange
 		this.onDeleteAccountSession = options.onDeleteAccountSession
 		this.onAccountLoaded = options.onAccountLoaded
+		this.onUnreadMessageNumLog = options.onUnreadMessageNumLog
+	}
+
+	_addUnreadMessageNumLog (title, data) {
+		if (this.onUnreadMessageNumLog) {
+			this.onUnreadMessageNumLog({
+				group: 'client-chat-account:unreadMessageNum',
+				content: {
+					title,
+					data
+				}
+			})
+		}
 	}
 	
 	get accountData () {
@@ -198,6 +212,10 @@ export default class ClientChatAccount {
 				})
 			}
 			this.data.accountUnreadMessageNumData = nextData
+			this._addUnreadMessageNumLog('服务端全量刷新账号未读数量', {
+				source: 'refreshAll',
+				accounts: nextData
+			})
 		})
 	}
 	
@@ -216,23 +234,33 @@ export default class ClientChatAccount {
 					return true
 				}
 			})
+			const before = index >= 0 ? this.data.accountUnreadMessageNumData[index] : null
+			const after = {
+				id: wechatAccountId,
+				num: rs.data[0].unread || 0,
+				muteNum: rs.data[0].muteUnread || 0
+			}
 			if (index >= 0) {
-				this.data.accountUnreadMessageNumData.splice(index, 1, {
-					id: wechatAccountId,
-					num: rs.data[0].unread || 0,
-					muteNum: rs.data[0].muteUnread || 0
-				})
+				this.data.accountUnreadMessageNumData.splice(index, 1, after)
 			} else {
-				this.data.accountUnreadMessageNumData.push({
-					id: wechatAccountId,
-					num: rs.data[0].unread || 0,
-					muteNum: rs.data[0].muteUnread || 0
-				})
+				this.data.accountUnreadMessageNumData.push(after)
 			}
+			this._addUnreadMessageNumLog('服务端刷新账号未读数量', {
+				source: 'refresh',
+				wechatAccountId,
+				before: before ? { num: before.num, muteNum: before.muteNum } : null,
+				after: { num: after.num, muteNum: after.muteNum }
+			})
 		})
 	}
 	
-	updateAccountUnreadMessageNum (accountId, callback) {
+	/**
+	 * 本地增量更新账号未读数量
+	 * @param { String } accountId
+	 * @param { Function } callback 返回 { num, muteNum }
+	 * @param { String } source 调用来源标记，仅用于日志排查
+	 */
+	updateAccountUnreadMessageNum (accountId, callback, source) {
 		return this.getAccount(accountId).then(rs => {
 			if (!rs || !rs.data) {
 				console.warn('未找到' + accountId + '工作微信号')
@@ -248,11 +276,26 @@ export default class ClientChatAccount {
 					return true
 				}
 			})
+			const beforeNum = unreadMessageNumIndex >= 0 ? this.data.accountUnreadMessageNumData[unreadMessageNumIndex].num : 0
+			const beforeMuteNum = unreadMessageNumIndex >= 0 ? this.data.accountUnreadMessageNumData[unreadMessageNumIndex].muteNum : 0
 			const nextReadMessageNum = callback({
 				account: rs.data,
-				unreadMesasgeNum: unreadMessageNumIndex >= 0 ? this.data.accountUnreadMessageNumData[unreadMessageNumIndex].num : 0,
-				unreadMessageMuteNum: unreadMessageNumIndex >= 0 ? this.data.accountUnreadMessageNumData[unreadMessageNumIndex].muteNum : 0
+				unreadMesasgeNum: beforeNum,
+				unreadMessageMuteNum: beforeMuteNum
 			})
+			if (this.onUnreadMessageNumLog && nextReadMessageNum !== undefined && nextReadMessageNum !== null) {
+				const afterNum = typeof nextReadMessageNum === 'object' ? nextReadMessageNum.num : nextReadMessageNum
+				const afterMuteNum = typeof nextReadMessageNum === 'object' ? nextReadMessageNum.muteNum : beforeMuteNum
+				if (afterNum !== beforeNum || afterMuteNum !== beforeMuteNum) {
+					this._addUnreadMessageNumLog('本地增量更新账号未读数量', {
+						source: source || 'unknown',
+						wechatAccountId: accountId,
+						before: { num: beforeNum, muteNum: beforeMuteNum },
+						after: { num: afterNum, muteNum: afterMuteNum },
+						delta: { num: (afterNum || 0) - (beforeNum || 0), muteNum: (afterMuteNum || 0) - (beforeMuteNum || 0) }
+					})
+				}
+			}
 			if (nextReadMessageNum && typeof nextReadMessageNum === 'object') {
 				/**
 				 * {

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

@@ -311,11 +311,22 @@ export default class ClientChatSession {
 			if (!rs.data) {
 				return Promise.reject('未找到会话' + sessionId)
 			}
+			/**
+			 * 轮询合并上下文，会依次传给每个 serializeMethod（见 client-chat.js onCmdNewMessage 里 getSession 的回调）
+			 * baseLastMsgTime     服务端返回的会话 lastMsgTime，用来判断某条消息服务端是否已经算进 unreadMsgCount
+			 * processedMessageIds 本次轮询期间处理过的所有消息 id
+			 * skippedMessageIds   服务端返回的会话已经包含（wechatTime <= baseLastMsgTime）、本地不再给会话未读 +1 的消息 id
+			 * unreadMessageIds    本地给会话未读 +1 的消息 id
+			 * accountUnreadDelta  本次轮询期间需要累加到工作微信号（账号）未读数量上的条数。
+			 *                     注意它和 unreadMessageIds.length 不同：账号未读初始值是登录时取的，不包含本次收到的任何消息，
+			 *                     所以被 skip 的消息也要算进来；只有"正在看当前会话被直接标记已读"的消息不算
+			 */
 			const context = {
 				baseLastMsgTime: rs.data.lastMsgTime || 0,
 				processedMessageIds: [],
 				skippedMessageIds: [],
-				unreadMessageIds: []
+				unreadMessageIds: [],
+				accountUnreadDelta: 0
 			}
 			const serializeTasks = pollRequest.serializeTasks.slice().sort((a, b) => {
 				return a.wechatTime - b.wechatTime || a.index - b.index
@@ -326,7 +337,11 @@ export default class ClientChatSession {
 					context.processedMessageIds.push(task.messageId)
 				}
 			})
-			this.addSession(rs.data, null)
+			// wechatAccountId 传 null 表示非分页来源，onAddSession 会把未读同步到账号；
+			// 同时带上 unreadDelta，让账号只累加本次新增的条数，而不是服务端返回的整个 unreadMsgCount（那里面的存量部分账号初始值已经包含了）
+			this.addSession(rs.data, null, {
+				unreadDelta: context.accountUnreadDelta
+			})
 			const wechatAccountId = rs.data.wechatAccountId
 			this._addGetSessionLog('会话轮询合并完成', {
 				sessionId,
@@ -341,6 +356,7 @@ export default class ClientChatSession {
 				processedMessageCount: context.processedMessageIds.length,
 				skippedMessageCount: context.skippedMessageIds.length,
 				unreadMessageCount: context.unreadMessageIds.length,
+				accountUnreadDelta: context.accountUnreadDelta,
 				hasSessionMap: !!this.sessionMap[sessionId],
 				hasAllSessionGroup: !!this._getSessionBySessionGroup(sessionId, ALL_WECHAT_ACCOUNT_ID),
 				hasAccountSessionGroup: !!this._getSessionBySessionGroup(sessionId, wechatAccountId)
@@ -486,8 +502,10 @@ export default class ClientChatSession {
 	 *		"unreadMsgCount": 3,
 	 *		"wechatAccountId": "2a39a725814acf07502299ab2285fff8d44377f5"
 	 *	}
+	 * @params { Object } - options
+	 * @params { Number } - options.unreadDelta 本次新增的未读条数，新消息触发getSession拉回会话时传入，用于账号未读数量只累加新增部分而不是整个unreadMsgCount
 	*/
-	addSession (data, wechatAccountId) {
+	addSession (data, wechatAccountId, options = {}) {
 		if (!data || !data.conversationId) {
 			throw new Error('缺少必须参数conversationId')
 		}
@@ -591,7 +609,8 @@ export default class ClientChatSession {
 		}
 		this.onAddSession && this.onAddSession({
 			wechatAccountId,
-			session: nextData
+			session: nextData,
+			unreadDelta: options.unreadDelta
 		})
 	}
 

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

@@ -228,8 +228,12 @@ export default class Websocket {
     exportLogData () {
         return this.socket.exportLogData()
     }
+
+    checkAndSync () {
+        return this.socket.checkAndSync()
+    }
     
     clearLogData () {
         return this.socket.clearLogData()
     }
-}
+}

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

@@ -115,23 +115,42 @@ class ClientChat {
 		const mergeSessionCommonOptions = (options, instance) => {
 			let updateSessioning = false
 			let removeSessioning = false
-			options.onAddSession = ({ session, wechatAccountId }) => {
+			/**
+			 * 会话新增回调，负责把新增会话的未读数量同步到工作微信号（账号）的未读数量上
+			 * @param { Object } session - 新增的会话
+			 * @param { String } wechatAccountId - 有值代表是分页加载（loadData/reload）来的会话，账号未读初始值已经包含，不累加
+			 * @param { Number } unreadDelta - 本次真正新增的未读条数，只有新消息触发 getSession 拉回会话时才会传（见 client-chat-session.js getSession）
+			 *
+			 * 账号未读数量的初始值来自登录时的 getAccountUnreadMessageNumMethod，是服务端按该账号"所有会话"算的，
+			 * 不管本地有没有分页加载到这些会话。所以非分页来源的会话要区分两种情况：
+			 *   1. 分配过来的会话（loadAssignTaskSessionData）：之前不属于这个账号，账号初始值里没有它，
+			 *      需要把整个 session.unreadMsgCount 累加上去。此时 unreadDelta 为 undefined。
+			 *   2. 新消息触发 getSession 拉回来的会话：一直属于这个账号，只是本地没翻页加载到，它的存量未读已经在账号初始值里了，
+			 *      如果再把整个 unreadMsgCount 加上去就会重复计算存量部分（这就是"会话都已读了但账号还有未读数、刷新后归零"的主因）。
+			 *      这种情况只能累加本次轮询期间新增的条数，即 unreadDelta。
+			 */
+			options.onAddSession = ({ session, wechatAccountId, unreadDelta }) => {
 				// 不是来源于分页的时候，没有wechatAccountId就是代表不是走的分页增加的会话，一般为获取新消息或则分配的会话
 				if (!wechatAccountId && instance === this.session) {
-					// 更新账号未读消息数量
-					this.account.updateAccountUnreadMessageNum(session.wechatAccountId, ({ unreadMesasgeNum, unreadMessageMuteNum }) => {
-						if (session.mute) {
-							return {
-								num: (unreadMesasgeNum || 0) + (session.unreadMsgCount || 0),
-								muteNum: (unreadMessageMuteNum || 0) + (session.unreadMsgCount || 0)
-							}
-						} else {
-							return {
-								num: (unreadMesasgeNum || 0) + (session.unreadMsgCount || 0),
-								muteNum: unreadMessageMuteNum
+					// unreadDelta 是数字 → getSession 来源，只加新增；否则 → 分配等来源，整个 unreadMsgCount 加上
+					const delta = typeof unreadDelta === 'number' ? unreadDelta : (session.unreadMsgCount || 0)
+					// delta 为 0 时不更新，避免产生无意义的账号未读更新和日志
+					if (delta > 0) {
+						// 更新账号未读消息数量
+						this.account.updateAccountUnreadMessageNum(session.wechatAccountId, ({ unreadMesasgeNum, unreadMessageMuteNum }) => {
+							if (session.mute) {
+								return {
+									num: (unreadMesasgeNum || 0) + delta,
+									muteNum: (unreadMessageMuteNum || 0) + delta
+								}
+							} else {
+								return {
+									num: (unreadMesasgeNum || 0) + delta,
+									muteNum: unreadMessageMuteNum
+								}
 							}
-						}
-					})
+						}, typeof unreadDelta === 'number' ? 'onAddSession:getSession' : 'onAddSession')
+					}
 				}
 				// 同步未读会话
 				if (instance !== this.sessionUnread && session.unreadMsgCount > 0) {
@@ -231,7 +250,7 @@ class ClientChat {
 								muteNum: unreadMessageMuteNum
 							}
 						}
-					})
+					}, 'onRemoveSession')
 					// 删除会话会同步删除所有的实例，所以需要做这个检查
 					if (this.sessionManage.currentSession && this.sessionManage.currentSession.conversationId === session.conversationId) {
 						this.sessionManage.setCurrentSession(null)
@@ -287,7 +306,7 @@ class ClientChat {
 							muteNum: unreadMessageMuteNum
 						}
 					}
-				})
+				}, 'onSessionReadChange')
 			}
 		}
 		this.session = new ClientChatSession({
@@ -445,8 +464,12 @@ class ClientChat {
 								rs.data.lastMsgId = data.id
 								rs.data.lastUpdateTime = data.updateDate
 							}
+							// 正在看这个会话并且允许自动标记已读
+							const isCurrentSessionRead = this.sessionManage.currentSession && this.sessionManage.currentSession.conversationId === sessionId && this.shouldMarkCurrentSessionRead(sessionId, data)
+							// 会话未读数量：isAfterServerMessage 为 true 表示这条消息比服务端返回的会话 lastMsgTime 新，
+							// 服务端返回的 unreadMsgCount 还没算它，需要本地 +1；否则服务端已经算进去了，skip 掉避免重复
 							if (!data.isSend && isAfterServerMessage) {
-								if (this.sessionManage.currentSession && this.sessionManage.currentSession.conversationId === sessionId && this.shouldMarkCurrentSessionRead(sessionId, data)) {
+								if (isCurrentSessionRead) {
 									rs.data.unreadMsgCount = 0
 								} else {
 									rs.data.unreadMsgCount = (rs.data.unreadMsgCount || 0) + 1
@@ -455,6 +478,13 @@ class ClientChat {
 							} else {
 								context.skippedMessageIds.push(data.id)
 							}
+							// 账号未读数量：和会话未读数量的判断口径不一样。
+							// 账号未读初始值是登录时从服务端取的，不包含这条新消息，所以不管这条消息有没有被服务端算进会话的 unreadMsgCount（即不管是否被 skip），
+							// 账号都要 +1。唯一不加的情况是"正在看当前会话并被直接标记已读"（此时会话未读被置 0，不会再通过 onSessionReadChange 扣减账号）。
+							// 这个累计值会通过 addSession(rs.data, null, { unreadDelta }) 传给 onAddSession，账号只累加这个增量而不是整个 unreadMsgCount
+							if (!data.isSend && !(isAfterServerMessage && isCurrentSessionRead)) {
+								context.accountUnreadDelta += 1
+							}
 						}
 						return rs
 					}, {
@@ -496,7 +526,7 @@ class ClientChat {
 											muteNum: unreadMessageMuteNum
 										}
 									}
-								})
+								}, 'onNewFriendMessage')
 							}
 						}
 						return nextSession
@@ -581,8 +611,12 @@ class ClientChat {
 								rs.data.lastMsgId = data.id
 								rs.data.lastUpdateTime = data.updateDate
 							}
+							// 正在看这个会话并且允许自动标记已读
+							const isCurrentSessionRead = this.sessionManage.currentSession && this.sessionManage.currentSession.conversationId === sessionId && this.shouldMarkCurrentSessionRead(sessionId, data)
+							// 会话未读数量：isAfterServerMessage 为 true 表示这条消息比服务端返回的会话 lastMsgTime 新，
+							// 服务端返回的 unreadMsgCount 还没算它，需要本地 +1；否则服务端已经算进去了，skip 掉避免重复
 							if (!data.isSend && isAfterServerMessage) {
-								if (this.sessionManage.currentSession && this.sessionManage.currentSession.conversationId === sessionId && this.shouldMarkCurrentSessionRead(sessionId, data)) {
+								if (isCurrentSessionRead) {
 									rs.data.unreadMsgCount = 0
 								} else {
 									rs.data.unreadMsgCount = (rs.data.unreadMsgCount || 0) + 1
@@ -594,6 +628,13 @@ class ClientChat {
 							} else {
 								context.skippedMessageIds.push(data.id)
 							}
+							// 账号未读数量：和会话未读数量的判断口径不一样。
+							// 账号未读初始值是登录时从服务端取的，不包含这条新消息，所以不管这条消息有没有被服务端算进会话的 unreadMsgCount（即不管是否被 skip），
+							// 账号都要 +1。唯一不加的情况是"正在看当前会话并被直接标记已读"（此时会话未读被置 0，不会再通过 onSessionReadChange 扣减账号）。
+							// 这个累计值会通过 addSession(rs.data, null, { unreadDelta }) 传给 onAddSession，账号只累加这个增量而不是整个 unreadMsgCount
+							if (!data.isSend && !(isAfterServerMessage && isCurrentSessionRead)) {
+								context.accountUnreadDelta += 1
+							}
 						}
 						return rs
 					}, {
@@ -638,7 +679,7 @@ class ClientChat {
 											muteNum: unreadMessageMuteNum
 										}
 									}
-								})
+								}, 'onNewRoomMessage')
 							}
 						}
 						return nextSession
@@ -748,6 +789,26 @@ class ClientChat {
 			getAccountGreetingUnreadMsgCountMethod: options.getAccountGreetingUnreadMsgCountMethod,
 			batchGetAccountGreetingUnreadMsgCountMethod: options.batchGetAccountGreetingUnreadMsgCountMethod,
 			clearAccountGreetingUnreadMsgCountMethod: options.clearAccountGreetingUnreadMsgCountMethod,
+			// 账号未读数量变化日志，附带该账号本地会话未读之和，用于排查账号未读数和会话未读数不一致的问题
+			onUnreadMessageNumLog: (log) => {
+				if (!this.socket) {
+					return
+				}
+				const wechatAccountId = log.content && log.content.data && log.content.data.wechatAccountId
+				if (wechatAccountId && this.session) {
+					log.content.data.localSessionUnread = Object.keys(this.session.sessionMap).reduce((rs, id) => {
+						const session = this.session.sessionMap[id]
+						if (session && session.wechatAccountId === wechatAccountId) {
+							rs.num += session.unreadMsgCount || 0
+							if (session.mute) {
+								rs.muteNum += session.unreadMsgCount || 0
+							}
+						}
+						return rs
+					}, { num: 0, muteNum: 0 })
+				}
+				this.socket.addLog(log)
+			},
 			onAccountAdded: ({ account }) => {
 				return this.account.refreshAccountUnreadMessageNum({
 					wechatAccountId: account.id
@@ -919,25 +980,10 @@ class ClientChat {
 										return this.contacts.getFriend(sessionFriendId, true)
 									})
 								}
-								// 刷新工作微信号未读消息数量
-								if (rs && rs.length) {
-									rs.forEach(session => {
-										this.account.updateAccountUnreadMessageNum(session.wechatAccountId, ({ unreadMesasgeNum, unreadMessageMuteNum }) => {
-											if (session.mute) {
-												return {
-													num: (unreadMesasgeNum || 0) + (session.unreadMsgCount || 0),
-													muteNum: (unreadMessageMuteNum || 0) + (session.unreadMsgCount || 0)
-												}
-											} else {
-												return {
-													num: (unreadMesasgeNum || 0) + (session.unreadMsgCount || 0),
-													muteNum: unreadMessageMuteNum
-												}
-											}
-										})
-									})
-								}
+								// 分配会话的未读数量已经在onAddSession里累加到工作微信号上了，这里不再重复累加
+								// 转移/删除的好友如果本地没有加载到对应会话，本地是无法扣减的，所以统一以服务端为准刷新一次
 								return ps.finally(() => {
+									this.refreshAccountsUnreadMessageNum([].concat(wechatAccountIds, data.wechatAccountIds || []))
 									// 这里应该标记那些工作微信号的通讯录修改了，后面要在界面打个提示，告诉用户通讯录变化了，让手动刷新一下
 									// 同时也将缓存都清理一下，例如工作微信号分组统计数量等
 									this.contacts.markModify() // 标记通讯录修改
@@ -963,6 +1009,8 @@ class ClientChat {
 								this.session.removeSession(session.conversationId)
 							}
 						}
+						// 本地没有加载到该会话时无法扣减未读数量，以服务端为准刷新一次
+						this.refreshAccountsUnreadMessageNum(data.wechatAccountIds)
 						// todo 刷新一下微信号，如果微信号一个好友都没了，应该要删除掉的
 						this.contacts.markModify() // 标记通讯录修改
 					} 
@@ -1001,25 +1049,10 @@ class ClientChat {
 								ps = this.account.reloadData()
 							}
 						}
-						// 刷新工作微信号未读消息数量
-						if (rs && rs.length) {
-							rs.forEach(session => {
-								this.account.updateAccountUnreadMessageNum(session.wechatAccountId, ({ unreadMesasgeNum, unreadMessageMuteNum }) => {
-									if (session.mute) {
-										return {
-											num: (unreadMesasgeNum || 0) + (session.unreadMsgCount || 0),
-											muteNum: (unreadMessageMuteNum || 0) + (session.unreadMsgCount || 0)
-										}
-									} else {
-										return {
-											num: (unreadMesasgeNum || 0) + (session.unreadMsgCount || 0),
-											muteNum: unreadMessageMuteNum
-										}
-									}
-								})
-							})
-						}
+						// 分配会话的未读数量已经在onAddSession里累加到工作微信号上了，这里不再重复累加
+						// 转移/删除的群聊如果本地没有加载到对应会话，本地是无法扣减的，所以统一以服务端为准刷新一次
 						return ps.finally(() => {
+							this.refreshAccountsUnreadMessageNum([].concat(wechatAccountIds, data.wechatAccountIds || []))
 							// 这里应该标记那些工作微信号的通讯录修改了，后面要在界面打个提示，告诉用户通讯录变化了，让手动刷新一下
 							// 同时也将缓存都清理一下，例如工作微信号分组统计数量等
 							this.contacts.markModify() // 标记通讯录修改
@@ -1043,6 +1076,8 @@ class ClientChat {
 					}
 					// 删除群聊
 					this.contacts.removeRoom(data.wechatChatroomId)
+					// 本地没有加载到该会话时无法扣减未读数量，以服务端为准刷新一次
+					this.refreshAccountsUnreadMessageNum(data.wechatAccountIds)
 				} 
 				// 更新群聊
 				else {
@@ -1080,6 +1115,8 @@ class ClientChat {
 					wechatAccountId: data.wechatAccountId,
 					unreadGreetingMsgCount: data.unreadGreetingMsgCount
 				})
+				// 刷新所有微信号请求数量
+				this.account.getAccountGreetingUnreadMsgCount()
 			},
 			onCmdNewFriendRequest: ({ data }) => {
 				// 刷新指定微信号请求数量
@@ -1151,6 +1188,10 @@ class ClientChat {
 				Promise.all(ps).finally(() => {
 					this.friendMessage.setLastReceiveMessageTime(Date.now())
 					this.roomMessage.setLastReceiveMessageTime(Date.now())
+					// 断线期间本地增量可能和服务端产生偏差（其他端已读、消息延迟等），重连后以服务端为准全量校准一次
+					if (ps.length) {
+						this.account.refreshAllAccountUnreadMesageNum()
+					}
 				})
 			}, 
 			onSocketClose: (evt) => {
@@ -1205,6 +1246,17 @@ class ClientChat {
 		this.shouldMarkCurrentSessionReadMethod = method
 	}
 
+	/**
+	 * 以服务端为准刷新指定工作微信号的未读消息数量，用于本地增量无法处理的场景（例如本地未加载到的会话被删除/转移）
+	 * @param { Array<String> } wechatAccountIds
+	 */
+	refreshAccountsUnreadMessageNum (wechatAccountIds) {
+		const ids = Array.from(new Set((wechatAccountIds || []).filter(id => id && this.account.accountMap[id])))
+		ids.forEach(wechatAccountId => {
+			this.account.refreshAccountUnreadMessageNum({ wechatAccountId })
+		})
+	}
+
 	shouldMarkCurrentSessionRead (sessionId, data) {
 		if (typeof this.shouldMarkCurrentSessionReadMethod === 'function') {
 			return this.shouldMarkCurrentSessionReadMethod({