juggleim-rnsdk/src/index.js

React Native wrapper for Juggle IM SDK

import { NativeModules, Platform, NativeEventEmitter } from "react-native";

const { JuggleIM: JMI } = NativeModules;
// 为避免警告，仅在Android平台传入JMI参数
const juggleIMEmitter = Platform.OS === 'android' ? new NativeEventEmitter(JMI) : new NativeEventEmitter();

/**
 * Juggle IM React Native SDK
 * @class JuggleIM
 */
class JuggleIM {
  /**
   * 设置服务器地址列表
   * @param {string[]} urls - 服务器地址列表
   * @returns {void}
   */
  static setServerUrls(urls) {
    JMI.setServerUrls(urls);
  }

  /**
   * 初始化SDK
   * @param {string} appKey - 应用唯一标识
   * @returns {void}
   */
  static init(appKey) {
    if (Platform.OS === "android") {
      JMI.init(appKey);
    } else if (Platform.OS === "ios") {
      JMI.initWithAppKey(appKey);
    }
  }

  /**
   * 连接到服务器
   * @param {string} token - 用户token
   * @returns {void}
   */
  static connect(token) {
    if (Platform.OS === "android") {
      JMI.connect(token);
    } else if (Platform.OS === "ios") {
      JMI.connectWithToken(token);
    }
  }

  /**
   * 添加连接状态监听器
   * @param {string} key - 监听器标识
   * @param {function} listener - 监听器回调函数
   * @returns {function} 返回取消监听的函数
   */
  static addConnectionStatusListener(key, listener) {
    if (Platform.OS === "android") {
      JMI.addConnectionStatusListener(key);
    } else if (Platform.OS === "ios") {
      JMI.addConnectionDelegate();
    }

    // 监听原生事件
    const subscription = juggleIMEmitter.addListener(
      "ConnectionStatusChanged",
      (event) => {
        if (Platform.OS === "android") {
          if (event.key === key) {
            listener(event.status, event.code, event.extra);
          }
        } else if (Platform.OS === "ios") {
          listener(event.status, event.code, event.extra);
        }
      }
    );

    const dbOpenSubscription = juggleIMEmitter.addListener(
      "DbDidOpen",
      (event) => {
        if (event.key === key) {
          listener("dbOpen", 0, "");
        }
      }
    );

    const dbCloseSubscription = juggleIMEmitter.addListener(
      "DbDidClose",
      (event) => {
        if (event.key === key) {
          listener("dbClose", 0, "");
        }
      }
    );

    // 返回取消监听的函数
    return () => {
      subscription.remove();
      dbOpenSubscription.remove();
      dbCloseSubscription.remove();
    };
  }

  /**
   * 添加消息监听器
   * @param {string} key - 监听器标识
   * @param {object} listener - 监听器回调函数对象
   * @returns {function} 返回取消监听的函数
   */
  static addMessageListener(key, listener) {
    if (Platform.OS === "android") {
      JMI.addMessageListener(key);
    } else if (Platform.OS === "ios") {
      JMI.addMessageDelegate();
    }

    const subscriptions = [];

    // 消息接收监听
    if (listener.onMessageReceive) {
      const subscription = juggleIMEmitter.addListener(
        "MessageReceived",
        (event) => {
          if (Platform.OS === "android" && event.key !== key) return;
          listener.onMessageReceive(event.message);
        }
      );
      subscriptions.push(subscription);
    }

    // 消息撤回监听
    if (listener.onMessageRecall) {
      const subscription = juggleIMEmitter.addListener(
        "MessageRecalled",
        (event) => {
          if (Platform.OS === "android" && event.key !== key) return;
          listener.onMessageRecall(event.message);
        }
      );
      subscriptions.push(subscription);
    }

    // 消息修改监听
    if (listener.onMessageUpdate) {
      const subscription = juggleIMEmitter.addListener(
        "MessageUpdated",
        (event) => {
          if (Platform.OS === "android" && event.key !== key) return;
          listener.onMessageUpdate(event.message);
        }
      );
      subscriptions.push(subscription);
    }

    // 消息删除监听
    if (listener.onMessageDelete) {
      const subscription = juggleIMEmitter.addListener(
        "MessageDeleted",
        (event) => {
          if (Platform.OS === "android" && event.key !== key) return;
          listener.onMessageDelete(event.conversation, event.clientMsgNos);
        }
      );
      subscriptions.push(subscription);
    }

    // 消息清除监听
    if (listener.onMessageClear) {
      const subscription = juggleIMEmitter.addListener(
        "MessageCleared",
        (event) => {
          if (Platform.OS === "android" && event.key !== key) return;
          listener.onMessageClear(
            event.conversation,
            event.timestamp,
            event.senderId
          );
        }
      );
      subscriptions.push(subscription);
    }

    // 消息回应添加监听
    if (listener.onMessageReactionAdd) {
      const subscription = juggleIMEmitter.addListener(
        "MessageReactionAdded",
        (event) => {
          if (Platform.OS === "android" && event.key !== key) return;
          listener.onMessageReactionAdd(event.conversation, event.reaction);
        }
      );
      subscriptions.push(subscription);
    }

    // 消息回应删除监听
    if (listener.onMessageReactionRemove) {
      const subscription = juggleIMEmitter.addListener(
        "MessageReactionRemoved",
        (event) => {
          if (Platform.OS === "android" && event.key !== key) return;
          listener.onMessageReactionRemove(event.conversation, event.reaction);
        }
      );
      subscriptions.push(subscription);
    }

    // 消息置顶监听
    if (listener.onMessageSetTop) {
      const subscription = juggleIMEmitter.addListener(
        "MessageSetTop",
        (event) => {
          if (Platform.OS === "android" && event.key !== key) return;
          listener.onMessageSetTop(event.message, event.operator, event.isTop);
        }
      );
      subscriptions.push(subscription);
    }

    // 返回取消监听的函数
    return () => {
      subscriptions.forEach((subscription) => subscription.remove());
    };
  }

  /**
   * 添加消息阅读状态监听器
   * @param {string} key - 监听器标识
   * @param {object} listener - 监听器回调函数对象
   * @returns {function} 返回取消监听的函数
   */
  static addMessageReadReceiptListener(key, listener) {
    if (Platform.OS === "android") {
      JMI.addMessageReadReceiptListener(key);
    } else if (Platform.OS === "ios") {
      JMI.addMessageReadReceiptDelegate();
    }

    const subscriptions = [];

    // 单聊消息阅读监听
    if (listener.onMessagesRead) {
      const subscription = juggleIMEmitter.addListener(
        "MessagesRead",
        (event) => {
          if (Platform.OS === "android" && event.key !== key) return;
          listener.onMessagesRead(event.conversation, event.messageIds);
        }
      );
      subscriptions.push(subscription);
    }

    // 群消息阅读监听
    if (listener.onGroupMessagesRead) {
      const subscription = juggleIMEmitter.addListener(
        "GroupMessagesRead",
        (event) => {
          if (Platform.OS === "android" && event.key !== key) return;
          listener.onGroupMessagesRead(event.conversation, event.messages);
        }
      );
      subscriptions.push(subscription);
    }

    // 返回取消监听的函数
    return () => {
      subscriptions.forEach((subscription) => subscription.remove());
    };
  }

  /**
   * 添加消息销毁监听器
   * @param {string} key - 监听器标识
   * @param {object} listener - 监听器回调函数对象
   * @returns {function} 返回取消监听的函数
   */
  static addMessageDestroyListener(key, listener) {
    if (Platform.OS === "android") {
      JMI.addMessageDestroyListener(key);
    } else if (Platform.OS === "ios") {
      JMI.addMessageDestroyDelegate();
    }

    const subscriptions = [];

    // 消息销毁时间更新监听
    if (listener.onMessageDestroyTimeUpdate) {
      const subscription = juggleIMEmitter.addListener(
        "MessageDestroyTimeUpdated",
        (event) => {
          if (Platform.OS === "android" && event.key !== key) return;
          listener.onMessageDestroyTimeUpdate(
            event.messageId,
            event.conversation,
            event.destroyTime
          );
        }
      );
      subscriptions.push(subscription);
    }

    // 返回取消监听的函数
    return () => {
      subscriptions.forEach((subscription) => subscription.remove());
    };
  }

  /**
   * 添加会话监听器
   * @param {string} key - 监听器标识
   * @param {object} listener - 监听器回调函数对象
   * @returns {function} 返回取消监听的函数
   */
  static addConversationListener(key, listener) {
    if (Platform.OS === "android") {
      JMI.addConversationListener(key);
    } else if (Platform.OS === "ios") {
      JMI.addConversationDelegate();
    }

    const subscriptions = [];

    // 会话新增监听
    if (listener.onConversationInfoAdd) {
      const subscription = juggleIMEmitter.addListener(
        "ConversationInfoAdded",
        (event) => {
          if (Platform.OS === "android" && event.key !== key) return;
          listener.onConversationInfoAdd(event.conversations);
        }
      );
      subscriptions.push(subscription);
    }

    // 会话更新监听
    if (listener.onConversationInfoUpdate) {
      const subscription = juggleIMEmitter.addListener(
        "ConversationInfoUpdated",
        (event) => {
          if (Platform.OS === "android" && event.key !== key) return;
          listener.onConversationInfoUpdate(event.conversations);
        }
      );
      subscriptions.push(subscription);
    }

    // 会话删除监听
    if (listener.onConversationInfoDelete) {
      const subscription = juggleIMEmitter.addListener(
        "ConversationInfoDeleted",
        (event) => {
          if (Platform.OS === "android" && event.key !== key) return;
          listener.onConversationInfoDelete(event.conversations);
        }
      );
      subscriptions.push(subscription);
    }

    // 总未读数更新监听
    if (listener.onTotalUnreadMessageCountUpdate) {
      const subscription = juggleIMEmitter.addListener(
        "TotalUnreadMessageCountUpdated",
        (event) => {
          if (Platform.OS === "android" && event.key !== key) return;
          listener.onTotalUnreadMessageCountUpdate(event.count);
        }
      );
      subscriptions.push(subscription);
    }

    // 返回取消监听的函数
    return () => {
      subscriptions.forEach((subscription) => subscription.remove());
    };
  }

  /**
   * 获取会话信息列表
   * @param {object} option - 获取选项
   * @returns {Promise<ConversationInfo[]>} 会话信息列表
   */
  static getConversationInfoList(option) {
    console.log("getConversationInfoList called with option:", option);
    return JMI.getConversationInfoList(
      option.count,
      option.timestamp,
      option.direction
    );
  }

  /**
   * 获取单个会话信息
   * @param {object} conversation - 会话对象
   * @returns {Promise<object>} 会话信息
   */
  static getConversationInfo(conversation) {
    return JMI.getConversationInfo(conversation);
  }

  /**
   * 创建会话信息
   * @param {object} conversation - 会话对象
   * @returns {Promise<object>} 创建的会话信息
   */
  static createConversationInfo(conversation) {
    return JMI.createConversationInfo(conversation);
  }

  /**
   * 删除会话信息
   * @param {object} conversation - 会话对象
   * @returns {Promise<boolean>} 删除结果
   */
  static deleteConversationInfo(conversation) {
    return JMI.deleteConversationInfo(conversation);
  }

  /**
   * 设置会话免打扰状态
   * @param {object} conversation - 会话对象
   * @param {boolean} isMute - 是否免打扰
   * @returns {Promise<boolean>} 设置结果
   */
  static setMute(conversation, isMute) {
    return JMI.setMute(conversation, isMute);
  }

  /**
   * 设置会话置顶状态
   * @param {object} conversation - 会话对象
   * @param {boolean} isTop - 是否置顶
   * @returns {Promise<boolean>} 设置结果
   */
  static setTop(conversation, isTop) {
    if (Platform.OS === "android") {
      return JMI.setTop(conversation, isTop);
    } else if (Platform.OS === "ios") {
      return JMI.setTop(conversation, isTop);
    }
  }

  /**
   * 清除会话未读数
   * @param {object} conversation - 会话对象
   * @returns {Promise<boolean>} 清除结果
   */
  static clearUnreadCount(conversation) {
    if (Platform.OS === "android") {
      return JMI.clearUnreadCount(conversation);
    } else if (Platform.OS === "ios") {
      return JMI.clearUnreadCount(conversation);
    }
  }

  /**
   * 清除总未读数
   * @returns {Promise<boolean>} 清除结果
   */
  static clearTotalUnreadCount() {
    return JMI.clearTotalUnreadCount();
  }

  /**
   * 获取总未读数
   * @returns {Promise<number>} 总未读数
   */
  static getTotalUnreadCount() {
    return JMI.getTotalUnreadCount();
  }

  /**
   * 设置会话草稿
   * @param {object} conversation - 会话对象
   * @param {string} draft - 草稿内容
   * @returns {Promise<boolean>} 设置结果
   */
  static setDraft(conversation, draft) {
    return JMI.setDraft(conversation, draft);
  }

  /**
   * 清除会话草稿
   * @param {object} conversation - 会话对象
   * @returns {Promise<boolean>} 清除结果
   */
  static clearDraft(conversation) {
    return JMI.clearDraft(conversation);
  }

  /**
   * 标记会话未读
   * @param {object} conversation - 会话对象
   * @returns {Promise<boolean>} 标记结果
   */
  static setUnread(conversation) {
    return JMI.setUnread(conversation);
  }

  /**
   * 获取置顶会话列表
   * @param {number} count - 获取数量
   * @param {number} timestamp - 时间戳
   * @param {number} direction - 拉取方向
   * @returns {Promise<Array>} 置顶会话列表
   */
  static getTopConversationInfoList(count = 20, timestamp = 0, direction = 0) {
    return JMI.getTopConversationInfoList(count, timestamp, direction);
  }

  /**
   * 获取指定类型未读数
   * @param {Array<number>} conversationTypes - 会话类型数组
   * @returns {Promise<number>} 未读数
   */
  static getUnreadCountWithTypes(conversationTypes) {
    return JMI.getUnreadCountWithTypes(conversationTypes);
  }

  /**
   * 向标签添加会话
   * @param {Array} conversations - 会话数组
   * @param {string} tagId - 标签ID
   * @returns {Promise<boolean>} 添加结果
   */
  static addConversationsToTag(conversations, tagId) {
    return JMI.addConversationsToTag(conversations, tagId);
  }

  /**
   * 从标签移除会话
   * @param {Array} conversations - 会话数组
   * @param {string} tagId - 标签ID
   * @returns {Promise<boolean>} 移除结果
   */
  static removeConversationsFromTag(conversations, tagId) {
    return JMI.removeConversationsFromTag(conversations, tagId);
  }

  //message

  /**
   * 发送消息
   * @param {SendMessageObject} message
   * @param {import("im-rn-sdk").SendMessageCallback} callback - 回调对象
   * @returns {import("im-rn-sdk").Message} - 消息对象
   */
  static async sendMessage(
    message,
    callback = {}
  ) {
    console.log("sendMessage message:", message);

    // 生成唯一标识符以避免回调冲突
    const messageId = Math.random().toString(36).substr(2, 9) + Date.now();

    const successListener = juggleIMEmitter.addListener(
      "onMessageSent",
      (event) => {
        if (event.messageId === messageId) {
          callback.onSuccess?.(event.message);
          successListener.remove();
          errorListener.remove();
        }
      }
    );

    const errorListener = juggleIMEmitter.addListener(
      "onMessageSentError",
      (event) => {
        if (event.messageId === messageId) {
          callback.onError?.(event.message, event.errorCode || -1);
          successListener.remove();
          errorListener.remove();
        }
      }
    );

    try {
      const localMsg = await JMI.sendMessage(message, messageId);
      return localMsg;
    } catch (error) {
      callback.onError?.(null, -1);
      successListener.remove();
      errorListener.remove();
      console.error("sendMessage error:", error);
    }
  }

  /**
   * 发送图片消息
   * @param {Object} message - 图片消息内容
   * @param {Object} callback - 回调对象
   * @returns {Promise<Message>} - 消息对象
   */
  static async sendImageMessage(
    message,
    callback = {}
  ) {
    console.log("sendImageMessage message...:", message);

    // 生成唯一标识符以避免回调冲突
    const messageId = Math.random().toString(36).substr(2, 9) + Date.now();

    const progressListener = juggleIMEmitter.addListener(
      "onMediaMessageProgress",
      (event) => {
        console.log("onMediaMessageSent msg:", event);
        if (event.messageId === messageId) {
          callback.onProgress?.(event.progress, event.message);
        }
      }
    );

    const successListener = juggleIMEmitter.addListener(
      "onMediaMessageSent",
      (event) => {
        console.log("onMediaMessageSent msg:", event);
        if (event.messageId === messageId) {
          callback.onSuccess?.(event.message);
          progressListener.remove();
          successListener.remove();
          errorListener.remove();
          cancelListener.remove();
        }
      }
    );

    const errorListener = juggleIMEmitter.addListener(
      "onMediaMessageSentError",
      (event) => {
        if (event.messageId === messageId) {
          callback.onError?.(event.message, event.errorCode || -1);
          progressListener.remove();
          successListener.remove();
          errorListener.remove();
          cancelListener.remove();
        }
      }
    );

    const cancelListener = juggleIMEmitter.addListener(
      "onMediaMessageCancelled",
      (event) => {
        if (event.messageId === messageId) {
          callback.onCancel?.(event.message);
          progressListener.remove();
          successListener.remove();
          errorListener.remove();
          cancelListener.remove();
        }
      }
    );

    try {
      const localMsg = await JMI.sendImageMessage(message, messageId);
      return localMsg;
    } catch (error) {
      progressListener.remove();
      successListener.remove();
      errorListener.remove();
      cancelListener.remove();
      console.error("sendImageMessage error:", error);
      throw error;
    }
  }

  /**
   * 发送文件消息
   * @param {Object} message - 文件消息内容
   * @param {Object} callback - 回调对象
   * @returns {Promise<Message>} - 消息对象
   */
  static async sendFileMessage(
    message,
    callback = {}
  ) {
    // 生成唯一标识符以避免回调冲突
    const messageId = Math.random().toString(36).substr(2, 9) + Date.now();

    // 添加监听器
    const progressListener = juggleIMEmitter.addListener(
      "onMediaMessageProgress",
      (event) => {
        if (event.messageId === messageId) {
          callback.onProgress?.(event.progress, event.message);
        }
      }
    );

    const successListener = juggleIMEmitter.addListener(
      "onMediaMessageSent",
      (event) => {
        if (event.messageId === messageId) {
          callback.onSuccess?.(event.message);
          progressListener.remove();
          successListener.remove();
          errorListener.remove();
          cancelListener.remove();
        }
      }
    );

    const errorListener = juggleIMEmitter.addListener(
      "onMediaMessageSentError",
      (event) => {
        if (event.messageId === messageId) {
          callback.onError?.(event.message, event.errorCode || -1);
          progressListener.remove();
          successListener.remove();
          errorListener.remove();
          cancelListener.remove();
        }
      }
    );

    const cancelListener = juggleIMEmitter.addListener(
      "onMediaMessageCancelled",
      (event) => {
        if (event.messageId === messageId) {
          callback.onCancel?.(event.message);
          progressListener.remove();
          successListener.remove();
          errorListener.remove();
          cancelListener.remove();
        }
      }
    );

    try {
      console.log("sendFileMessage message...:", message);
      const localMsg = await JMI.sendFileMessage(message, messageId);
      console.log("sendFileMessage localMsg:", localMsg);
      return localMsg;
    } catch (error) {
      progressListener.remove();
      successListener.remove();
      errorListener.remove();
      cancelListener.remove();
      console.error("sendFileMessage error:", error);
      throw error;
    }
  }

  /**
   * 发送语音消息
   * @param {Object} message - 语音消息内容
   * @param {Object} callback - 回调对象
   * @returns {Promise<Message>} - 消息对象
   */
  static async sendVoiceMessage(
    message,
    callback = {}
  ) {
    // 生成唯一标识符以避免回调冲突
    const messageId = Math.random().toString(36).substr(2, 9) + Date.now();

    // 添加监听器
    const progressListener = juggleIMEmitter.addListener(
      "onMediaMessageProgress",
      (event) => {
        if (event.messageId === messageId) {
          callback.onProgress?.(event.progress, event.message);
        }
      }
    );

    const successListener = juggleIMEmitter.addListener(
      "onMediaMessageSent",
      (event) => {
        if (event.messageId === messageId) {
          callback.onSuccess?.(event.message);
          progressListener.remove();
          successListener.remove();
          errorListener.remove();
          cancelListener.remove();
        }
      }
    );

    const errorListener = juggleIMEmitter.addListener(
      "onMediaMessageSentError",
      (event) => {
        if (event.messageId === messageId) {
          callback.onError?.(event.message, event.errorCode || -1);
          progressListener.remove();
          successListener.remove();
          errorListener.remove();
          cancelListener.remove();
        }
      }
    );

    const cancelListener = juggleIMEmitter.addListener(
      "onMediaMessageCancelled",
      (event) => {
        if (event.messageId === messageId) {
          callback.onCancel?.(event.message);
          progressListener.remove();
          successListener.remove();
          errorListener.remove();
          cancelListener.remove();
        }
      }
    );

    try {
      console.log("sendVoiceMessage message...:", message);
      const localMsg = await JMI.sendVoiceMessage(message, messageId);
      console.log("sendVoiceMessage localMsg:", localMsg);
      return localMsg;
    } catch (error) {
      progressListener.remove();
      successListener.remove();
      errorListener.remove();
      cancelListener.remove();
      console.error("sendVoiceMessage error:", error);
      throw error;
    }
  }

  /**
   * 获取历史消息
   * @param {Object} conversation - 会话对象
   * @param {number} direction - 拉取方向
   * @param {Object} options - 获取选项
   */
  static getMessageList(conversation, direction, options) {
    return JMI.getMessages(conversation, direction, options);
  }

  /**
   * 撤回消息
   * @param {Object} message - 消息对象
   * @param {Object} extras - kv 扩展信息
   */
  static recallMessage(message, extras = {}) {
    return JMI.recallMessage(message, extras);
  }

  /**
   * 根据clientMsgNo列表删除消息
   * @param {object} conversation - 会话对象
   * @param {number[]} clientMsgNos - clientMsgNo列表
   * @returns {Promise<boolean>} 删除结果
   */
  static deleteMessagesByClientMsgNoList(conversation, clientMsgNos) {
    if (Platform.OS === "android") {
      return JMI.deleteMessagesByClientMsgNoList(conversation, clientMsgNos);
    } else if (Platform.OS === "ios") {
      return JMI.deleteMessagesByClientMsgNoList(conversation, clientMsgNos);
    }
  }

  /**
   * 添加消息反应
   * @param {Object} message - 消息对象
   * @param {string} reactionId - 反应ID
   */
  static addMessageReaction(message, reactionId) {
    JMI.addMessageReaction(message, reactionId);
  }

  /**
   * 移除消息反应
   * @param {Object} message - 消息对象
   * @param {string} reactionId - 反应ID
   */
  static removeMessageReaction(message, reactionId) {
    JMI.removeMessageReaction(message, reactionId, callback);
  }
}

export default JuggleIM;