zsl-im-sdk 1.0.0

package/websocket.ts

@@ -0,0 +1,367 @@
+// 从types目录导入所有类型定义
+export * from "./types";
+import {
+  MessageType,
+  MessageStatus,
+  SocketAction,
+  SocketData,
+  ISendMessage,
+  IMessage,
+  IReadReceipt,
+  IRecalledMessage,
+} from "./types/index";
+
+// 事件类型
+export type EventType =
+  | "message"
+  | "connect"
+  | "disconnect"
+  | "error"
+  | "reconnect"
+  | "recalled";
+
+// 事件回调类型
+export type EventCallback<T = any> = (data: T) => void;
+
+// 配置选项接口
+export interface IMOptions {
+  url: string;
+  token: string;
+  userId: string | number;
+  maxReconnectCount?: number;
+  reconnectInterval?: number;
+  heartbeatInterval?: number;
+}
+
+// 消息队列项接口
+interface MessageQueueItem {
+  data: SocketData;
+  resolve: () => void;
+  reject: (error: any) => void;
+}
+
+// WebSocket实例类型，使用any类型兼容uni-app的SocketTask
+export default class IM {
+  private ws: any | null = null;
+  private url: string;
+  private token: string;
+  private userId: string | number;
+  private isConnected: boolean = false;
+
+  private reconnectTimer: ReturnType<typeof setTimeout> | null = null;
+  private reconnectCount: number = 0;
+  private maxReconnectCount: number;
+  private reconnectInterval: number;
+  private messageQueue: MessageQueueItem[] = [];
+  private listeners: Record<EventType, EventCallback[]> = {
+    message: [],
+    connect: [],
+    disconnect: [],
+    error: [],
+    reconnect: [],
+    recalled: [],
+  };
+
+  // 心跳相关
+  private heartbeatTimer: ReturnType<typeof setTimeout> | null = null;
+  private heartbeatInterval: number;
+
+  constructor(options: IMOptions) {
+    this.url = options.url;
+    this.token = options.token;
+    this.userId = options.userId;
+    this.maxReconnectCount = options.maxReconnectCount || 5;
+    this.reconnectInterval = options.reconnectInterval || 3000;
+    this.heartbeatInterval = options.heartbeatInterval || 30000;
+  }
+
+  // 获取完整的WebSocket连接URL
+  private getWsUrl(): string {
+    return `${this.url}?userId=${this.userId}`;
+  }
+
+  // 连接websocket
+  public connect(): Promise<void> {
+    return new Promise((resolve, reject) => {
+      try {
+        this.ws = uni.connectSocket({
+          url: this.getWsUrl(),
+          header: {
+            token: this.token,
+          },
+          success: () => {
+            console.log("WebSocket连接请求已发送");
+          },
+          fail: (err) => {
+            console.error("WebSocket连接失败", err);
+            reject(err);
+          },
+        });
+
+        this.ws.onOpen(() => {
+          console.log("WebSocket连接已打开");
+          this.isConnected = true;
+          this.reconnectCount = 0;
+          this.flushMessageQueue();
+          this.startHeartbeat();
+          this.emit("connect");
+          resolve();
+        });
+
+        this.ws.onMessage((res: { data: string }) => {
+          try {
+            const data = JSON.parse(res.data) as SocketData;
+            this.handleMessage(data);
+          } catch (err: any) {
+            console.error("解析WebSocket消息失败", err);
+            this.emit("error", err);
+          }
+        });
+
+        this.ws.onClose(() => {
+          console.log("WebSocket连接已关闭");
+          this.isConnected = false;
+          this.stopHeartbeat();
+          this.emit("disconnect");
+          this.handleReconnect();
+        });
+
+        this.ws.onError((err: any) => {
+          console.error("WebSocket错误", err);
+          this.isConnected = false;
+          this.stopHeartbeat();
+          this.emit("error", err);
+        });
+      } catch (err) {
+        console.error("WebSocket连接异常", err);
+        reject(err);
+      }
+    });
+  }
+
+  // 断开连接
+  public disconnect(): void {
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+    this.isConnected = false;
+    this.stopHeartbeat();
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+  }
+
+  // 重连机制
+  private handleReconnect(): void {
+    if (this.reconnectCount < this.maxReconnectCount) {
+      this.reconnectCount++;
+      console.log(`正在尝试第${this.reconnectCount}次重连...`);
+      this.reconnectTimer = setTimeout(() => {
+        this.emit("reconnect", this.reconnectCount);
+        this.connect();
+      }, this.reconnectInterval);
+    } else {
+      console.error("重连次数已达上限，停止重连");
+    }
+  }
+
+  // 处理收到的消息
+  private handleMessage(data: SocketData): void {
+    const { action, payload } = data;
+
+    // 处理心跳消息
+    if (action === SocketAction.PING) {
+      this.sendPingPong(SocketAction.PONG);
+      return;
+    }
+
+    // 处理新消息
+    // DELIVERED - 已送达
+    // MESSAGE - 收到其他人的消息
+    if (action === SocketAction.MESSAGE || action === SocketAction.DELIVERED) {
+      const payloadData = payload as ISendMessage;
+      const message: IMessage = {
+        id: payloadData.id || Date.now(),
+        conversationId: payloadData.conversationId || "",
+        senderId: payloadData.senderId || "",
+        recipientId: payloadData.recipientId,
+        messageType: payloadData.messageType,
+        content: payloadData.content || "",
+        mediaUrl: payloadData.mediaUrl || "",
+        metadata: payloadData.metadata || "",
+        createdAt: payloadData.time || this.getCurrentTime(),
+        status: MessageStatus.SENT,
+      };
+      this.emit("message", message);
+    }
+
+    // 处理消息撤回
+    if (action === SocketAction.RECALLED) {
+      console.log("========SocketAction.RECALLED==", payload);
+      this.emit("recalled", payload);
+    }
+
+    // 处理错误消息
+    if (action === SocketAction.ERROR) {
+      this.emit("error", payload);
+    }
+  }
+
+  // 发送消息
+  public send(data: SocketData): Promise<void> {
+    return new Promise((resolve, reject) => {
+      if (this.isConnected && this.ws) {
+        try {
+          const message = JSON.stringify(data);
+          this.ws.send({
+            data: message,
+            success: () => {
+              console.log("消息发送成功", data);
+              resolve();
+            },
+            fail: (err: any) => {
+              console.error("消息发送失败", err);
+              reject(err);
+            },
+          });
+        } catch (err: any) {
+          console.error("消息发送异常", err);
+          reject(err);
+        }
+      } else {
+        console.log("WebSocket未连接，将消息加入队列");
+        this.messageQueue.push({ data, resolve, reject });
+      }
+    });
+  }
+
+  // 发送文本消息
+  public sendText(
+    conversationId: string,
+    recipientId: string | number,
+    content: string,
+    messageType: MessageType = MessageType.TEXT,
+    mediaUrl: string | undefined,
+  ): Promise<void> {
+    const payload: ISendMessage = {
+      conversationId: conversationId,
+      senderId: this.userId,
+      recipientId: recipientId,
+      messageType: messageType,
+      content: content,
+      mediaUrl,
+      time: this.getCurrentTime(),
+    };
+
+    return this.send({
+      action: SocketAction.SEND_MESSAGE,
+      payload: payload,
+    });
+  }
+
+  // 发送已读回执
+  public sendReadReceipt(
+    conversationId: string,
+    lastReadMessageId?: number,
+  ): Promise<void> {
+    const payload: IReadReceipt = {
+      conversationId: conversationId,
+      lastReadMessageId: lastReadMessageId,
+    };
+
+    return this.send({
+      action: SocketAction.READ_RECEIPT,
+      payload: payload,
+    });
+  }
+
+  // 发送消息撤回
+  public sendRecallMessage(messageId: number): Promise<void> {
+    const payload: IRecalledMessage = {
+      messageId,
+    };
+
+    return this.send({
+      action: SocketAction.RECALL_MESSAGE,
+      payload: payload,
+    });
+  }
+
+  // 发送心跳消息
+  private sendPingPong(action: SocketAction): Promise<void> {
+    return this.send({
+      action: action,
+      payload: {},
+    });
+  }
+
+  // 开始心跳
+  private startHeartbeat(): void {
+    this.stopHeartbeat();
+    this.heartbeatTimer = setInterval(() => {
+      if (this.isConnected) {
+        this.sendPingPong(SocketAction.PING);
+      }
+    }, this.heartbeatInterval);
+  }
+
+  // 停止心跳
+  private stopHeartbeat(): void {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+  }
+
+  // 刷新消息队列
+  private flushMessageQueue(): void {
+    if (this.isConnected && this.ws && this.messageQueue.length > 0) {
+      const queue = [...this.messageQueue];
+      this.messageQueue = [];
+      queue.forEach((item) => {
+        this.send(item.data).then(item.resolve).catch(item.reject);
+      });
+    }
+  }
+
+  // 获取当前时间 (ISO格式)
+  private getCurrentTime(): string {
+    return new Date().toISOString();
+  }
+
+  // 事件监听
+  public on<T = any>(event: EventType, callback: EventCallback<T>): void {
+    if (this.listeners[event]) {
+      this.listeners[event].push(callback as EventCallback);
+    }
+  }
+
+  // 移除事件监听
+  public off<T = any>(event: EventType, callback: EventCallback<T>): void {
+    if (this.listeners[event]) {
+      this.listeners[event] = this.listeners[event].filter(
+        (cb) => cb !== callback,
+      );
+    }
+  }
+
+  // 触发事件
+  private emit<T = any>(event: EventType, data?: T): void {
+    if (this.listeners[event]) {
+      this.listeners[event].forEach((callback) => {
+        try {
+          callback(data as any);
+        } catch (err) {
+          console.error(`事件${event}回调执行失败`, err);
+        }
+      });
+    }
+  }
+
+  // 获取连接状态
+  public getConnectionStatus(): boolean {
+    return this.isConnected;
+  }
+}