juggleim-rnsdk 0.0.23 → 0.1.3

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

@@ -36,8 +36,14 @@ import com.juggle.im.internal.logger.JLogLevel;
 
 import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
+import java.nio.charset.StandardCharsets;
+
+import org.json.JSONObject;
+import org.json.JSONArray;
+import org.json.JSONException;
 
 import javax.annotation.Nonnull;
 
@@ -50,6 +56,9 @@ public class JuggleIMManager extends ReactContextBaseJavaModule {
     private Map<String, IMessageManager.IMessageListener> messageListeners = new HashMap<>();
     private Map<String, IMessageManager.IMessageReadReceiptListener> readReceiptListeners = new HashMap<>();
     private Map<String, IConversationManager.IConversationListener> conversationListeners = new HashMap<>();
+    
+    // 自定义消息类型注册表
+    private Map<String, String> customMessageTypes = new HashMap<>();
 
     public JuggleIMManager(@Nonnull ReactApplicationContext reactContext) {
         super(reactContext);
@@ -98,6 +107,22 @@ public class JuggleIMManager extends ReactContextBaseJavaModule {
         logBuilder.setLogConsoleLevel(JLogLevel.JLogLevelVerbose);
         builder.setJLogConfig(new JLogConfig(logBuilder));
         JIM.getInstance().init(getCurrentActivity(), appKey, builder.build());
+        JIM.getInstance().getMessageManager().registerContentType(GenericCustomMessage.class);
+    }
+
+    /**
+     * 注册自定义消息类型
+     *
+     * @param contentType 消息类型标识符
+     */
+    @ReactMethod
+    public void registerCustomMessageType(String contentType) {
+        if (contentType == null || contentType.isEmpty() || contentType.startsWith("jg:")) {
+            Log.e("JuggleIM", "contentType 不能以 'jg:' 开头");
+            return;
+        }
+        customMessageTypes.put(contentType, contentType);
+        Log.d("JuggleIM", "注册自定义消息类型: " + contentType);
     }
 
     /**
@@ -459,10 +484,13 @@ public class JuggleIMManager extends ReactContextBaseJavaModule {
      */
     private WritableMap convertMessageContentToMap(MessageContent content) {
         WritableMap map = new WritableNativeMap();
-        map.putString("contentType", content.getContentType());
-        if (content.getContentType().equals("jg:text")) {
+        String contentType = content.getContentType();
+        Log.d("JuggleIM", "contentType: " + contentType);
+        map.putString("contentType", contentType);
+        
+        if (contentType.equals("jg:text")) {
             map.putString("content", ((TextMessage) content).getContent());
-        } else if (content.getContentType().equals("jg:img")) {
+        } else if (contentType.equals("jg:img")) {
             ImageMessage img = (ImageMessage) content;
             map.putString("url", img.getUrl());
             map.putString("localPath", img.getLocalPath());
@@ -470,21 +498,36 @@ public class JuggleIMManager extends ReactContextBaseJavaModule {
             map.putString("thumbnailUrl", img.getThumbnailUrl());
             map.putInt("width", img.getWidth());
             map.putInt("height", img.getHeight());
-        } else if (content.getContentType().equals("jg:file")) {
+        } else if (contentType.equals("jg:file")) {
             FileMessage file = (FileMessage) content;
             map.putString("url", file.getUrl());
             map.putString("type", file.getType());
             map.putString("name", file.getName());
             map.putDouble("size", file.getSize());
-        } else if (content.getContentType().equals("jg:voice")) {
+        } else if (contentType.equals("jg:voice")) {
             VoiceMessage voice = (VoiceMessage) content;
             map.putString("url", voice.getUrl());
             map.putString("localPath", voice.getLocalPath());
             map.putInt("duration", voice.getDuration());
+        } else if (contentType.equals("jgrn:custom")) {
+            GenericCustomMessage genericCustomMessage = (GenericCustomMessage) content;
+            byte[] data = genericCustomMessage.encode();
+            if (data != null) {
+                try {
+                    String jsonStr = new String(data, StandardCharsets.UTF_8);
+                    JSONObject jsonObject = new JSONObject(jsonStr);
+                    map = convertJSONToWritableMap(jsonObject);
+                } catch (JSONException e) {
+                    Log.e("JuggleIM", "解析自定义消息失败: " + e.getMessage());
+                }
+            } else {
+                Log.e("JuggleIM", "No data for contentType: " + contentType);
+            }
         } else {
-            Log.e("JuggleIM", "Unknown contentType: " + content.getContentType());
+            Log.e("JuggleIM", "Unknown contentType: " + contentType);
             return RNTypeConverter.toWritableMap(content);
         }
+        Log.d("JuggleIM", "convertMessageContentToMap: " + map.getString("contentType"));
 
         return map;
     }
@@ -518,11 +561,160 @@ public class JuggleIMManager extends ReactContextBaseJavaModule {
                 voice.setDuration(map.getInt("duration"));
                 return voice;
             default:
+                // 检查是否是自定义消息
+                if (customMessageTypes.containsKey(contentType)) {
+                    return createCustomMessage(map);
+                }
                 Log.e("JuggleIM", "contentType: " + contentType);
                 return RNTypeConverter.fromReadableMap(map, MessageContent.class);
         }
     }
 
+    /**
+     * 创建自定义消息对象
+     */
+    private MessageContent createCustomMessage(ReadableMap map) {
+        try {
+            // 将 ReadableMap 转换为 JSON
+            JSONObject jsonObject = convertReadableMapToJSON(map);
+            String jsonStr = jsonObject.toString();
+            
+            // 创建通用自定义消息对象
+            GenericCustomMessage customMsg = new GenericCustomMessage();
+            customMsg.setData(jsonStr.getBytes(StandardCharsets.UTF_8));
+            
+            return customMsg;
+        } catch (JSONException e) {
+            Log.e("JuggleIM", "创建自定义消息失败: " + e.getMessage());
+            return null;
+        }
+    }
+
+    /**
+     * 将 ReadableMap 转换为 JSONObject
+     */
+    private JSONObject convertReadableMapToJSON(ReadableMap map) throws JSONException {
+        JSONObject jsonObject = new JSONObject();
+        ReadableMapKeySetIterator iterator = map.keySetIterator();
+        
+        while (iterator.hasNextKey()) {
+            String key = iterator.nextKey();
+            switch (map.getType(key)) {
+                case Null:
+                    jsonObject.put(key, JSONObject.NULL);
+                    break;
+                case Boolean:
+                    jsonObject.put(key, map.getBoolean(key));
+                    break;
+                case Number:
+                    jsonObject.put(key, map.getDouble(key));
+                    break;
+                case String:
+                    jsonObject.put(key, map.getString(key));
+                    break;
+                case Map:
+                    jsonObject.put(key, convertReadableMapToJSON(map.getMap(key)));
+                    break;
+                case Array:
+                    jsonObject.put(key, convertReadableArrayToJSONArray(map.getArray(key)));
+                    break;
+            }
+        }
+        
+        return jsonObject;
+    }
+
+    /**
+     * 将 ReadableArray 转换为 JSONArray
+     */
+    private JSONArray convertReadableArrayToJSONArray(ReadableArray array) throws JSONException {
+        JSONArray jsonArray = new JSONArray();
+        
+        for (int i = 0; i < array.size(); i++) {
+            switch (array.getType(i)) {
+                case Null:
+                    jsonArray.put(JSONObject.NULL);
+                    break;
+                case Boolean:
+                    jsonArray.put(array.getBoolean(i));
+                    break;
+                case Number:
+                    jsonArray.put(array.getDouble(i));
+                    break;
+                case String:
+                    jsonArray.put(array.getString(i));
+                    break;
+                case Map:
+                    jsonArray.put(convertReadableMapToJSON(array.getMap(i)));
+                    break;
+                case Array:
+                    jsonArray.put(convertReadableArrayToJSONArray(array.getArray(i)));
+                    break;
+            }
+        }
+        
+        return jsonArray;
+    }
+
+    /**
+     * 将 JSONObject 转换为 WritableMap
+     */
+    private WritableMap convertJSONToWritableMap(JSONObject jsonObject) throws JSONException {
+        WritableMap map = new WritableNativeMap();
+        
+        Iterator<String> iterator = jsonObject.keys();
+        while (iterator.hasNext()) {
+            String key = iterator.next();
+            Object value = jsonObject.get(key);
+            if (value instanceof JSONObject) {
+                map.putMap(key, convertJSONToWritableMap((JSONObject) value));
+            } else if (value instanceof JSONArray) {
+                map.putArray(key, convertJSONArrayToWritableArray((JSONArray) value));
+            } else if (value instanceof Boolean) {
+                map.putBoolean(key, (Boolean) value);
+            } else if (value instanceof Integer) {
+                map.putInt(key, (Integer) value);
+            } else if (value instanceof Double) {
+                map.putDouble(key, (Double) value);
+            } else if (value instanceof String) {
+                map.putString(key, (String) value);
+            } else if (value == JSONObject.NULL) {
+                map.putNull(key);
+            }
+        }
+        
+        return map;
+    }
+
+    /**
+     * 将 JSONArray 转换为 WritableArray
+     */
+    private WritableArray convertJSONArrayToWritableArray(JSONArray jsonArray) throws JSONException {
+        WritableArray array = new WritableNativeArray();
+        
+        for (int i = 0; i < jsonArray.length(); i++) {
+            Object value = jsonArray.get(i);
+            
+            if (value instanceof JSONObject) {
+                array.pushMap(convertJSONToWritableMap((JSONObject) value));
+            } else if (value instanceof JSONArray) {
+                array.pushArray(convertJSONArrayToWritableArray((JSONArray) value));
+            } else if (value instanceof Boolean) {
+                array.pushBoolean((Boolean) value);
+            } else if (value instanceof Integer) {
+                array.pushInt((Integer) value);
+            } else if (value instanceof Double) {
+                array.pushDouble((Double) value);
+            } else if (value instanceof String) {
+                array.pushString((String) value);
+            } else if (value == JSONObject.NULL) {
+                array.pushNull();
+            }
+        }
+        
+        return array;
+    }
+
     /**
      * 将消息回应转换为Map
      */
@@ -768,6 +960,9 @@ public class JuggleIMManager extends ReactContextBaseJavaModule {
      * 将 ConversationInfo 转换为 WritableMap
      */
     private WritableMap convertConversationInfoToMap(ConversationInfo info) {
+        if (info == null) {
+            return null;
+        }
         WritableMap map = new WritableNativeMap();
         map.putMap("conversation", convertConversationToMap(info.getConversation()));
         map.putInt("unreadCount", info.getUnreadCount());
@@ -793,13 +988,18 @@ public class JuggleIMManager extends ReactContextBaseJavaModule {
      * 将 MentionInfo 转换为 WritableMap
      */
     private WritableMap convertMentionInfoToMap(MessageMentionInfo mentionInfo) {
+        if (mentionInfo == null) {
+            return null;
+        }
         WritableMap map = new WritableNativeMap();
         WritableArray userMap = new WritableNativeArray();
         map.putInt("type", mentionInfo.getType().getValue());
-        for (UserInfo userInfo : mentionInfo.getTargetUsers()) {
-            userMap.pushMap(convertUserInfoToMap(userInfo));
+        if (mentionInfo.getTargetUsers() != null) { 
+            for (UserInfo userInfo : mentionInfo.getTargetUsers()) {
+                userMap.pushMap(convertUserInfoToMap(userInfo));
+            }
+            map.putArray("targetUsers", userMap);
         }
-        map.putArray("targetUsers", userMap);
         return map;
     }
 

package/ios/GenericCustomMessage.h

@@ -0,0 +1,24 @@
+#import <JuggleIM/JuggleIM.h>
+
+/**
+ * 通用自定义消息类
+ * 用于承载 RN 层自定义消息的 JSON 数据
+ */
+@interface GenericCustomMessage : JMessageContent
+
+/**
+ * 消息数据
+ */
+@property(nonatomic, strong) NSData *data;
+
+/**
+ * 设置消息数据
+ */
+- (void)setData:(NSData *)data;
+
+/**
+ * 获取消息数据
+ */
+- (NSData *)getData;
+
+@end

package/ios/GenericCustomMessage.m

@@ -0,0 +1,29 @@
+#import "GenericCustomMessage.h"
+
+@implementation GenericCustomMessage
+
++ (NSString *)contentType {
+  return @"jgrn:custom";
+}
+
+- (NSData *)encode {
+  return self.data;
+}
+
+- (void)decode:(NSData *)data {
+  self.data = data;
+}
+
+- (void)setData:(NSData *)data {
+  _data = data;
+}
+
+- (NSData *)getData {
+  return _data;
+}
+
+- (NSString *)conversationDigest {
+  return @"[自定义消息]";
+}
+
+@end

package/ios/JuggleIMManager.m

@@ -1,4 +1,5 @@
 #import "JuggleIMManager.h"
+#import "GenericCustomMessage.h"
 #import <JuggleIM/JuggleIM.h>
 #import <React/RCTEventEmitter.h>
 
@@ -9,10 +10,20 @@
                                JMessageReadReceiptDelegate,
                                JMessageDestroyDelegate, JConversationDelegate>
 
+// 自定义消息类型注册表
+@property(nonatomic, strong) NSMutableDictionary *customMessageTypes;
+
 @end
 
 @implementation JuggleIMManager
 
+- (instancetype)init {
+  if (self = [super init]) {
+    _customMessageTypes = [NSMutableDictionary dictionary];
+  }
+  return self;
+}
+
 RCT_EXPORT_MODULE(JuggleIM);
 
 RCT_EXPORT_METHOD(setServerUrls : (NSArray *)urls) {
@@ -22,6 +33,19 @@ RCT_EXPORT_METHOD(setServerUrls : (NSArray *)urls) {
 RCT_EXPORT_METHOD(initWithAppKey : (NSString *)appKey) {
   [[JIM shared] initWithAppKey:appKey];
   [JIM.shared setConsoleLogLevel:JLogLevelVerbose];
+  [JIM.shared.messageManager registerContentType:[GenericCustomMessage class]];
+}
+
+/**
+ * 注册自定义消息类型
+ */
+RCT_EXPORT_METHOD(registerCustomMessageType : (NSString *)contentType) {
+  if ([contentType hasPrefix:@"jg:"]) {
+    NSLog(@"contentType 不能以 'jg:' 开头");
+    return;
+  }
+  self.customMessageTypes[contentType] = contentType;
+  NSLog(@"注册自定义消息类型: %@", contentType);
 }
 
 RCT_EXPORT_METHOD(connectWithToken : (NSString *)token) {
@@ -419,7 +443,8 @@ RCT_EXPORT_METHOD(addConversationDelegate) {
  */
 - (NSDictionary *)convertMessageContentToDictionary:(JMessageContent *)content {
   NSMutableDictionary *dict = [NSMutableDictionary dictionary];
-  dict[@"contentType"] = [[content class] contentType] ?: @"";
+  NSString *contentType = [[content class] contentType];
+  dict[@"contentType"] = contentType ?: @"";
 
   if ([content isKindOfClass:[JTextMessage class]]) {
     JTextMessage *textMsg = (JTextMessage *)content;
@@ -447,6 +472,23 @@ RCT_EXPORT_METHOD(addConversationDelegate) {
     dict[@"localPath"] = voiceMsg.localPath ?: @"";
     dict[@"duration"] = @(voiceMsg.duration);
     dict[@"extra"] = voiceMsg.extra ?: @"";
+  } else if ([contentType isEqualToString:@"jgrn:custom"]) {
+    // 处理自定义消息:解析 JSON 数据
+    GenericCustomMessage *customMsg = (GenericCustomMessage *)content;
+    NSData *data = [customMsg encode];
+    if (data) {
+      NSError *error = nil;
+      NSDictionary *jsonDict = [NSJSONSerialization JSONObjectWithData:data
+                                                               options:0
+                                                                 error:&error];
+      if (!error && jsonDict) {
+        dict = [jsonDict mutableCopy];
+      } else {
+        NSLog(@"解析自定义消息失败: %@", error.localizedDescription);
+      }
+    }
+  } else {
+    NSLog(@"Unknown contentType: %@", contentType);
   }
 
   return dict;
@@ -1291,6 +1333,9 @@ RCT_EXPORT_METHOD(removeMessageReaction : (
     voice.localPath = messageDict[@"localPath"];
     voice.duration = [messageDict[@"duration"] integerValue];
     return voice;
+  } else if (self.customMessageTypes[contentType]) {
+    // 处理自定义消息:将字典转换为 JSON 数据
+    return [self createCustomMessageFromDict:messageDict];
   }
 
   return nil;
@@ -1406,6 +1451,32 @@ RCT_EXPORT_METHOD(removeMessageReaction : (
   return userInfo;
 }
 
+/**
+ * 创建自定义消息对象
+ */
+- (JMessageContent *)createCustomMessageFromDict:(NSDictionary *)dict {
+  @try {
+    // 将字典转换为 JSON 数据
+    NSError *error = nil;
+    NSData *jsonData = [NSJSONSerialization dataWithJSONObject:dict
+                                                       options:0
+                                                         error:&error];
+    if (error || !jsonData) {
+      NSLog(@"创建自定义消息失败: %@", error.localizedDescription);
+      return nil;
+    }
+
+    // 创建通用自定义消息对象
+    GenericCustomMessage *customMsg = [[GenericCustomMessage alloc] init];
+    [customMsg setData:jsonData];
+
+    return customMsg;
+  } @catch (NSException *exception) {
+    NSLog(@"创建自定义消息异常: %@", exception.reason);
+    return nil;
+  }
+}
+
 /**
  * 发送消息已读回执
  */

package/package.json

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

package/src/index.d.ts

@@ -36,9 +36,39 @@ declare module "juggleim-rnsdk" {
    *           枚举：jg:text, jg:img, jg:file, jg:voice
    */
   export abstract class MessageContent {
-    abstract contentType: string;
+    contentType: string;
   }
 
+  /**
+   * 自定义消息内容
+   * 实现示例：
+   * ```
+   * export class TextCardMessage extends CustomMessageContent {
+   *  title: string = '';
+   *  description: string = '';
+   *  url: string = '';
+   *  constructor(title?: string, description?: string, url?: string) {
+   *     super('demo:textcard');
+   *     this.title = title || '';
+   *     this.description = description || '';
+   *     this.url = url || '';
+   * }
+   * ```
+   * 
+   * 自定义消息注册
+   * ```
+   * JuggleIM.registerCustomMessageType('demo:textcard', TextCardMessage);
+   * ```
+   */
+  export class CustomMessageContent extends MessageContent {
+    constructor(contentType: string);
+  }
+
+  /**
+   * 自定义消息类构造函数类型
+   */
+  export type CustomMessageConstructor = new () => MessageContent;
+
   /**
    * 文本消息内容
    */
@@ -68,7 +98,6 @@ declare module "juggleim-rnsdk" {
       previewList?: MergeMessagePreviewUnit[]
     );
 
-    // 对应 Java 字段
     title?: string;
     containerMsgId?: string;
     conversation?: Conversation;
@@ -278,7 +307,7 @@ declare module "juggleim-rnsdk" {
 
   export interface ConversationInfo {
     conversation: Conversation;
-    unreadMessageCount: number;
+    unreadCount: number;
     isTop: boolean;
     isMute: boolean;
     lastMessage?: Message;
@@ -340,6 +369,8 @@ declare module "juggleim-rnsdk" {
     count?: number;
     startTime?: number;
   }
+
+  // 发送消息实体对象
   export interface SendMessageObject {
     conversationType: number;
     conversationId: string;
@@ -445,6 +476,25 @@ declare module "juggleim-rnsdk" {
      */
     static init(appKey: string): void;
 
+    /**
+     * 注册自定义消息类型
+     * @param contentType 消息类型标识符(不能以 "jg:" 开头)
+     * @param messageClass 自定义消息类的构造函数
+     * @example
+     * ```typescript
+     * class CustomMessage implements CustomMessageContent {
+     *   contentType = 'my:custom';
+     *   value: string = '';
+     * }
+     * 
+     * JuggleIM.registerCustomMessageType('my:custom', CustomMessage);
+     * ```
+     */
+    static registerCustomMessageType(
+      contentType: string,
+      messageClass: CustomMessageConstructor
+    ): void;
+
     /**
      * 连接到服务器
      * @param token 用户token
@@ -796,13 +846,11 @@ declare module "juggleim-rnsdk" {
      * 发送消息已读回执
      * @param conversation 会话对象
      * @param messageIds 消息ID列表
-     * @param callback 回调函数
      * @returns {Promise<Boolean>} 是否发送成功
      */
     static sendReadReceipt(
       conversation: Conversation,
       messageIds: string[],
-      callback?: SimpleCallback
     ): Promise<Boolean>;
 
     /**
@@ -817,7 +865,6 @@ declare module "juggleim-rnsdk" {
       messageId: string,
       conversation: Conversation,
       isTop: boolean,
-      callback?: SimpleCallback
     ): Promise<Boolean>;
   }
 }