juggleim-rnsdk 0.2.3 → 0.2.4

package/android/build.gradle

@@ -44,7 +44,7 @@ repositories {
 
 dependencies {
     implementation 'com.facebook.react:react-native:0.71.1'
-    implementation 'com.juggle.im:juggle:1.8.34'
+    implementation 'com.juggle.im:juggle:1.8.35'
     implementation 'com.juggle.call.zego:juggle:1.8.25'
     implementation 'im.zego:express-video:3.17.3'
 }

package/android/src/main/java/com/juggleim/JuggleIMManager.java

@@ -25,6 +25,7 @@ import com.juggle.im.model.Conversation;
 import com.juggle.im.model.ConversationInfo;
 import com.juggle.im.model.MessageMentionInfo;
 import com.juggle.im.model.MessageReaction;
+import com.juggle.im.model.MediaMessageContent;
 import com.juggle.im.model.MessageReactionItem;
 import com.juggle.im.model.UserInfo;
 import com.juggle.im.model.GroupMessageReadInfo;
@@ -498,7 +499,6 @@ public class JuggleIMManager extends ReactContextBaseJavaModule {
     private WritableMap convertMessageContentToMap(MessageContent content) {
         byte[] bytes = content.encode();
         String str = new String(bytes, StandardCharsets.UTF_8);
-        Log.d("JuggleIM", "convertMessageContentToMap: " + str);
         WritableMap map = RNTypeConverter.stringToWritableMap(str);
         if (content instanceof ImageMessage) {
             ImageMessage img = (ImageMessage) content;
@@ -1077,9 +1077,17 @@ public class JuggleIMManager extends ReactContextBaseJavaModule {
      * 将 ReadableMap 转换为 Conversation 对象
      */
     private Conversation convertMapToConversation(ReadableMap map) {
-        Conversation.ConversationType type = Conversation.ConversationType.values()[map.getInt("conversationType")];
-        Conversation conversation = new Conversation(type, map.getString("conversationId"));
-        return conversation;
+        if (map.hasKey("conversationType") && map.hasKey("conversationId")) {
+            Conversation.ConversationType type = Conversation.ConversationType.values()[map.getInt("conversationType")];
+            Conversation conversation = new Conversation(type, map.getString("conversationId"));
+            return conversation;
+        } else if (map.hasKey("conversation")) {
+            ReadableMap conversationMap = map.getMap("conversation");
+            Conversation.ConversationType type = Conversation.ConversationType.values()[conversationMap.getInt("conversationType")];
+            Conversation conversation = new Conversation(type, conversationMap.getString("conversationId"));
+            return conversation;
+        }
+        return null;
     }
 
     /**
@@ -1613,6 +1621,166 @@ public class JuggleIMManager extends ReactContextBaseJavaModule {
         }
     }
 
+    /**
+     * 发送媒体消息
+     */
+    @ReactMethod
+    public void sendMediaMessage(ReadableMap messageMap, String messageId, Promise promise) {
+        try {
+            Conversation conversation = convertMapToConversation(messageMap);
+            ReadableMap contentMap = messageMap.getMap("content");
+            MessageContent content = convertMapToMessageContent(contentMap);
+            
+            if (!(content instanceof MediaMessageContent)) {
+                promise.reject("SEND_MEDIA_MESSAGE_ERROR", "Content is not a media message");
+                return;
+            }
+
+            MessageOptions options = new MessageOptions();
+            PushData pushData = convertMapToPushData(messageMap);
+            if (pushData != null) {
+                options.setPushData(pushData);
+            }
+            ReadableMap mentionInfoMap = messageMap.getMap("mentionInfo");
+            if (mentionInfoMap != null) {
+                MessageMentionInfo mentionInfo = convertMapToMentionInfo(mentionInfoMap);
+                options.setMentionInfo(mentionInfo);
+            }
+            if (messageMap.hasKey("referredMessageId")) {
+                options.setReferredMessageId(messageMap.getString("referredMessageId"));
+            }
+
+            Message message = JIM.getInstance().getMessageManager().sendMediaMessage(
+                    (MediaMessageContent) content,
+                    conversation,
+                    options,
+                    new IMessageManager.ISendMediaMessageCallback() {
+                        @Override
+                        public void onProgress(int progress, Message message) {
+                            WritableMap params = new WritableNativeMap();
+                            params.putString("messageId", messageId);
+                            params.putInt("progress", progress);
+                            params.putMap("message", convertMessageToMap(message));
+                            sendEvent("onMediaMessageProgress", params);
+                        }
+
+                        @Override
+                        public void onSuccess(Message message) {
+                            WritableMap params = new WritableNativeMap();
+                            params.putString("messageId", messageId);
+                            params.putMap("message", convertMessageToMap(message));
+                            sendEvent("onMediaMessageSent", params);
+                        }
+
+                        @Override
+                        public void onError(Message message, int errorCode) {
+                            WritableMap params = new WritableNativeMap();
+                            params.putString("messageId", messageId);
+                            params.putMap("message", convertMessageToMap(message));
+                            params.putInt("errorCode", errorCode);
+                            sendEvent("onMediaMessageSentError", params);
+                        }
+
+                        @Override
+                        public void onCancel(Message message) {
+                            WritableMap params = new WritableNativeMap();
+                            params.putString("messageId", messageId);
+                            params.putMap("message", convertMessageToMap(message));
+                            sendEvent("onMediaMessageCancelled", params);
+                        }
+                    });
+
+            WritableMap result = convertMessageToMap(message);
+            result.putString("messageId", messageId);
+            promise.resolve(result);
+        } catch (Exception e) {
+            promise.reject("SEND_MEDIA_MESSAGE_ERROR", e.getMessage());
+        }
+    }
+
+    /**
+     * 重发消息
+     */
+    @ReactMethod
+    public void resendMessage(ReadableMap messageMap, String messageId, Promise promise) {
+        try {
+            Message message = convertMapToMessage(messageMap);
+            Message sendMsg = JIM.getInstance().getMessageManager().resendMessage(message, new IMessageManager.ISendMessageCallback() {
+                @Override
+                public void onSuccess(Message message) {
+                    WritableMap params = new WritableNativeMap();
+                    params.putString("messageId", messageId);
+                    params.putMap("message", convertMessageToMap(message));
+                    sendEvent("onMessageSent", params);
+                }
+
+                @Override
+                public void onError(Message message, int errorCode) {
+                    WritableMap params = new WritableNativeMap();
+                    params.putString("messageId", messageId);
+                    params.putMap("message", convertMessageToMap(message));
+                    params.putInt("errorCode", errorCode);
+                    sendEvent("onMessageSentError", params);
+                }
+            });
+            WritableMap result = convertMessageToMap(sendMsg);
+            result.putString("messageId", messageId);
+            promise.resolve(result);
+        } catch (Exception e) {
+            promise.reject("RESEND_MESSAGE_ERROR", e.getMessage());
+        }
+    }
+
+    /**
+     * 重发媒体消息
+     */
+    @ReactMethod
+    public void resendMediaMessage(ReadableMap messageMap, String messageId, Promise promise) {
+        try {
+            Message message = convertMapToMessage(messageMap);
+            Message sendMsg = JIM.getInstance().getMessageManager().resendMediaMessage(message, new IMessageManager.ISendMediaMessageCallback() {
+                @Override
+                public void onProgress(int progress, Message message) {
+                    WritableMap params = new WritableNativeMap();
+                    params.putString("messageId", messageId);
+                    params.putInt("progress", progress);
+                    params.putMap("message", convertMessageToMap(message));
+                    sendEvent("onMediaMessageProgress", params);
+                }
+
+                @Override
+                public void onSuccess(Message message) {
+                    WritableMap params = new WritableNativeMap();
+                    params.putString("messageId", messageId);
+                    params.putMap("message", convertMessageToMap(message));
+                    sendEvent("onMediaMessageSent", params);
+                }
+
+                @Override
+                public void onError(Message message, int errorCode) {
+                    WritableMap params = new WritableNativeMap();
+                    params.putString("messageId", messageId);
+                    params.putMap("message", convertMessageToMap(message));
+                    params.putInt("errorCode", errorCode);
+                    sendEvent("onMediaMessageSentError", params);
+                }
+
+                @Override
+                public void onCancel(Message message) {
+                    WritableMap params = new WritableNativeMap();
+                    params.putString("messageId", messageId);
+                    params.putMap("message", convertMessageToMap(message));
+                    sendEvent("onMediaMessageCancelled", params);
+                }
+            });
+            WritableMap result = convertMessageToMap(sendMsg);
+            result.putString("messageId", messageId);
+            promise.resolve(result);
+        } catch (Exception e) {
+            promise.reject("RESEND_MEDIA_MESSAGE_ERROR", e.getMessage());
+        }
+    }
+
     private Message convertMapToMessage(ReadableMap messageMap) {
         Message message = new Message();
         Conversation conversation = convertMapToConversation(messageMap);
@@ -1637,6 +1805,7 @@ public class JuggleIMManager extends ReactContextBaseJavaModule {
             ReadableMap contentMap = messageMap.getMap("content");
             MessageContent content = convertMapToMessageContent(contentMap);
             message.setContent(content);
+            message.setContentType(content.getContentType());
         }
 
         // 设置消息方向

package/ios/JuggleIMManager.m

@@ -394,6 +394,7 @@ RCT_EXPORT_METHOD(addConversationDelegate) {
   dict[@"content"] = contentDic;
   dict[@"direction"] = @(message.direction);
   dict[@"messageState"] = @(message.messageState);
+  dict[@"contentType"] = message.contentType;
 
   // 添加是否已读
   dict[@"hasRead"] = @(message.hasRead);
@@ -1001,11 +1002,20 @@ RCT_EXPORT_METHOD(removeConversationsFromTag : (NSArray *)
  * 将字典转换为会话对象
  */
 - (JConversation *)convertDictionaryToConversation:(NSDictionary *)dict {
-  JConversationType type =
-      (JConversationType)[dict[@"conversationType"] intValue];
-  NSString *conversationId = dict[@"conversationId"];
-  return [[JConversation alloc] initWithConversationType:type
+  if (dict[@"conversation"]) {
+    NSDictionary* conversationDict = dict[@"conversation"];
+    JConversationType type =
+        (JConversationType)[conversationDict[@"conversationType"] intValue];
+    NSString *conversationId = conversationDict[@"conversationId"];
+    return [[JConversation alloc] initWithConversationType:type
                                           conversationId:conversationId];
+  } else {
+    JConversationType type =
+        (JConversationType)[dict[@"conversationType"] intValue];
+    NSString *conversationId = dict[@"conversationId"];
+    return [[JConversation alloc] initWithConversationType:type
+                                          conversationId:conversationId];
+  }
 }
 
 /**
@@ -1479,6 +1489,141 @@ RCT_EXPORT_METHOD(removeMessageReaction : (
   return nil;
 }
 
+/**
+ * 重发消息
+ */
+RCT_EXPORT_METHOD(resendMessage : (NSDictionary *)messageDict messageId : (
+    NSString *)messageId resolver : (RCTPromiseResolveBlock)
+                      resolve rejecter : (RCTPromiseRejectBlock)reject) {
+  @try {
+    JMessage *message = [self convertDictToMessage:messageDict];
+    JMessage *sendMsg = [JIM.shared.messageManager resend:message
+        success:^(JMessage *message) {
+          NSMutableDictionary *params = [NSMutableDictionary dictionary];
+          params[@"messageId"] = messageId;
+          params[@"message"] = [self convertMessageToDictionary:message];
+          [self sendEventWithName:@"onMessageSent" body:params];
+        }
+        error:^(JErrorCode errorCode, JMessage *message) {
+          NSMutableDictionary *params = [NSMutableDictionary dictionary];
+          params[@"messageId"] = messageId;
+          params[@"message"] = [self convertMessageToDictionary:message];
+          params[@"errorCode"] = @(errorCode);
+          [self sendEventWithName:@"onMessageSentError" body:params];
+        }];
+    NSMutableDictionary *result = [self convertMessageToDictionary:sendMsg];
+    result[@"messageId"] = messageId;
+    resolve(result);
+  } @catch (NSException *exception) {
+    reject(@"RESEND_MESSAGE_ERROR", exception.reason, nil);
+  }
+}
+
+/**
+ * 重发媒体消息
+ */
+RCT_EXPORT_METHOD(resendMediaMessage : (NSDictionary *)messageDict messageId : (
+    NSString *)messageId resolver : (RCTPromiseResolveBlock)
+                      resolve rejecter : (RCTPromiseRejectBlock)reject) {
+  @try {
+    JMessage *message = [self convertDictToMessage:messageDict];
+    JMessage *sendMsg = [JIM.shared.messageManager resendMediaMessage:message
+        progress:^(int progress, JMessage *message) {
+          NSMutableDictionary *params = [NSMutableDictionary dictionary];
+          params[@"messageId"] = messageId;
+          params[@"progress"] = @(progress);
+          params[@"message"] = [self convertMessageToDictionary:message];
+          [self sendEventWithName:@"onMediaMessageProgress" body:params];
+        }
+        success:^(JMessage *message) {
+          NSMutableDictionary *params = [NSMutableDictionary dictionary];
+          params[@"messageId"] = messageId;
+          params[@"message"] = [self convertMessageToDictionary:message];
+          [self sendEventWithName:@"onMediaMessageSent" body:params];
+        }
+        error:^(JErrorCode errorCode, JMessage *message) {
+          NSMutableDictionary *params = [NSMutableDictionary dictionary];
+          params[@"messageId"] = messageId;
+          params[@"message"] = [self convertMessageToDictionary:message];
+          params[@"errorCode"] = @(errorCode);
+          [self sendEventWithName:@"onMediaMessageSentError" body:params];
+        }
+        cancel:^(JMessage *message) {
+          NSMutableDictionary *params = [NSMutableDictionary dictionary];
+          params[@"messageId"] = messageId;
+          params[@"message"] = [self convertMessageToDictionary:message];
+          [self sendEventWithName:@"onMediaMessageCancelled" body:params];
+    }];
+    NSMutableDictionary *result = [self convertMessageToDictionary:sendMsg];
+    result[@"messageId"] = messageId;
+    resolve(result);
+  } @catch (NSException *exception) {
+    reject(@"RESEND_MEDIA_MESSAGE_ERROR", exception.reason, nil);
+  }
+}
+
+/**
+ * 发送媒体消息
+ */
+RCT_EXPORT_METHOD(sendMediaMessage : (NSDictionary *)messageDict resolver : (
+    RCTPromiseResolveBlock)resolve rejecter : (RCTPromiseRejectBlock)reject) {
+  @try {
+    NSString *messageId = [NSString stringWithFormat:@"%f%d", [[NSDate date] timeIntervalSince1970], arc4random() % 10000];
+    if (messageDict[@"messageId"]) {
+        messageId = messageDict[@"messageId"];
+    }
+
+    JMessageContent *content = [self convertDictToMessageContent:messageDict[@"content"]];
+    if (!content) {
+        reject(@"SEND_MEDIA_MESSAGE_ERROR", @"Invalid message content", nil);
+        return;
+    }
+    
+    if (![content isKindOfClass:[JMediaMessageContent class]]) {
+        reject(@"SEND_MEDIA_MESSAGE_ERROR", @"Content must be MediaMessageContent", nil);
+        return;
+    }
+
+    JConversation *conversation =
+        [self convertDictionaryToConversation:messageDict];
+        
+    JMessage *message = [JIM.shared.messageManager sendMediaMessage:(JMediaMessageContent *)content
+        inConversation:conversation
+        progress:^(int progress, JMessage *message) {
+          NSMutableDictionary *params = [NSMutableDictionary dictionary];
+          params[@"messageId"] = messageId;
+          params[@"progress"] = @(progress);
+          params[@"message"] = [self convertMessageToDictionary:message];
+          [self sendEventWithName:@"onMediaMessageProgress" body:params];
+        }
+        success:^(JMessage *message) {
+          NSMutableDictionary *params = [NSMutableDictionary dictionary];
+          params[@"messageId"] = messageId;
+          params[@"message"] = [self convertMessageToDictionary:message];
+          [self sendEventWithName:@"onMediaMessageSent" body:params];
+        }
+        error:^(JErrorCode errorCode, JMessage *message) {
+          NSMutableDictionary *params = [NSMutableDictionary dictionary];
+          params[@"messageId"] = messageId;
+          params[@"message"] = [self convertMessageToDictionary:message];
+          params[@"errorCode"] = @(errorCode);
+          [self sendEventWithName:@"onMediaMessageSentError" body:params];
+        }
+        cancel:^(JMessage *message) {
+          NSMutableDictionary *params = [NSMutableDictionary dictionary];
+          params[@"messageId"] = messageId;
+          params[@"message"] = [self convertMessageToDictionary:message];
+          [self sendEventWithName:@"onMediaMessageCancelled" body:params];
+        }];
+
+    NSMutableDictionary *result = [self convertMessageToDictionary:message];
+    result[@"messageId"] = messageId;
+    resolve(result);
+  } @catch (NSException *exception) {
+    reject(@"SEND_MEDIA_MESSAGE_ERROR", exception.reason, nil);
+  }
+}
+
 - (JMessage *)convertDictToMessage:(NSDictionary *)messageDict {
   if (![messageDict isKindOfClass:[NSDictionary class]]) {
     return nil;
@@ -1516,6 +1661,7 @@ RCT_EXPORT_METHOD(removeMessageReaction : (
   if ([contentDict isKindOfClass:[NSDictionary class]]) {
     JMessageContent *content = [self convertDictToMessageContent:contentDict];
     message.content = content;
+    message.contentType = contentDict[@"contentType"];
   }
 
   // 7. direction

package/juggleim-rnsdk.podspec

@@ -16,7 +16,7 @@ Pod::Spec.new do |s|
   s.requires_arc = true
 
   s.dependency "React-Core"
-  s.dependency "JuggleIM", "~> 1.8.34.1"
+  s.dependency "JuggleIM", "~> 1.8.35"
   s.dependency 'JZegoCall', '1.8.25'
 
 end

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "juggleim-rnsdk",
-  "version": "0.2.3",
+  "version": "0.2.4",
   "description": "React Native wrapper for Juggle IM SDK",
   "main": "src/index.js",
   "types": "src/index.d.ts",

package/src/index.d.ts

@@ -519,6 +519,39 @@ export default class JuggleIM {
    * @returns {Promise<GroupInfo[]>} 群组信息列表
    */
   static getGroupInfoList(groupIdList: string[]): Promise<GroupInfo[]>;
+
+  /**
+   * 重发消息
+   * @param {Message} message - 消息对象
+   * @param {SendMessageCallback} [callback] - 回调对象
+   * @returns {Promise<Message>} - 消息对象
+   */
+  static resendMessage(
+    message: Message,
+    callback?: SendMessageCallback
+  ): Promise<Message>;
+
+  /**
+   * 重发媒体消息
+   * @param {Message} message - 消息对象
+   * @param {SendMediaMessageCallback} [callback] - 回调对象
+   * @returns {Promise<Message>} - 消息对象
+   */
+  static resendMediaMessage(
+    message: Message,
+    callback?: SendMediaMessageCallback
+  ): Promise<Message>;
+
+  /**
+   * 发送媒体消息
+   * @param {SendMessageObject} message - 消息内容
+   * @param {SendMediaMessageCallback} [callback] - 回调对象
+   * @returns {Promise<Message>} - 消息对象
+   */
+  static sendMediaMessage(
+    message: SendMessageObject,
+    callback?: SendMediaMessageCallback
+  ): Promise<Message>;
 }
 
 

package/src/index.js

@@ -763,9 +763,10 @@ class JuggleIM {
 
     const successListener = juggleIMEmitter.addListener(
       "onMessageSent",
-      (event) => {
+      async (event) => {
         if (event.messageId === messageId) {
-          callback.onSuccess?.(event.message);
+          const msgInfo = await this.buildMessageInfo(event.message);
+          callback.onSuccess?.(msgInfo);
           successListener.remove();
           errorListener.remove();
         }
@@ -785,7 +786,7 @@ class JuggleIM {
 
     try {
       const localMsg = await JMI.sendMessage(message, messageId);
-      return localMsg;
+      return this.buildMessageInfo(localMsg)
     } catch (error) {
       callback.onError?.(JSON.stringify(error), -1);
       successListener.remove();
@@ -821,10 +822,11 @@ class JuggleIM {
 
     const successListener = juggleIMEmitter.addListener(
       "onMediaMessageSent",
-      (event) => {
+      async (event) => {
         console.log("onMediaMessageSent msg:", event);
         if (event.messageId === messageId) {
-          callback.onSuccess?.(event.message);
+          const msgInfo = await this.buildMessageInfo(event.message);
+          callback.onSuccess?.(msgInfo);
           progressListener.remove();
           successListener.remove();
           errorListener.remove();
@@ -865,7 +867,7 @@ class JuggleIM {
       if (localMsg.content?.local) {
         localMsg.content.localPath = localMsg.content.local;
       }
-      return localMsg;
+      return this.buildMessageInfo(localMsg)
     } catch (error) {
       progressListener.remove();
       successListener.remove();
@@ -940,8 +942,7 @@ class JuggleIM {
     try {
       console.log("sendFileMessage message...:", message);
       const localMsg = await JMI.sendFileMessage(message, messageId);
-      console.log("sendFileMessage localMsg:", localMsg);
-      return localMsg;
+      return this.buildMessageInfo(localMsg)
     } catch (error) {
       progressListener.remove();
       successListener.remove();
@@ -976,10 +977,11 @@ class JuggleIM {
 
     const successListener = juggleIMEmitter.addListener(
       "onMediaMessageSent",
-      (event) => {
+      async (event) => {
         if (event.messageId === messageId) {
           console.log("onMediaMessageSent msg:", event);
-          callback.onSuccess?.(event.message);
+          const msgInfo = await this.buildMessageInfo(event.message);
+          callback.onSuccess?.(msgInfo);
           progressListener.remove();
           successListener.remove();
           errorListener.remove();
@@ -1016,7 +1018,7 @@ class JuggleIM {
 
     try {
       const localMsg = await JMI.sendVoiceMessage(message, messageId);
-      return localMsg;
+      return this.buildMessageInfo(localMsg)
     } catch (error) {
       progressListener.remove();
       successListener.remove();
@@ -1193,6 +1195,206 @@ class JuggleIM {
   static getGroupInfoList(groupIdList) {
     return JMI.getGroupInfoList(groupIdList);
   }
+
+  /**
+   * 重发消息
+   * @param {import("juggleim-rnsdk").Message} message
+   * @param {import("juggleim-rnsdk").SendMessageCallback} callback - 回调对象
+   * @returns {import("juggleim-rnsdk").Message} - 消息对象
+   */
+  static async resendMessage(
+    message,
+    callback = {}
+  ) {
+    console.log("resendMessage message:", message);
+
+    // 生成唯一标识符以避免回调冲突
+    const messageId = Math.random().toString(36).substr(2, 9) + Date.now();
+
+    const successListener = juggleIMEmitter.addListener(
+      "onMessageSent",
+      async (event) => {
+        if (event.messageId === messageId) {
+          const msgInfo = await this.buildMessageInfo(event.message);
+          callback.onSuccess?.(msgInfo);
+          successListener.remove();
+          errorListener.remove();
+        }
+      }
+    );
+
+    const errorListener = juggleIMEmitter.addListener(
+      "onMessageSentError",
+      async (event) => {
+        if (event.messageId === messageId) {
+          callback.onError?.(event.message, event.errorCode || -1);
+          successListener.remove();
+          errorListener.remove();
+        }
+      }
+    );
+
+    try {
+      const localMsg = await JMI.resendMessage(message, messageId);
+      const msgInfo = await this.buildMessageInfo(localMsg);
+      console.log("resendMessage msgInfo:", msgInfo);
+      return msgInfo;
+    } catch (error) {
+      callback.onError?.(JSON.stringify(error), -1);
+      successListener.remove();
+      errorListener.remove();
+      console.error("resendMessage error:", error);
+    }
+  }
+
+  /**
+   * 重发媒体消息
+   * @param {import("juggleim-rnsdk").Message} message
+   * @param {import("juggleim-rnsdk").SendMediaMessageCallback} callback - 回调对象
+   * @returns {import("juggleim-rnsdk").Message} - 消息对象
+   */
+  static async resendMediaMessage(
+    message,
+    callback = {}
+  ) {
+    console.log("resendMediaMessage message:", message);
+
+    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",
+      async (event) => {
+        if (event.messageId === messageId) {
+          const msgInfo = await this.buildMessageInfo(event.message);
+          callback.onSuccess?.(msgInfo);
+          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 {
+      return await JMI.resendMediaMessage(message, messageId);
+    } catch (error) {
+      callback.onError?.(JSON.stringify(error), -1);
+      progressListener.remove();
+      successListener.remove();
+      errorListener.remove();
+      cancelListener.remove();
+      console.error("resendMediaMessage error:", error);
+    }
+  }
+
+  /**
+   * 发送媒体消息
+   * @param {import("juggleim-rnsdk").SendMessageObject} message - 消息内容
+   * @param {import("juggleim-rnsdk").SendMediaMessageCallback} callback - 回调对象
+   * @returns {Promise<import("juggleim-rnsdk").Message>} - 消息对象
+   */
+  static async sendMediaMessage(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) {
+          const msgInfo = this.buildMessageInfo(event.message);
+          callback.onSuccess?.(msgInfo);
+          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 {
+      var msg = null;
+      if (Platform.OS === "android") {
+        msg = await JMI.sendMediaMessage(message, messageId);
+      } else {
+        const messageWithId = { ...message, messageId };
+        msg = await JMI.sendMediaMessage(messageWithId);
+      }
+      const msgInfo = await this.buildMessageInfo(msg);
+      return msgInfo;
+    } catch (error) {
+      callback.onError?.(JSON.stringify(error), -1);
+      progressListener.remove();
+      successListener.remove();
+      errorListener.remove();
+      cancelListener.remove();
+      console.error("sendMediaMessage error:", error);
+    }
+  }
 }
 
 export * from './types';