@aochuang/client-sdk 1.0.278

package/services/socket/socket.js

@@ -0,0 +1,797 @@
+import Vue from 'vue'
+import { createPromise } from '../../utils/util.js'
+import { firstLetterUpperCase, unique } from '../../utils/string.js'
+import { isUni } from './utils.js'
+import Event from '../../utils/event.js'
+import Log from '../../utils/log'
+
+export const CONNECT_STATUS = {
+    Ready: -1,
+    Close: 0,
+    Connecting: 1,
+    Success: 2,
+    Error: 3
+}
+
+export default class Socket {
+    
+    socketAdapter = null
+    
+    reconnectCount = 0
+
+    maxReconnectCount = 1000 // 最大重连次数
+    
+    reconnectInterval = 1000
+    
+    maxReconnectInterval = 60000
+
+    data = Vue.observable({
+        connectIpChange: false, // 连接设备是否变化，如果变化需要提示用户退出重新登录
+        connectMessage: null,
+        connectUrl: null,
+        connectStatus: CONNECT_STATUS.Ready
+    })
+    
+    get connectStatus () {
+        return this.data.connectStatus
+    }
+    
+    get connectIpChange () {
+        return this.data.connectIpChange
+    }
+    
+    messageCallbackMap = {}
+    
+    constructor (options) {
+        options = Object.assign({
+            url: null,
+            client: null,
+            logEnable: false,
+            logName: 'socket',
+            logMaxSize: 5 * 1024 * 1024, // 最多记5M日志
+            socketAdapter: null, // 支持从外面传一个socket构造函数，但是要实现socket标准的使用方式
+            onExceedMaxReconnectLimit: null, // 超过最大重连次数回调
+            onBeforeSendMessage: null,
+            getLoginUserIdMethod: null,
+            getLoginUserTokenMethod: null
+        }, options)
+        if (!options.client) {
+            throw new Error('client不能为空')
+        }
+        if (!options.getLoginUserTokenMethod) {
+            throw new Error('getLoginUserTokenMethod不能为空')
+        }
+        if (!options.getLoginUserIdMethod) {
+            throw new Error('getLoginUserIdMethod不能为空')
+        }
+        this.socketAdapter = options.socketAdapter
+        this.client = options.client
+        this.getLoginUserTokenMethod = options.getLoginUserTokenMethod
+        this.getLoginUserIdMethod = options.getLoginUserIdMethod
+        this.onExceedMaxReconnectLimit = options.onExceedMaxReconnectLimit
+        this.onBeforeSendMessage = options.onBeforeSendMessage
+        this.logEnable = !!options.logEnable
+        this.url = options.url
+        this.event = new Event()
+        this.log = new Log({
+            maxSize: options.logMaxSize, // 最多存5M的日志数据
+            name: options.logName || 'socket'
+        })
+        // 会话失效
+        this.event.on('onCmdKickOut', () => {
+            this.event.emit('onKickOut')
+            this.data.connectIpChange = true
+        })
+        this.connectPromise = Promise.reject({
+            errMsg: 'socket未连接'
+        })
+        this.readyPromise = Promise.reject({
+            errMsg: 'socket未登录'
+        })
+        // 手动捕获一下，防止控制台总是提示
+        this.connectPromise.catch((e) => {})
+        this.readyPromise.catch((e) => {})
+    }
+    
+    get token () {
+        return this.getLoginUserTokenMethod()
+    }
+    
+    get accountId () {
+        return this.getLoginUserIdMethod()
+    }
+
+    _isCurrentSocket (socket) {
+        return !!socket && socket === this._ws
+    }
+
+    _handleReconnectLimitExceeded () {
+        const err = new Error('socket重连次数已超过上限')
+        clearTimeout(this._reconnectTimer)
+        this._isReconnecting = false
+        this._reconnectPromise = null
+        this._reconnectReject = null
+        // this.onExceedMaxReconnectLimit && this.onExceedMaxReconnectLimit(err)
+        return err
+    }
+    
+    connect () {
+        if (!this.url) {
+            return Promise.reject('缺少连接地址url配置')
+        }
+        if (this.connectStatus === CONNECT_STATUS.Connecting || this.connectStatus === CONNECT_STATUS.Success) {
+            return Promise.all([
+                this.connectPromise,
+                this.readyPromise
+            ])
+        }
+        let ps = Promise.resolve()
+        // 将上一次连接的socket实例销毁
+        if (this.lastConnectPromise) {
+            ps = this.lastConnectPromise.then(socket => {
+                // 主要是清理一下自定义的socket构造类里面的事件，比如shareworker里面创建的
+                socket && socket.destroy && socket.destroy()
+            }, () => {})
+            this.lastConnectPromise = null
+        }
+        ps = ps.then(() => {
+            this.data.connectIpChange = false
+            this.connectPromise = createPromise()
+            this.lastConnectPromise = this.connectPromise
+            this.readyPromise = createPromise()
+            this.data.connectUrl = this.url + `?client=${this.client}&accountId=${this.accountId}&accessToken=${this.token}`
+            let socket = null
+            this.data.connectStatus = CONNECT_STATUS.Connecting
+            this.logEnable && this.log.addLog({
+                group: 'socket:connect',
+                content: {
+                    title: '开始连接',
+                    socketUrl: this.data.connectUrl
+                }
+            })
+            this._ws = null
+            if (this.socketAdapter) {
+                socket = new this.socketAdapter(this.data.connectUrl)
+                this._ws = socket
+                socket.onopen = () => {
+                    if (!this._isCurrentSocket(socket)) {
+                        return
+                    }
+                    // onclose会比onopen先触发，导致connectStatus不正确，会被设置为错误的success状态，下次reconnect的时候判断连接状态出问题了
+                    // 因为前面状态在connecting，所以可以这么判断一下
+                    if (this.data.connectStatus === CONNECT_STATUS.Close || this.data.connectStatus === CONNECT_STATUS.Error) {
+                        this.readyPromise.reject(new Error('socket连接已经关闭或者发生了错误'))
+                    } else {
+                        this.data.connectStatus = CONNECT_STATUS.Success
+                        this.connectPromise.resolve(socket)
+                        this.handleSocketOpen(() => {
+                            this.readyPromise.resolve(socket)
+                        }, (err) => {
+                            this.readyPromise.reject(err)
+                        }, socket)
+                    }
+                }
+                socket.onmessage = (evt) => {
+                    this.handleSocketMesssage(evt, socket)
+                }
+                socket.onclose = (evt) => {
+                    this.handleSocketClose(evt, socket)
+                }
+                socket.onerror = (evt) => {
+                    if (!this._isCurrentSocket(socket)) {
+                        return
+                    }
+                    this.connectPromise.reject(evt)
+                    this.handleSocketError(evt, socket)
+                }
+            } else if (isUni()) {
+                socket = uni.connectSocket({
+                    url: this.data.connectUrl,
+                    method: 'GET',
+                    complete: () => {},
+                    fail: (err) => {
+                        this.data.connectMessage = err
+                        this.connectPromise.reject(err)
+                    }
+                })
+                this._ws = socket
+                socket.onOpen((evt) => {
+                    if (!this._isCurrentSocket(socket)) {
+                        return
+                    }
+                    this.data.connectStatus = CONNECT_STATUS.Success
+                    this.connectPromise.resolve(socket)
+                    this.handleSocketOpen(() => {
+                        this.readyPromise.resolve(socket)
+                    }, err => {
+                        this.readyPromise.reject(err)
+                    }, socket)
+                })
+                socket.onClose((evt) => {
+                    this.handleSocketClose(evt, socket)
+                })
+                socket.onError((err) => {
+                    if (!this._isCurrentSocket(socket)) {
+                        return
+                    }
+                    this.connectPromise.reject(err)
+                    this.handleSocketError(err, socket)
+                })
+                socket.onMessage((evt) => {
+                    this.handleSocketMesssage(evt, socket)
+                })
+            } else {
+                socket = new WebSocket(this.data.connectUrl)
+                this._ws = socket
+                socket.onopen = () => {
+                    if (!this._isCurrentSocket(socket)) {
+                        return
+                    }
+                    this.data.connectStatus = CONNECT_STATUS.Success
+                    this.connectPromise.resolve(socket)
+                    this.handleSocketOpen(() => {
+                        this.readyPromise.resolve(socket)
+                    }, (err) => {
+                        this.readyPromise.reject(err)
+                    }, socket)
+                }
+                socket.onmessage = (evt) => {
+                    this.handleSocketMesssage(evt, socket)
+                }
+                socket.onclose = (evt) => {
+                    this.handleSocketClose(evt, socket)
+                }
+                socket.onerror = (evt) => {
+                    if (!this._isCurrentSocket(socket)) {
+                        return
+                    }
+                    this.connectPromise.reject(evt)
+                    this.handleSocketError(evt, socket)
+                }
+            }
+            return Promise.all([
+                this.connectPromise,
+                this.readyPromise
+            ])
+        })
+        return ps
+    }
+    
+    handleSocketOpen (successFn, errorFn, socket) {
+        if (socket && !this._isCurrentSocket(socket)) {
+            return
+        }
+        let params = {
+            cmdType: "CmdSignIn",
+            throttle: true, // 开启节流，先请求的先生效，主要是sharedWorker里面放置CmdSignIn在多个页签时多次触发
+            throttleTime: 1000 * 5,
+            accountId: this.accountId,
+            accessToken: this.token,
+            client: this.client
+        }
+        this.logEnable && this.log.addLog({
+            group: 'socket:onopen',
+            content: {
+                title: 'socket连接中'
+            }
+        })
+        this.sendMessage(params).then(() => {
+            if (socket && !this._isCurrentSocket(socket)) {
+                return
+            }
+            this.logEnable && this.log.addLog({
+                group: 'socket:onopen',
+                content: {
+                    title: 'socket已连接'
+                }
+            })
+            this._startHeartbeat() // 注释掉，因为现在心跳的命令改了，用账号在线状态控制，减少命令发送频率
+            successFn && successFn()
+            this.event.emit('onOpen')
+        }, (err) => {
+            if (socket && !this._isCurrentSocket(socket)) {
+                return
+            }
+            errorFn && errorFn(err)
+        })
+    }
+    
+    handleSocketClose (evt, socket) {
+        // closePromise 必须在 _isCurrentSocket 检查之前处理，
+        // 避免 handleSocketError 先置空 _ws 导致 closePromise 永远不被 resolve
+        if (this.closePromise) {
+            this.closePromise.resolve()
+            this.closePromise = null
+        }
+        if (socket && !this._isCurrentSocket(socket)) {
+            return
+        }
+        const prevConnectStatus = this.connectStatus
+        this._ws = null
+        this.data.connectStatus = CONNECT_STATUS.Close
+        this.connectPromise = createPromise()
+        this.connectPromise.reject('socket连接已关闭')
+        this.connectPromise.catch(e => {})
+        // 同时拒绝 readyPromise，确保 connect() 的 Promise.all 能快速失败，触发 scheduleRetry
+        if (this.readyPromise && typeof this.readyPromise.reject === 'function') {
+            this.readyPromise.reject(new Error('socket连接关闭'))
+        }
+        this.logEnable && this.log.addLog({
+            group: 'socket:onclose',
+            content: {
+                title: 'socket连接关闭',
+                code: evt.code,
+                reason: evt.reason,
+            }
+        })
+        if (!evt.reason || evt.reason.indexOf('(手动关闭)') < 0) {
+            if (prevConnectStatus === CONNECT_STATUS.Connecting) {
+                return
+            }
+            this.reconnect()
+        }
+        this.event.emit('onClose', {
+            code: evt.code,
+            reason: evt.reason
+        })
+    }
+    
+    handleSocketError (evt, socket) {
+        if (socket && !this._isCurrentSocket(socket)) {
+            return
+        }
+        console.log(evt, 'WSERR');
+        this.logEnable && this.log.addLog({
+            group: 'socket:onclose',
+            content: {
+                title: 'socket连接失败'
+            }
+        })
+        this.data.connectStatus = CONNECT_STATUS.Error
+        this.connectPromise = createPromise()
+        this.connectPromise.reject('socket连接错误')
+        this.connectPromise.catch(e => {})
+        // 同时拒绝 readyPromise，确保 connect() 的 Promise.all 能快速失败
+        if (this.readyPromise && typeof this.readyPromise.reject === 'function') {
+            this.readyPromise.reject(new Error('socket连接错误'))
+        }
+        this.reconnect()
+    }
+    
+    mockSocketMessage (evt) {
+        this.handleSocketMesssage(evt)
+    }
+    
+    handleSocketMesssage (evt, socket) {
+        if (socket && !this._isCurrentSocket(socket)) {
+            return
+        }
+        const messageData = typeof evt.data === 'string' ? JSON.parse(evt.data) : evt.data
+        if (!messageData) {
+            return
+        }
+        if (this.messageCallbackMap[messageData.seq]) {
+            if (messageData.code === -1) {
+                this.messageCallbackMap[messageData.seq].reject({
+                    errMsg: messageData.extra
+                })
+            } else {
+                this.messageCallbackMap[messageData.seq].resolve({
+                    data: messageData.extra
+                })
+            }
+        }
+        this.logEnable && this.log.addLog({
+            group: 'socket:receiveMessage',
+            content: {
+                title: '收到消息',
+                message: messageData
+            }
+        })
+        this.event.emit('onReceiveMessage', {
+            data: messageData
+        })
+        // if (messageData && messageData.extra === 'pong') {
+        //   this._heartbeatCheck && this._heartbeatCheck.resolve()
+        //   return
+        // }
+        if (messageData.cmdType) {
+            const callbackName = 'on' + firstLetterUpperCase(messageData.cmdType)
+            this.event.emit(callbackName, {
+                data: messageData
+            })
+            this.callMessage({
+                cmdType: 'CommandResponse',
+                seq: messageData.seq,
+                result: 0,
+                extra: ''
+            })
+        }
+    }
+    
+    reconnect () {
+        // 防止并发重连调用（handleSocketError 和 handleSocketClose 都可能触发 reconnect）
+        if (this._isReconnecting) {
+            return this._reconnectPromise || Promise.resolve()
+        }
+        this._isReconnecting = true
+        
+        this._reconnectPromise = this.close({
+            code: 1000,
+            reason: '重连关闭连接'
+        }).finally(() => {
+            return new Promise((resolve, reject) => {
+                this._reconnectReject = reject
+                this.reconnectCount++
+                if (this.maxReconnectCount > 0 && this.reconnectCount > this.maxReconnectCount) {
+                    reject(this._handleReconnectLimitExceeded())
+                    return
+                }
+                const onConnectSuccess = () => {
+                    this.reconnectInterval = 1000
+                    this.reconnectCount = 0
+                    this._isReconnecting = false
+                    this._reconnectReject = null
+                    this._reconnectPromise = null
+                    resolve()
+                }
+                const scheduleRetry = () => {
+                    if (this.maxReconnectCount > 0 && this.reconnectCount >= this.maxReconnectCount) {
+                        reject(this._handleReconnectLimitExceeded())
+                        return
+                    }
+                    // 指数退避 + 随机抖动
+                    const jitter = Math.random() * 500 * 2 - 500
+                    const actualInterval = Math.min(this.reconnectInterval + jitter, this.maxReconnectInterval)
+                    // 先翻倍再等待，避免定时器被取消导致倍数丢失
+                    this.reconnectInterval = Math.min(this.reconnectInterval * 2, this.maxReconnectInterval)
+                    clearTimeout(this._reconnectTimer)
+                    this._reconnectTimer = setTimeout(() => {
+                        this.reconnectCount++
+                        this.connect().then(onConnectSuccess, scheduleRetry)
+                    }, actualInterval)
+                }
+                // 第一次的时候不延时，主要是外面发消息的时候手动重连，需要能加连接中的状态串起来，否则发送的消息直接失败
+                if (this.reconnectCount === 1) {
+                    this.connect().then(onConnectSuccess, scheduleRetry)
+                } else {
+                    scheduleRetry()
+                }
+            })
+        })
+        
+        return this._reconnectPromise
+    }
+    
+    /**
+     * 告诉服务器接收到了消息，没有callback回调逻辑
+    */
+    callMessage (message) {
+        const nextMessage = Object.assign({}, message)
+        if (!nextMessage.cmdType) {
+            throw new Error('发送消息缺少cmdType参数')
+        }
+        const messagePromise = createPromise()
+        if (isUni()) {
+            this.connectPromise.then(socket => {
+                socket.send({
+                    data: JSON.stringify(nextMessage), 
+                    success: () => {
+                        messagePromise.resolve()
+                    },
+                    fail: (err) => {
+                        messagePromise.reject(err)
+                    }
+                })
+            })
+        } else {
+            this.connectPromise.then(socket => {
+                try {
+                    socket.send(JSON.stringify(nextMessage))
+                    messagePromise.resolve()
+                } catch (err) {
+                    messagePromise.reject(err)
+                }
+            })
+        }
+        return messagePromise
+    }
+    
+    /**
+     * 向服务器会传消息，服务器不会返回回调消息，客户端发送消息-》服务端-》告诉客户端状态
+    */
+    sendMessage (message, beforeCallback) {
+        this.logEnable && this.log.addLog({
+            group: 'socket:sendMessage',
+            content: {
+                title: '发送消息',
+                message
+            }
+        })
+        const nextMessage = Object.assign({
+            seq: unique()
+        }, message)
+        if (!nextMessage.seq) {
+            throw new Error('发送消息缺少seq参数')
+        }
+        const messageId = nextMessage.seq
+        if (!nextMessage.cmdType) {
+            throw new Error('发送消息缺少cmdType参数')
+        }
+        const messagePromise = createPromise()
+        let ps = Promise.resolve()
+        if (this.onBeforeSendMessage) {
+            const rs = this.onBeforeSendMessage({
+                message
+            })
+            if (rs && rs.then) {
+                ps = rs
+            }
+        }
+        ps = ps.then(() => {
+            if (beforeCallback) {
+                // 主要是给client-chat-wechat新增临时消息时处理
+                return beforeCallback({
+                    message
+                })
+            }
+        })
+        ps.then(() => {
+            let callback = null
+            const onCallback = (fn) => {
+                if (callback) {
+                    throw new Error('[Socket]不允许重复设置callback')
+                }
+                callback = fn
+            }
+            this.event.emit('onSendMessage', {
+                data: nextMessage,
+                onCallback
+            })
+            const messageObject = {
+                messageId,
+                message: nextMessage,
+                resolve: (data) => {
+                    messagePromise.resolve(data)
+                    messageObject.destroy()
+                    callback && callback({
+                        data
+                    })
+                },
+                reject: (err) => {
+                    messagePromise.reject(err)
+                    messageObject.destroy()
+                    callback && callback({
+                        error: err
+                    })
+                },
+                destroy: () => {
+                    clearTimeout(messageObject._timeoutId)
+                    delete this.messageCallbackMap[messageId]
+                },
+                _timeoutId: setTimeout(() => {
+                    messageObject.reject('timeout')
+                }, 1000 * 30) // 30s认为超时
+            }
+            this.messageCallbackMap[messageId] = messageObject
+            if (isUni()) {
+                this.connectPromise.then(socket => {
+                    socket.send({
+                        data: JSON.stringify(nextMessage), 
+                        fail: (err) => {
+                            messagePromise.reject(err)
+                        }
+                    })
+                }, err => {
+                    messagePromise.reject(err)
+                })
+            } else {
+                this.connectPromise.then(socket => {
+                    try {
+                        socket.send(JSON.stringify(nextMessage))
+                    } catch (err) {
+                        messagePromise.reject(err)
+                    }
+                }, err => {
+                    messagePromise.reject(err)
+                })
+            }
+        }, messagePromise.reject)
+        return messagePromise
+    }
+    
+    close (options) {
+        options = Object.assign({
+            code: null,
+            reason: null
+        }, options)
+        if (this._heartbeatCheck) {
+            this._heartbeatCheck.destroy()
+        }
+        if (this.connectStatus === CONNECT_STATUS.Close || this.connectStatus === CONNECT_STATUS.Ready) {
+            return Promise.resolve()
+        }
+        if (!options.reason) {
+            options.reason = ''
+        }
+        options.reason = options.reason + '(手动关闭)' // 加一个手动关闭，后面close事件中判断一下，如果是手动关闭的不需要重连，如果是服务器关闭的，就需要重连，因为后端不知道为什么会主动关闭
+        // 直接使用 _ws 引用关闭 socket，避免 connectPromise 被替换后无法关闭旧连接
+        const socket = this._ws
+        if (!socket) {
+            this.data.connectStatus = CONNECT_STATUS.Close
+            return Promise.resolve()
+        }
+        return new Promise((resolve, reject) => {
+            if (isUni()) {
+                socket.close({
+                    reason: options.reason,
+                    code: options.code,
+                    success: () => {
+                        this.connectPromise = Promise.reject({
+                            errMsg: 'socket已关闭'
+                        })
+                        this.data.connectStatus = CONNECT_STATUS.Close
+                        resolve()
+                    },
+                    fail: (err) => {
+                        reject(err)
+                    }
+                })
+            } else {
+                this.closePromise = createPromise()
+                socket.close(options.code, options.reason)
+                this.closePromise.then(resolve, reject)
+            }
+        })
+    }
+    
+    disconnect () {
+        this.data.connectIpChange = false
+        for (let i in this.messageCallbackMap) {
+            this.messageCallbackMap[i].destroy()
+        }
+        this.reconnectInterval = 1000
+        this.reconnectCount = 0
+        this._isReconnecting = false
+        clearTimeout(this._reconnectTimer)
+        if (this._reconnectReject) {
+            this._reconnectPromise && this._reconnectPromise.catch(() => {})
+            this._reconnectReject(new Error('disconnect取消重连'))
+            this._reconnectReject = null
+            this._reconnectPromise = null
+        }
+        return this.close({
+            code: 1000,
+            reason: '断开连接'
+        })
+    }
+    
+    setUrl (url) {
+        this.url = url || ''
+    }
+
+    /**
+     * 手动触发一次心跳逻辑，主要是要快速检查微信号在线状态
+    */
+    doHeartbeat () {
+        this.readyPromise.then(() => {
+            this._startHeartbeat()
+        })
+    }
+
+    _startHeartbeat () {
+        this._heartbeatCheck && this._heartbeatCheck.destroy()
+        this._createHeartbeatCheck({
+            onDisconnect: () => {
+                // 心跳超时，就重连
+                console.log('心跳超时，开始重连')
+                this.reconnect()
+            }
+        })
+    }
+    _createHeartbeatCheck (options) {
+        // 合并配置，默认25s心跳（后端好像是30s，增加一些容差，防止因为网路或者其他原因导致断开连接了），5次熔断
+        options = Object.assign({
+            spanTime: 1000 * 25,
+            fusingNum: 5,
+            onDisconnect: null
+        }, options)
+
+        let rejectNum = 0
+        let intervalTimer = null // 改用setInterval，统一管理定时器
+        let isStop = false
+        let lastHeartbeatTime = Date.now() // 记录上次心跳发送时间，精准计时
+
+        // 检查熔断逻辑（抽离，便于复用）
+        const checkFusing = () => {
+            if (rejectNum > options.fusingNum) {
+                isStop = true
+                clearInterval(intervalTimer) // 停止定时器
+                options.onDisconnect && options.onDisconnect()
+                console.error(`连续${rejectNum}次心跳无响应，触发断开连接`)
+            }
+        }
+        // 核心：发送心跳的方法（抽离成独立函数，便于复用）
+        const sendCmdPing = (isFirst) => {
+            if (isStop) {
+                return
+            }
+            // 连接未成功，直接返回
+            if (this.connectStatus !== CONNECT_STATUS.Success) {
+                console.warn('WebSocket未连接成功，跳过本次心跳')
+                return
+            }
+            const params = {}
+            // 触发参数合并事件
+            this.event.emit('onHeartbeatCheck', {
+                mergeParams (nextParams) {
+                    Object.assign(params, nextParams)
+                }
+            })
+            // 发送心跳消息（完善catch异常捕获）
+            this.sendMessage(Object.assign({
+                wechatAccountIds: []
+            }, params, {
+                throttle: isFirst ? false : true, // 判断isFrist是因为shareworker里面会进行节流处理导致获取在线的微信号太慢了，所以第一次的时候不做节流，后面在开启节流，先请求的先生效，主要是sharedWorker里面放置CmdRequestWechatAccountsAliveStatus在多个页签时多次触发
+                throttleTime: options.spanTime,
+                cmdType: 'CmdRequestWechatAccountsAliveStatus'
+            })).then((evt) => {
+                // 心跳成功：重置计数 + 更新上次心跳时间
+                this.event.emit('onHeartbeatSuccess', evt)
+                rejectNum = 0
+                lastHeartbeatTime = Date.now() // 关键：更新成功时间
+                console.log(`心跳成功，重置熔断计数`)
+            }).catch((err) => {
+                // 心跳发送失败：累加计数，避免静默中断
+                console.error(`心跳发送失败：`, err)
+                ++rejectNum
+                checkFusing() // 立即检查是否熔断
+            })
+        }
+
+        // 心跳定时触发逻辑（核心：固定间隔检查，精准计时）
+        const heartbeatLoop = () => {
+            if (isStop) {
+                return
+            }
+            const now = Date.now()
+            // 计算实际间隔：当前时间 - 上次心跳时间
+            const actualSpan = now - lastHeartbeatTime
+            // 仅当实际间隔≥设定间隔时，才发送心跳（避免浏览器降频导致重复发送）
+            if (actualSpan >= options.spanTime - 1000) { // 预留1s误差
+                sendCmdPing(false) // 非首次，开启节流
+                // 发送后立即更新上次心跳时间（避免重复触发）
+                lastHeartbeatTime = Date.now()
+            }
+            // 检查熔断（无论是否发送心跳，都要检查）
+            checkFusing()
+        }
+        // 初始化：首次发送心跳（无节流）
+        sendCmdPing(true)
+        // 启动固定间隔定时器（1s检查一次，避免降频影响）
+        intervalTimer = setInterval(heartbeatLoop, 1000)
+
+        // 暴露销毁和重置方法（完善定时器清理）
+        this._heartbeatCheck = {
+            resolve: () => {
+                rejectNum = 0
+                lastHeartbeatTime = Date.now() // 重置计时
+            },
+            destroy: () => {
+                isStop = true
+                clearInterval(intervalTimer) // 清理interval
+                intervalTimer = null
+                this._heartbeatCheck = null
+                console.log('心跳检测已销毁')
+            }
+        }
+    }
+    
+    exportLogData () {
+        return this.log.exportLogData()
+    }
+    
+    clearLogData () {
+        return this.log.clearLogData()
+    }
+}