zsl-im-sdk 1.0.0 → 1.0.2

package/store.ts

@@ -1,692 +0,0 @@
-/**
- * IM 状态管理 Store
- * 使用 Vuex 管理会话、消息、用户、WebSocket 连接等状态
- */
-
-import Vue from "vue";
-import Vuex, { Store } from "vuex";
-import IM from "./websocket";
-import { MessageType } from "./types/message-type.type";
-import { IConversation } from "./types/conversation.type";
-
-Vue.use(Vuex);
-
-// ==================== 类型定义 ====================
-
-/** 消息类型 */
-export interface IMessage {
-  id: string;
-  conversationId: string;
-  content: string;
-  messageType: string;
-  senderId: string | number;
-  createdAt: string;
-  status: "SENDING" | "SENT" | "FAILED";
-  icon?: string;
-  recipientId?: string;
-  mediaUrl?: string;
-}
-
-/** 用户类型 */
-export interface IUser {
-  account: string;
-  avatarUrl?: string;
-  biz: string;
-  createdAt: string;
-  displayName: string;
-  id: string | number;
-  isDel: number;
-  status: string;
-  token: string;
-  updatedAt: string;
-}
-
-/** 根状态类型 */
-export interface IState {
-  // 会话状态
-  conversation: {
-    conversations: IConversation[];
-    selectedConversationId: string;
-  };
-  // 消息状态
-  message: {
-    messages: Record<string, IMessage[]>;
-    messageQueue: IMessage[];
-  };
-  // 用户状态
-  user: {
-    currentUser: IUser | null;
-    users: Record<string | number, IUser>;
-  };
-  // WebSocket 状态
-  websocket: {
-    isConnected: boolean;
-    reconnectAttempts: number;
-    imInstance: IM | null;
-  };
-  // 全局状态
-  global: {
-    loading: boolean;
-    error: string | null;
-  };
-}
-
-// ==================== Persistence ====================
-const STORAGE_KEY = 'ZSL_IM_STORE_STATE';
-
-const loadState = (): Partial<IState> => {
-    try {
-        const stateStr = uni.getStorageSync(STORAGE_KEY);
-        if (stateStr) {
-            return JSON.parse(stateStr);
-        }
-    } catch (e) {
-        console.error('Load state error:', e);
-    }
-    return {};
-};
-
-const saveState = (state: IState) => {
-    const persistState = {
-        conversation: state.conversation,
-        message: state.message,
-        user: state.user
-    };
-    try {
-        uni.setStorageSync(STORAGE_KEY, JSON.stringify(persistState));
-    } catch (e) {
-        console.error('Save state error:', e);
-    }
-};
-
-const persistencePlugin = (store: Store<IState>) => {
-    store.subscribe((mutation, state) => {
-        if (mutation.type.startsWith('conversation/') || 
-            mutation.type.startsWith('message/') || 
-            mutation.type.startsWith('user/')) {
-            saveState(state);
-        }
-    });
-};
-
-// ==================== Vuex Store ====================
-
-const savedState = loadState();
-
-const store = new Vuex.Store<IState>({
-  state: {
-    conversation: {
-      conversations: [],
-      selectedConversationId: "",
-      ...(savedState.conversation || {})
-    },
-    message: {
-      messages: {},
-      messageQueue: [],
-      ...(savedState.message || {})
-    },
-    user: {
-      currentUser: null,
-      users: {},
-      ...(savedState.user || {})
-    },
-    websocket: {
-      isConnected: false,
-      reconnectAttempts: 0,
-      imInstance: null,
-    },
-    global: {
-      loading: false,
-      error: null,
-    },
-  },
-  plugins: [persistencePlugin],
-
-  // ==================== Mutations ====================
-  mutations: {
-    // ---------- 会话相关 ----------
-    /** 设置会话列表 */
-    "conversation/SET_CONVERSATIONS"(state, conversations: IConversation[]) {
-      state.conversation.conversations = conversations;
-    },
-
-    /** 添加或更新会话 */
-    "conversation/ADD_CONVERSATION"(state, conversation: IConversation) {
-      const index = state.conversation.conversations.findIndex(
-        (c) => c.conversationId === conversation.conversationId,
-      );
-      if (index === -1) {
-        state.conversation.conversations.unshift(conversation);
-      } else {
-        state.conversation.conversations.splice(index, 1, conversation);
-        state.conversation.conversations.unshift(
-          state.conversation.conversations.splice(index, 1)[0],
-        );
-      }
-    },
-
-    /** 更新会话信息 */
-    "conversation/UPDATE_CONVERSATION"(
-      state,
-      {
-        conversationId,
-        updates,
-      }: { conversationId: string; updates: Partial<IConversation> },
-    ) {
-      const conversation = state.conversation.conversations.find(
-        (c) => c.conversationId === conversationId,
-      );
-      if (conversation) Object.assign(conversation, updates);
-    },
-
-    /** 删除会话 */
-    "conversation/DELETE_CONVERSATION"(state, conversationId: string) {
-      state.conversation.conversations =
-        state.conversation.conversations.filter(
-          (c) => c.conversationId !== conversationId,
-        );
-      if (state.conversation.selectedConversationId === conversationId) {
-        state.conversation.selectedConversationId = "";
-      }
-    },
-
-    /** 设置当前选中的会话 */
-    "conversation/SET_SELECTED_CONVERSATION"(state, conversationId: string) {
-      state.conversation.selectedConversationId = conversationId;
-    },
-
-    /** 重置会话状态 */
-    "conversation/RESET_STATE"(state) {
-      state.conversation.conversations = [];
-      state.conversation.selectedConversationId = "";
-    },
-
-    // ---------- 消息相关 ----------
-    /** 设置指定会话的消息列表 */
-    "message/SET_MESSAGES"(
-      state,
-      {
-        conversationId,
-        messages,
-      }: { conversationId: string; messages: IMessage[] },
-    ) {
-      state.message.messages[conversationId] = messages;
-    },
-
-    /** 添加消息 */
-    "message/ADD_MESSAGE"(state, message: IMessage) {
-      if (!state.message.messages[message.conversationId]) {
-        state.message.messages[message.conversationId] = [];
-      }
-      state.message.messages[message.conversationId].push(message);
-    },
-
-    /** 更新消息 */
-    "message/UPDATE_MESSAGE"(
-      state,
-      {
-        messageId,
-        conversationId,
-        updates,
-      }: {
-        messageId: string | number;
-        conversationId: string;
-        updates: Partial<IMessage>;
-      },
-    ) {
-      const messages = state.message.messages[conversationId];
-      if (messages) {
-        const message = messages.find((m) => m.id === messageId);
-        if (message) Object.assign(message, updates);
-      }
-    },
-
-    /** 添加到消息队列 */
-    "message/ADD_TO_MESSAGE_QUEUE"(state, message: IMessage) {
-      state.message.messageQueue.push(message);
-    },
-
-    /** 从消息队列移除 */
-    "message/REMOVE_FROM_MESSAGE_QUEUE"(state, messageId: string | number) {
-      state.message.messageQueue = state.message.messageQueue.filter(
-        (m) => m.id !== messageId,
-      );
-    },
-
-    /** 重置消息状态 */
-    "message/RESET_STATE"(state) {
-      state.message.messages = {};
-      state.message.messageQueue = [];
-    },
-
-    // ---------- 用户相关 ----------
-    /** 设置当前用户 */
-    "user/SET_CURRENT_USER"(state, user: IUser) {
-      state.user.currentUser = user;
-    },
-
-    /** 添加用户 */
-    "user/ADD_USER"(state, user: IUser) {
-      state.user.users[user.id] = user;
-    },
-
-    /** 更新用户信息 */
-    "user/UPDATE_USER"(
-      state,
-      { userId, updates }: { userId: string | number; updates: Partial<IUser> },
-    ) {
-      if (state.user.users[userId]) {
-        Object.assign(state.user.users[userId], updates);
-      }
-    },
-
-    /** 重置用户状态 */
-    "user/RESET_STATE"(state) {
-      state.user.currentUser = null;
-      state.user.users = {};
-    },
-
-    // ---------- WebSocket 相关 ----------
-    /** 设置连接状态 */
-    "websocket/SET_CONNECTED"(state, isConnected: boolean) {
-      console.log("WebSocket 连接状态:", isConnected);
-      state.websocket.isConnected = isConnected;
-      if (isConnected) state.websocket.reconnectAttempts = 0;
-    },
-
-    /** 增加重连次数 */
-    "websocket/INCREMENT_RECONNECT_ATTEMPTS"(state) {
-      state.websocket.reconnectAttempts++;
-    },
-
-    /** 设置 IM 实例 */
-    "websocket/SET_IM_INSTANCE"(state, imInstance: IM) {
-      state.websocket.imInstance = imInstance;
-    },
-
-    /** 重置 WebSocket 状态 */
-    "websocket/RESET_STATE"(state) {
-      if (state.websocket.imInstance) {
-        state.websocket.imInstance.disconnect();
-        state.websocket.imInstance = null;
-      }
-      state.websocket.isConnected = false;
-      state.websocket.reconnectAttempts = 0;
-    },
-
-    // ---------- 全局状态 ----------
-    /** 设置加载状态 */
-    "global/SET_LOADING"(state, loading: boolean) {
-      state.global.loading = loading;
-    },
-
-    /** 设置错误信息 */
-    "global/SET_ERROR"(state, error: string | null) {
-      state.global.error = error;
-    },
-
-    /** 重置全局状态 */
-    "global/RESET_STATE"(state) {
-      state.global.loading = false;
-      state.global.error = null;
-    },
-  },
-
-  // ==================== Actions ====================
-  actions: {
-    /** 重置所有状态 */
-    resetState({ commit }) {
-      commit("conversation/RESET_STATE");
-      commit("message/RESET_STATE");
-      commit("user/RESET_STATE");
-      commit("websocket/RESET_STATE");
-      commit("global/RESET_STATE");
-    },
-
-    /** 连接 WebSocket */
-    async connectWebSocket(
-      { commit, state, dispatch },
-      payload?: { wsUrl: string; token: string; userId: string | number },
-    ) {
-      if (!payload) throw new Error("WebSocket 连接参数缺失");
-
-      const { wsUrl, token, userId } = payload;
-
-      // 如果已存在实例，先断开
-      if (state.websocket.imInstance) {
-        state.websocket.imInstance.disconnect();
-        commit("websocket/SET_IM_INSTANCE", null);
-      }
-
-      // 创建新实例
-      const imInstance = new IM({ url: wsUrl, token, userId });
-
-      // 设置事件监听
-      imInstance.on("connect", () => commit("websocket/SET_CONNECTED", true));
-      imInstance.on("disconnect", () => {
-        commit("websocket/SET_CONNECTED", false);
-        commit("websocket/INCREMENT_RECONNECT_ATTEMPTS");
-      });
-      imInstance.on("error", (error) =>
-        console.error("WebSocket 错误:", error),
-      );
-      imInstance.on("message", (message) =>
-        dispatch("handleWebSocketMessage", message),
-      );
-	  // 撤回消息
-      imInstance.on("recalled", (message) =>
-        dispatch("handleWebSocketRecalledMessage", message),
-      );
-      imInstance.on("reconnect", (attempt) =>
-        console.log(`WebSocket 重连中，第 ${attempt} 次尝试`),
-      );
-
-      commit("websocket/SET_IM_INSTANCE", imInstance);
-
-      try {
-        await imInstance.connect();
-      } catch (error) {
-        console.error("WebSocket 连接失败:", error);
-        commit("websocket/SET_CONNECTED", false);
-        throw error;
-      }
-    },
-
-    /** 断开 WebSocket */
-    disconnectWebSocket({ commit, state }) {
-      if (state.websocket.imInstance) {
-        state.websocket.imInstance.disconnect();
-        commit("websocket/SET_IM_INSTANCE", null);
-      }
-      commit("websocket/SET_CONNECTED", false);
-    },
-
-    /** 处理 WebSocket 消息 */
-    async handleWebSocketMessage({ commit, state, dispatch }, message: any) {
-      try {
-        console.log("收到 WebSocket 消息:", message);
-
-        if (!message.conversationId) {
-          console.error("消息缺少 conversationId:", message);
-          return;
-        }
-
-        // 添加消息
-        commit("message/ADD_MESSAGE", message);
-
-        // 更新会话
-        const conversation = state.conversation.conversations.find(
-          (c) => c.conversationId === message.conversationId,
-        );
-        if (conversation) {
-          const updates: any = {
-            lastMessageId: message.id,
-            lastMessageContent: message.content,
-            lastMessageAt: message.createdAt,
-            lastMessageType: message.messageType,
-          };
-
-          // 判断是否是当前打开的会话
-          const isCurrentConversation =
-            message.conversationId ===
-            state.conversation.selectedConversationId;
-
-          if (isCurrentConversation) {
-            // 如果是当前会话，自动发送已读回执
-            try {
-              await dispatch("sendReadReceipt", {
-                conversationId: message.conversationId,
-                lastReadMessageId: message.id,
-              });
-              console.log("已自动发送已读回执:", message.id);
-            } catch (error) {
-              console.error("发送已读回执失败:", error);
-            }
-          } else {
-            // 如果不是当前会话，增加未读数
-            updates.unreadCount = (conversation.unreadCount || 0) + 1;
-          }
-
-          commit("conversation/UPDATE_CONVERSATION", {
-            conversationId: message.conversationId,
-            updates,
-          });
-        }
-      } catch (error) {
-        console.error("处理 WebSocket 消息时出错:", error);
-      }
-    },
-
-
-	/** 处理 WebSocket 收到撤回消息 */
-	async handleWebSocketRecalledMessage({ commit, state, dispatch }, message: any) {
-	  try {
-	    console.log("收到 WebSocket 撤回消息:", message);
-	
-	    if (!message.conversationId) {
-	      console.error("消息缺少 conversationId:", message);
-	      return;
-	    }
-	
-	    // 更新消息状态为撤回
-	    const recalledMsgId = message.id; // 假设撤回消息的内容是原消息ID
-	    commit("message/UPDATE_MESSAGE", {
-	      messageId: recalledMsgId,
-	      conversationId: message.conversationId,
-	      updates: { status: "RECALLED" },
-	    });
-	
-	    // 更新会话最后一条消息（如果是被撤回的那条）
-	    const conversation = state.conversation.conversations.find(
-	      (c) => c.conversationId === message.conversationId,
-	    );
-	    if (conversation && conversation.lastMessageId === recalledMsgId) {
-	      const updates: any = {
-	        lastMessageContent: "对方撤回了一条消息", // 或者 "你撤回了一条消息"
-	        lastMessageType: "RECALLED",
-	      };
-	      commit("conversation/UPDATE_CONVERSATION", {
-	        conversationId: message.conversationId,
-	        updates,
-	      });
-	    }
-	  } catch (error) {
-	    console.error("处理 WebSocket 撤回消息时出错:", error);
-	  }
-	},
-	
-
-    /** 发送消息 */
-    async sendMessage(
-      { commit, state },
-      messageData: Omit<IMessage, "id" | "createdAt" | "status">,
-    ) {
-      const newMessage: IMessage = {
-        ...messageData,
-        id: `temp-${Date.now()}`,
-        createdAt: new Date().toISOString(),
-        status: "SENDING",
-      };
-
-      // 添加到队列
-      commit("message/ADD_TO_MESSAGE_QUEUE", newMessage);
-
-      // 更新会话
-      const conversation = state.conversation.conversations.find(
-        (c) => c.conversationId === newMessage.conversationId,
-      );
-      if (conversation) {
-        commit("conversation/UPDATE_CONVERSATION", {
-          conversationId: newMessage.conversationId,
-          updates: {
-            lastMessageId: newMessage.id,
-            lastMessageContent: newMessage.content,
-            lastMessageAt: newMessage.createdAt,
-            lastMessageType: newMessage.messageType as MessageType,
-          },
-        });
-      } else {
-        // 创建新会话
-        commit("conversation/ADD_CONVERSATION", {
-          conversationId: newMessage.conversationId,
-          conversationType: newMessage.conversationId.includes("p2p")
-            ? "P2P"
-            : "GROUP",
-          isMuted: false,
-          isPinned: false,
-          lastMessageAt: newMessage.createdAt,
-          lastMessageContent: newMessage.content,
-          unreadCount: 1,
-          user: {
-            userId: newMessage.senderId,
-            displayName: "用户：" + newMessage.senderId,
-            account: newMessage.senderId as string,
-            avatarUrl: newMessage.icon || "/static/images/default-avatar.png",
-          },
-          lastMessageType: newMessage.messageType as MessageType,
-          lastMessageSenderId: newMessage.senderId,
-          lastMessageSenderName: newMessage.senderId as string,
-          status: 0,
-          recalled: false,
-          recaller: { id: "", name: "" },
-          payload: { text: newMessage.content || "" },
-          lastMessageId: newMessage.id,
-        });
-      }
-
-      try {
-        // 发送消息
-        if (!state.websocket.imInstance) throw new Error("WebSocket 未连接");
-
-        await state.websocket.imInstance.sendText(
-          newMessage.conversationId,
-          newMessage.recipientId!,
-          newMessage.content,
-          newMessage.messageType as MessageType,
-          newMessage.mediaUrl,
-        );
-
-        // 更新状态
-        commit("message/UPDATE_MESSAGE", {
-          messageId: newMessage.id,
-          conversationId: newMessage.conversationId,
-          updates: { status: "SENT" },
-        });
-        commit("message/REMOVE_FROM_MESSAGE_QUEUE", newMessage.id);
-      } catch (error) {
-        commit("message/UPDATE_MESSAGE", {
-          messageId: newMessage.id,
-          conversationId: newMessage.conversationId,
-          updates: { status: "FAILED" },
-        });
-        commit("global/SET_ERROR", "发送消息失败");
-        console.error("发送消息失败:", error);
-        throw error;
-      }
-    },
-
-    /** 发送已读回执 */
-    async sendReadReceipt(
-      { state },
-      payload: { conversationId: string; lastReadMessageId?: number },
-    ) {
-      if (!state.websocket.imInstance) throw new Error("WebSocket 未连接");
-      return state.websocket.imInstance.sendReadReceipt(
-        payload.conversationId,
-        payload.lastReadMessageId,
-      );
-    },
-
-    /** 撤回消息 */
-    async sendRecallMessage({ state }, payload: { messageId: number }) {
-      if (!state.websocket.imInstance) throw new Error("WebSocket 未连接");
-      return state.websocket.imInstance.sendRecallMessage(payload.messageId);
-    },
-
-    /**
-     * 用户登录
-     * 注意：SDK 不包含登录 API，需要在应用层实现
-     * 登录成功后调用 connectWebSocket 连接 WebSocket
-     */
-    async login(
-      { commit, dispatch },
-      loginParams: { user: IUser; wsUrl: string; token: string },
-    ) {
-      commit("global/SET_LOADING", true);
-
-      console.log("=====login====", loginParams);
-
-      try {
-        const { user, wsUrl, token } = loginParams;
-        commit("user/SET_CURRENT_USER", user);
-        commit("user/ADD_USER", user);
-        await dispatch("connectWebSocket", { userId: user.id, wsUrl, token });
-        return user;
-      } catch (error) {
-        commit("global/SET_ERROR", "登录失败");
-        console.error("登录失败:", error);
-        throw error;
-      } finally {
-        commit("global/SET_LOADING", false);
-      }
-    },
-
-    /** 用户登出 */
-    logout({ dispatch }) {
-      dispatch("disconnectWebSocket");
-      dispatch("resetState");
-    },
-  },
-
-  // ==================== Getters ====================
-  getters: {
-    /** 排序后的会话列表 */
-    sortedConversations: (state) =>
-      [...state.conversation.conversations].sort(
-        (a, b) =>
-          new Date(b.lastMessageAt).getTime() -
-          new Date(a.lastMessageAt).getTime(),
-      ),
-
-    /** 当前选中的会话 */
-    selectedConversation: (state) =>
-      state.conversation.conversations.find(
-        (c) => c.conversationId === state.conversation.selectedConversationId,
-      ),
-
-    /** 获取指定会话的消息列表 */
-    conversationMessages: (state) => (conversationId: string) =>
-      state.message.messages[conversationId] || [],
-
-    /** 总未读消息数 */
-    unreadCount: (state) =>
-      state.conversation.conversations.reduce(
-        (total, c) => total + c.unreadCount,
-        0,
-      ),
-
-    /** 获取用户信息 */
-    userInfo: (state) => (userId: string | number) =>
-      state.user.users[userId] || null,
-
-    /** WebSocket 连接状态 */
-    isConnected: (state) => state.websocket.isConnected,
-
-    /** 加载状态 */
-    loading: (state) => state.global.loading,
-
-    /** 错误信息 */
-    error: (state) => state.global.error,
-  },
-});
-
-// ==================== 插件安装 ====================
-
-/** Vue 插件安装函数 */
-export function install(vue: any) {
-  if (vue.prototype) {
-    vue.prototype.$store = store;
-  }
-}
-
-export default store;