528 lines
15 KiB
JavaScript
528 lines
15 KiB
JavaScript
var requestLib = require('./request');
|
||
var wxTunnel = require('./wxTunnel');
|
||
|
||
/**
|
||
* 当前打开的信道，同一时间只能有一个信道打开
|
||
*/
|
||
var currentTunnel = null;
|
||
|
||
// 信道状态枚举
|
||
var STATUS_CLOSED = Tunnel.STATUS_CLOSED = 'CLOSED';
|
||
var STATUS_CONNECTING = Tunnel.STATUS_CONNECTING = 'CONNECTING';
|
||
var STATUS_ACTIVE = Tunnel.STATUS_ACTIVE = 'ACTIVE';
|
||
var STATUS_RECONNECTING = Tunnel.STATUS_RECONNECTING = 'RECONNECTING';
|
||
|
||
// 错误类型枚举
|
||
var ERR_CONNECT_SERVICE = Tunnel.ERR_CONNECT_SERVICE = 1001;
|
||
var ERR_CONNECT_SOCKET = Tunnel.ERR_CONNECT_SOCKET = 1002;
|
||
var ERR_RECONNECT = Tunnel.ERR_RECONNECT = 2001;
|
||
var ERR_SOCKET_ERROR = Tunnel.ERR_SOCKET_ERROR = 3001;
|
||
|
||
// 包类型枚举
|
||
var PACKET_TYPE_MESSAGE = 'message';
|
||
var PACKET_TYPE_PING = 'ping';
|
||
var PACKET_TYPE_PONG = 'pong';
|
||
var PACKET_TYPE_TIMEOUT = 'timeout';
|
||
var PACKET_TYPE_CLOSE = 'close';
|
||
|
||
// 断线重连最多尝试 5 次
|
||
var DEFAULT_MAX_RECONNECT_TRY_TIMES = 5;
|
||
|
||
// 每次重连前，等待时间的增量值
|
||
var DEFAULT_RECONNECT_TIME_INCREASE = 1000;
|
||
|
||
function Tunnel(serviceUrl) {
|
||
if (currentTunnel && currentTunnel.status !== STATUS_CLOSED) {
|
||
throw new Error('当前有未关闭的信道，请先关闭之前的信道，再打开新信道');
|
||
}
|
||
|
||
currentTunnel = this;
|
||
|
||
// 等确认微信小程序全面支持 ES6 就不用那么麻烦了
|
||
var me = this;
|
||
|
||
//=========================================================================
|
||
// 暴露实例状态以及方法
|
||
//=========================================================================
|
||
this.serviceUrl = serviceUrl;
|
||
this.socketUrl = null;
|
||
this.status = null;
|
||
|
||
this.open = openConnect;
|
||
this.on = registerEventHandler;
|
||
this.emit = emitMessagePacket;
|
||
this.close = close;
|
||
|
||
this.isClosed = isClosed;
|
||
this.isConnecting = isConnecting;
|
||
this.isActive = isActive;
|
||
this.isReconnecting = isReconnecting;
|
||
|
||
|
||
//=========================================================================
|
||
// 信道状态处理，状态说明：
|
||
// closed - 已关闭
|
||
// connecting - 首次连接
|
||
// active - 当前信道已经在工作
|
||
// reconnecting - 断线重连中
|
||
//=========================================================================
|
||
function isClosed() { return me.status === STATUS_CLOSED; }
|
||
function isConnecting() { return me.status === STATUS_CONNECTING; }
|
||
function isActive() { return me.status === STATUS_ACTIVE; }
|
||
function isReconnecting() { return me.status === STATUS_RECONNECTING; }
|
||
|
||
function setStatus(status) {
|
||
var lastStatus = me.status;
|
||
if (lastStatus !== status) {
|
||
me.status = status;
|
||
}
|
||
}
|
||
|
||
// 初始为关闭状态
|
||
setStatus(STATUS_CLOSED);
|
||
|
||
|
||
//=========================================================================
|
||
// 信道事件处理机制
|
||
// 信道事件包括：
|
||
// connect - 连接已建立
|
||
// close - 连接被关闭（包括主动关闭和被动关闭）
|
||
// reconnecting - 开始重连
|
||
// reconnect - 重连成功
|
||
// error - 发生错误，其中包括连接失败、重连失败、解包失败等等
|
||
// [message] - 信道服务器发送过来的其它事件类型，如果事件类型和上面内置的事件类型冲突，将在事件类型前面添加前缀 `@`
|
||
//=========================================================================
|
||
var preservedEventTypes = 'connect,close,reconnecting,reconnect,error'.split(',');
|
||
var eventHandlers = [];
|
||
|
||
/**
|
||
* 注册消息处理函数
|
||
* @param {string} messageType 支持内置消息类型（"connect"|"close"|"reconnecting"|"reconnect"|"error"）以及业务消息类型
|
||
*/
|
||
function registerEventHandler(eventType, eventHandler) {
|
||
if (typeof eventHandler === 'function') {
|
||
eventHandlers.push([eventType, eventHandler]);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 派发事件，通知所有处理函数进行处理
|
||
*/
|
||
function dispatchEvent(eventType, eventPayload) {
|
||
eventHandlers.forEach(function (handler) {
|
||
var handleType = handler[0];
|
||
var handleFn = handler[1];
|
||
|
||
if (handleType === '*') {
|
||
handleFn(eventType, eventPayload);
|
||
} else if (handleType === eventType) {
|
||
handleFn(eventPayload);
|
||
}
|
||
});
|
||
}
|
||
|
||
/**
|
||
* 派发事件，事件类型和系统保留冲突的，事件名会自动加上 '@' 前缀
|
||
*/
|
||
function dispatchEscapedEvent(eventType, eventPayload) {
|
||
if (preservedEventTypes.indexOf(eventType) > -1) {
|
||
eventType = '@' + eventType;
|
||
}
|
||
|
||
dispatchEvent(eventType, eventPayload);
|
||
}
|
||
|
||
|
||
//=========================================================================
|
||
// 信道连接控制
|
||
//=========================================================================
|
||
var isFirstConnection = true;
|
||
var isOpening = false;
|
||
|
||
/**
|
||
* 连接信道服务器，获取 WebSocket 连接地址，获取地址成功后，开始进行 WebSocket 连接
|
||
*/
|
||
function openConnect() {
|
||
if (isOpening) return;
|
||
isOpening = true;
|
||
|
||
// 只有关闭状态才会重新进入准备中
|
||
setStatus(isFirstConnection ? STATUS_CONNECTING : STATUS_RECONNECTING);
|
||
|
||
requestLib.request({
|
||
url: serviceUrl,
|
||
method: 'GET',
|
||
success: function (response) {
|
||
if (+response.statusCode === 200 && response.data && response.data.data.connectUrl) {
|
||
openSocket(me.socketUrl = response.data.data.connectUrl);
|
||
} else {
|
||
dispatchConnectServiceError(response);
|
||
}
|
||
},
|
||
fail: dispatchConnectServiceError,
|
||
complete: () => isOpening = false,
|
||
});
|
||
|
||
function dispatchConnectServiceError(detail) {
|
||
if (isFirstConnection) {
|
||
setStatus(STATUS_CLOSED);
|
||
|
||
dispatchEvent('error', {
|
||
code: ERR_CONNECT_SERVICE,
|
||
message: '连接信道服务失败，网络错误或者信道服务没有正确响应',
|
||
detail: detail || null,
|
||
});
|
||
|
||
} else {
|
||
startReconnect(detail);
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 打开 WebSocket 连接，打开后，注册微信的 Socket 处理方法
|
||
*/
|
||
function openSocket(url) {
|
||
wxTunnel.listen({
|
||
onOpen: handleSocketOpen,
|
||
onMessage: handleSocketMessage,
|
||
onClose: handleSocketClose,
|
||
onError: handleSocketError,
|
||
});
|
||
|
||
wx.connectSocket({ url: url });
|
||
isFirstConnection = false;
|
||
}
|
||
|
||
|
||
//=========================================================================
|
||
// 处理消息通讯
|
||
//
|
||
// packet - 数据包，序列化形式为 `${type}` 或者 `${type}:${content}`
|
||
// packet.type - 包类型，包括 message, ping, pong, close
|
||
// packet.content? - 当包类型为 message 的时候，会附带 message 数据
|
||
//
|
||
// message - 消息体，会使用 JSON 序列化后作为 packet.content
|
||
// message.type - 消息类型，表示业务消息类型
|
||
// message.content? - 消息实体，可以为任意类型，表示消息的附带数据，也可以为空
|
||
//
|
||
// 数据包示例：
|
||
// - 'ping' 表示 Ping 数据包
|
||
// - 'message:{"type":"speak","content":"hello"}' 表示一个打招呼的数据包
|
||
//=========================================================================
|
||
|
||
// 连接还没成功建立的时候，需要发送的包会先存放到队列里
|
||
var queuedPackets = [];
|
||
|
||
/**
|
||
* WebSocket 打开之后，更新状态，同时发送所有遗留的数据包
|
||
*/
|
||
function handleSocketOpen() {
|
||
/* istanbul ignore else */
|
||
if (isConnecting()) {
|
||
dispatchEvent('connect');
|
||
|
||
}
|
||
else if (isReconnecting()) {
|
||
dispatchEvent('reconnect');
|
||
resetReconnectionContext();
|
||
}
|
||
|
||
setStatus(STATUS_ACTIVE);
|
||
emitQueuedPackets();
|
||
nextPing();
|
||
}
|
||
|
||
/**
|
||
* 收到 WebSocket 数据包，交给处理函数
|
||
*/
|
||
function handleSocketMessage(message) {
|
||
resolvePacket(message.data);
|
||
}
|
||
|
||
/**
|
||
* 发送数据包，如果信道没有激活，将先存放队列
|
||
*/
|
||
function emitPacket(packet) {
|
||
if (isActive()) {
|
||
sendPacket(packet);
|
||
} else {
|
||
queuedPackets.push(packet);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 数据包推送到信道
|
||
*/
|
||
function sendPacket(packet) {
|
||
var encodedPacket = [packet.type];
|
||
|
||
if (packet.content) {
|
||
encodedPacket.push(JSON.stringify(packet.content));
|
||
}
|
||
|
||
wx.sendSocketMessage({
|
||
data: encodedPacket.join(':'),
|
||
fail: handleSocketError,
|
||
});
|
||
}
|
||
|
||
function emitQueuedPackets() {
|
||
queuedPackets.forEach(emitPacket);
|
||
|
||
// empty queued packets
|
||
queuedPackets.length = 0;
|
||
}
|
||
|
||
/**
|
||
* 发送消息包
|
||
*/
|
||
function emitMessagePacket(messageType, messageContent) {
|
||
var packet = {
|
||
type: PACKET_TYPE_MESSAGE,
|
||
content: {
|
||
type: messageType,
|
||
content: messageContent,
|
||
},
|
||
};
|
||
|
||
emitPacket(packet);
|
||
}
|
||
|
||
/**
|
||
* 发送 Ping 包
|
||
*/
|
||
function emitPingPacket() {
|
||
emitPacket({ type: PACKET_TYPE_PING });
|
||
}
|
||
|
||
/**
|
||
* 发送关闭包
|
||
*/
|
||
function emitClosePacket() {
|
||
emitPacket({ type: PACKET_TYPE_CLOSE });
|
||
}
|
||
|
||
/**
|
||
* 解析并处理从信道接收到的包
|
||
*/
|
||
function resolvePacket(raw) {
|
||
var packetParts = raw.split(':');
|
||
var packetType = packetParts.shift();
|
||
var packetContent = packetParts.join(':') || null;
|
||
var packet = { type: packetType };
|
||
|
||
if (packetContent) {
|
||
try {
|
||
packet.content = JSON.parse(packetContent);
|
||
} catch (e) {}
|
||
}
|
||
|
||
switch (packet.type) {
|
||
case PACKET_TYPE_MESSAGE:
|
||
handleMessagePacket(packet);
|
||
break;
|
||
case PACKET_TYPE_PONG:
|
||
handlePongPacket(packet);
|
||
break;
|
||
case PACKET_TYPE_TIMEOUT:
|
||
handleTimeoutPacket(packet);
|
||
break;
|
||
case PACKET_TYPE_CLOSE:
|
||
handleClosePacket(packet);
|
||
break;
|
||
default:
|
||
handleUnknownPacket(packet);
|
||
break;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 收到消息包，直接 dispatch 给处理函数
|
||
*/
|
||
function handleMessagePacket(packet) {
|
||
var message = packet.content;
|
||
dispatchEscapedEvent(message.type, message.content);
|
||
}
|
||
|
||
|
||
//=========================================================================
|
||
// 心跳、断开与重连处理
|
||
//=========================================================================
|
||
|
||
/**
|
||
* Ping-Pong 心跳检测超时控制，这个值有两个作用：
|
||
* 1. 表示收到服务器的 Pong 相应之后，过多久再发下一次 Ping
|
||
* 2. 如果 Ping 发送之后，超过这个时间还没收到 Pong，断开与服务器的连接
|
||
* 该值将在与信道服务器建立连接后被更新
|
||
*/
|
||
let pingPongTimeout = 15000;
|
||
let pingTimer = 0;
|
||
let pongTimer = 0;
|
||
|
||
/**
|
||
* 信道服务器返回 Ping-Pong 控制超时时间
|
||
*/
|
||
function handleTimeoutPacket(packet) {
|
||
var timeout = packet.content * 1000;
|
||
/* istanbul ignore else */
|
||
if (!isNaN(timeout)) {
|
||
pingPongTimeout = timeout;
|
||
ping();
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 收到服务器 Pong 响应，定时发送下一个 Ping
|
||
*/
|
||
function handlePongPacket(packet) {
|
||
nextPing();
|
||
}
|
||
|
||
/**
|
||
* 发送下一个 Ping 包
|
||
*/
|
||
function nextPing() {
|
||
clearTimeout(pingTimer);
|
||
clearTimeout(pongTimer);
|
||
pingTimer = setTimeout(ping, pingPongTimeout);
|
||
}
|
||
|
||
/**
|
||
* 发送 Ping，等待 Pong
|
||
*/
|
||
function ping() {
|
||
/* istanbul ignore else */
|
||
if (isActive()) {
|
||
emitPingPacket();
|
||
|
||
// 超时没有响应，关闭信道
|
||
pongTimer = setTimeout(handlePongTimeout, pingPongTimeout);
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Pong 超时没有响应，信道可能已经不可用，需要断开重连
|
||
*/
|
||
function handlePongTimeout() {
|
||
startReconnect('服务器已失去响应');
|
||
}
|
||
|
||
// 已经重连失败的次数
|
||
var reconnectTryTimes = 0;
|
||
|
||
// 最多允许失败次数
|
||
var maxReconnectTryTimes = Tunnel.MAX_RECONNECT_TRY_TIMES || DEFAULT_MAX_RECONNECT_TRY_TIMES;
|
||
|
||
// 重连前等待的时间
|
||
var waitBeforeReconnect = 0;
|
||
|
||
// 重连前等待时间增量
|
||
var reconnectTimeIncrease = Tunnel.RECONNECT_TIME_INCREASE || DEFAULT_RECONNECT_TIME_INCREASE;
|
||
|
||
var reconnectTimer = 0;
|
||
|
||
function startReconnect(lastError) {
|
||
if (reconnectTryTimes >= maxReconnectTryTimes) {
|
||
close();
|
||
|
||
dispatchEvent('error', {
|
||
code: ERR_RECONNECT,
|
||
message: '重连失败',
|
||
detail: lastError,
|
||
});
|
||
}
|
||
else {
|
||
wx.closeSocket();
|
||
waitBeforeReconnect += reconnectTimeIncrease;
|
||
setStatus(STATUS_RECONNECTING);
|
||
reconnectTimer = setTimeout(doReconnect, waitBeforeReconnect);
|
||
}
|
||
|
||
if (reconnectTryTimes === 0) {
|
||
dispatchEvent('reconnecting');
|
||
}
|
||
|
||
reconnectTryTimes += 1;
|
||
}
|
||
|
||
function doReconnect() {
|
||
openConnect();
|
||
}
|
||
|
||
function resetReconnectionContext() {
|
||
reconnectTryTimes = 0;
|
||
waitBeforeReconnect = 0;
|
||
}
|
||
|
||
/**
|
||
* 收到服务器的关闭请求
|
||
*/
|
||
function handleClosePacket(packet) {
|
||
close();
|
||
}
|
||
|
||
function handleUnknownPacket(packet) {
|
||
// throw away
|
||
}
|
||
|
||
var isClosing = false;
|
||
|
||
/**
|
||
* 收到 WebSocket 断开的消息，处理断开逻辑
|
||
*/
|
||
function handleSocketClose() {
|
||
/* istanbul ignore if */
|
||
if (isClosing) return;
|
||
|
||
/* istanbul ignore else */
|
||
if (isActive()) {
|
||
// 意外断开的情况，进行重连
|
||
startReconnect('链接已断开');
|
||
}
|
||
}
|
||
|
||
function close() {
|
||
isClosing = true;
|
||
closeSocket();
|
||
setStatus(STATUS_CLOSED);
|
||
resetReconnectionContext();
|
||
isFirstConnection = false;
|
||
clearTimeout(pingTimer);
|
||
clearTimeout(pongTimer);
|
||
clearTimeout(reconnectTimer);
|
||
dispatchEvent('close');
|
||
isClosing = false;
|
||
}
|
||
|
||
function closeSocket(emitClose) {
|
||
if (isActive() && emitClose !== false) {
|
||
emitClosePacket();
|
||
}
|
||
|
||
wx.closeSocket();
|
||
}
|
||
|
||
|
||
//=========================================================================
|
||
// 错误处理
|
||
//=========================================================================
|
||
|
||
/**
|
||
* 错误处理
|
||
*/
|
||
function handleSocketError(detail) {
|
||
switch (me.status) {
|
||
case Tunnel.STATUS_CONNECTING:
|
||
dispatchEvent('error', {
|
||
code: ERR_SOCKET_ERROR,
|
||
message: '连接信道失败，网络错误或者信道服务不可用',
|
||
detail: detail,
|
||
});
|
||
break;
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
module.exports = Tunnel; |