juggleim-rnsdk 0.1.10 → 0.1.11

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.27.1'
+    implementation 'com.juggle.im:juggle:1.8.28.1'
     implementation 'com.juggle.call.zego:juggle:1.8.25'
     implementation 'im.zego:express-video:3.17.3'
 }

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

@@ -18,6 +18,8 @@ public class JuggleIMPackage implements ReactPackage {
         List<NativeModule> modules = new ArrayList<>();
         modules.add(new JuggleIMManager(reactContext));
         modules.add(new com.juggleim.call.JuggleIMCallModule(reactContext));
+        modules.add(new com.juggleim.moment.JuggleIMMomentModule(reactContext));
+
         return modules;
     }
 

package/android/src/main/java/com/juggleim/moment/JuggleIMMomentModule.java

@@ -0,0 +1,376 @@
+package com.juggleim.moment;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableArray;
+import com.facebook.react.bridge.WritableMap;
+import com.juggle.im.JIM;
+import com.juggle.im.JIMConst;
+import com.juggle.im.interfaces.IMessageManager;
+import com.juggle.im.interfaces.IMomentManager;
+import com.juggle.im.model.GetMomentCommentOption;
+import com.juggle.im.model.GetMomentOption;
+import com.juggle.im.model.Moment;
+import com.juggle.im.model.MomentComment;
+import com.juggle.im.model.MomentMedia;
+import com.juggle.im.model.MomentMedia.MomentMediaType;
+import com.juggle.im.model.MomentReaction;
+import com.juggle.im.model.UserInfo;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import javax.annotation.Nonnull;
+
+public class JuggleIMMomentModule extends ReactContextBaseJavaModule {
+    private static final String MODULE_NAME = "JuggleIMMomentModule";
+
+    public JuggleIMMomentModule(ReactApplicationContext reactContext) {
+        super(reactContext);
+    }
+
+    @Nonnull
+    @Override
+    public String getName() {
+        return MODULE_NAME;
+    }
+
+    private IMomentManager getMomentManager() {
+        return JIM.getInstance().getMomentManager();
+    }
+
+    @ReactMethod
+    public void addMoment(String content, ReadableArray mediaList, Promise promise) {
+        List<MomentMedia> list = new ArrayList<>();
+        if (mediaList != null) {
+            for (int i = 0; i < mediaList.size(); i++) {
+                list.add(convertReadableMapToMomentMedia(mediaList.getMap(i)));
+            }
+        }
+        getMomentManager().addMoment(content, list, new JIMConst.IResultCallback<Moment>() {
+            @Override
+            public void onSuccess(Moment moment) {
+                promise.resolve(convertMomentToWritableMap(moment));
+            }
+
+            @Override
+            public void onError(int errorCode) {
+                reject(promise, errorCode);
+            }
+        });
+    }
+
+    @ReactMethod
+    public void removeMoment(String momentId, Promise promise) {
+        getMomentManager().removeMoment(momentId, new IMessageManager.ISimpleCallback() {
+            @Override
+            public void onSuccess() {
+                promise.resolve(null);
+            }
+
+            @Override
+            public void onError(int errorCode) {
+                reject(promise, errorCode);
+            }
+        });
+    }
+
+    @ReactMethod
+    public void getCachedMomentList(ReadableMap optionMap, Promise promise) {
+        GetMomentOption option = convertReadableMapToGetMomentOption(optionMap);
+        List<Moment> list = getMomentManager().getCachedMomentList(option);
+        WritableArray array = Arguments.createArray();
+        if (list != null) {
+            for (Moment moment : list) {
+                array.pushMap(convertMomentToWritableMap(moment));
+            }
+        }
+        promise.resolve(array);
+    }
+
+    @ReactMethod
+    public void getMomentList(ReadableMap optionMap, Promise promise) {
+        GetMomentOption option = convertReadableMapToGetMomentOption(optionMap);
+        getMomentManager().getMomentList(option, new JIMConst.IResultListCallback<Moment>() {
+            @Override
+            public void onSuccess(List<Moment> moments, boolean isFinish) {
+                WritableMap result = Arguments.createMap();
+                WritableArray array = Arguments.createArray();
+                for (Moment moment : moments) {
+                    array.pushMap(convertMomentToWritableMap(moment));
+                }
+                result.putArray("list", array);
+                result.putBoolean("isFinished", isFinish);
+                promise.resolve(result);
+            }
+
+            @Override
+            public void onError(int errorCode) {
+                reject(promise, errorCode);
+            }
+        });
+    }
+
+    @ReactMethod
+    public void getMoment(String momentId, Promise promise) {
+        getMomentManager().getMoment(momentId, new JIMConst.IResultCallback<Moment>() {
+            @Override
+            public void onSuccess(Moment moment) {
+                promise.resolve(convertMomentToWritableMap(moment));
+            }
+
+            @Override
+            public void onError(int errorCode) {
+                reject(promise, errorCode);
+            }
+        });
+    }
+
+    @ReactMethod
+    public void addComment(String momentId, String parentCommentId, String content, Promise promise) {
+        getMomentManager().addComment(momentId, parentCommentId, content,
+                new JIMConst.IResultCallback<MomentComment>() {
+                    @Override
+                    public void onSuccess(MomentComment comment) {
+                        promise.resolve(convertMomentCommentToWritableMap(comment));
+                    }
+
+                    @Override
+                    public void onError(int errorCode) {
+                        reject(promise, errorCode);
+                    }
+                });
+    }
+
+    @ReactMethod
+    public void removeComment(String momentId, String commentId, Promise promise) {
+        getMomentManager().removeComment(momentId, commentId, new IMessageManager.ISimpleCallback() {
+            @Override
+            public void onSuccess() {
+                promise.resolve(null);
+            }
+
+            @Override
+            public void onError(int errorCode) {
+                reject(promise, errorCode);
+            }
+        });
+    }
+
+    @ReactMethod
+    public void getCommentList(ReadableMap optionMap, Promise promise) {
+        GetMomentCommentOption option = convertReadableMapToGetMomentCommentOption(optionMap);
+        getMomentManager().getCommentList(option, new JIMConst.IResultListCallback<MomentComment>() {
+            @Override
+            public void onSuccess(List<MomentComment> comments, boolean isFinish) {
+                WritableMap result = Arguments.createMap();
+                WritableArray array = Arguments.createArray();
+                for (MomentComment comment : comments) {
+                    array.pushMap(convertMomentCommentToWritableMap(comment));
+                }
+                result.putArray("list", array);
+                result.putBoolean("isFinished", isFinish);
+                promise.resolve(result);
+            }
+
+            @Override
+            public void onError(int errorCode) {
+                reject(promise, errorCode);
+            }
+        });
+    }
+
+    @ReactMethod
+    public void addReaction(String momentId, String key, Promise promise) {
+        getMomentManager().addReaction(momentId, key, new IMessageManager.ISimpleCallback() {
+            @Override
+            public void onSuccess() {
+                promise.resolve(null);
+            }
+
+            @Override
+            public void onError(int errorCode) {
+                reject(promise, errorCode);
+            }
+        });
+    }
+
+    @ReactMethod
+    public void removeReaction(String momentId, String key, Promise promise) {
+        getMomentManager().removeReaction(momentId, key, new IMessageManager.ISimpleCallback() {
+            @Override
+            public void onSuccess() {
+                promise.resolve(null);
+            }
+
+            @Override
+            public void onError(int errorCode) {
+                reject(promise, errorCode);
+            }
+        });
+    }
+
+    @ReactMethod
+    public void getReactionList(String momentId, Promise promise) {
+        getMomentManager().getReactionList(momentId, new JIMConst.IResultListCallback<MomentReaction>() {
+            @Override
+            public void onSuccess(List<MomentReaction> reactions, boolean isFinish) {
+                WritableArray array = Arguments.createArray();
+                for (MomentReaction reaction : reactions) {
+                    array.pushMap(convertMomentReactionToWritableMap(reaction));
+                }
+                promise.resolve(array);
+            }
+
+            @Override
+            public void onError(int errorCode) {
+                reject(promise, errorCode);
+            }
+        });
+    }
+
+    // Helper methods
+
+    private void reject(Promise promise, int errorCode) {
+        WritableMap map = Arguments.createMap();
+        map.putInt("code", errorCode);
+        promise.reject(String.valueOf(errorCode), map);
+    }
+
+    private MomentMedia convertReadableMapToMomentMedia(ReadableMap map) {
+        MomentMedia media = new MomentMedia();
+        String typeStr = map.getString("type");
+        if ("image".equals(typeStr)) {
+            media.setType(MomentMediaType.IMAGE);
+        } else if ("video".equals(typeStr)) {
+            media.setType(MomentMediaType.VIDEO);
+        }
+        if (map.hasKey("url"))
+            media.setUrl(map.getString("url"));
+        if (map.hasKey("snapshotUrl"))
+            media.setSnapshotUrl(map.getString("snapshotUrl"));
+        if (map.hasKey("width"))
+            media.setWidth(map.getInt("width"));
+        if (map.hasKey("height"))
+            media.setHeight(map.getInt("height"));
+        if (map.hasKey("duration"))
+            media.setDuration(map.getInt("duration"));
+        return media;
+    }
+
+    private GetMomentOption convertReadableMapToGetMomentOption(ReadableMap map) {
+        GetMomentOption option = new GetMomentOption();
+        if (map.hasKey("count"))
+            option.setCount(map.getInt("count"));
+        if (map.hasKey("timestamp"))
+            // option.setTimestamp((long) map.getDouble("timestamp"));
+            option.setStartTime((long) map.getDouble("timestamp"));
+        if (map.hasKey("direction")) {
+            int dir = map.getInt("direction");
+            option.setDirection(dir == 0 ? JIMConst.PullDirection.NEWER : JIMConst.PullDirection.OLDER);
+        }
+        return option;
+    }
+
+    private GetMomentCommentOption convertReadableMapToGetMomentCommentOption(ReadableMap map) {
+        GetMomentCommentOption option = new GetMomentCommentOption();
+        if (map.hasKey("momentId"))
+            option.setMomentId(map.getString("momentId"));
+        if (map.hasKey("count"))
+            option.setCount(map.getInt("count"));
+        if (map.hasKey("timestamp"))
+            // option.setTimestamp((long) map.getDouble("timestamp"));
+            option.setStartTime((long) map.getDouble("timestamp"));
+        if (map.hasKey("direction")) {
+            int dir = map.getInt("direction");
+            option.setDirection(dir == 0 ? JIMConst.PullDirection.NEWER : JIMConst.PullDirection.OLDER);
+        }
+        return option;
+    }
+
+    private WritableMap convertMomentToWritableMap(Moment moment) {
+        WritableMap map = Arguments.createMap();
+        map.putString("momentId", moment.getMomentId());
+        map.putString("content", moment.getContent());
+        map.putMap("userInfo", convertUserInfoToWritableMap(moment.getUserInfo()));
+        map.putDouble("createTime", moment.getCreateTime());
+
+        WritableArray mediaList = Arguments.createArray();
+        if (moment.getMediaList() != null) {
+            for (MomentMedia media : moment.getMediaList()) {
+                mediaList.pushMap(convertMomentMediaToWritableMap(media));
+            }
+        }
+        map.putArray("mediaList", mediaList);
+
+        WritableArray commentList = Arguments.createArray();
+        if (moment.getCommentList() != null) {
+            for (MomentComment comment : moment.getCommentList()) {
+                commentList.pushMap(convertMomentCommentToWritableMap(comment));
+            }
+        }
+        map.putArray("commentList", commentList);
+
+        WritableArray reactionList = Arguments.createArray();
+        if (moment.getReactionList() != null) {
+            for (MomentReaction reaction : moment.getReactionList()) {
+                reactionList.pushMap(convertMomentReactionToWritableMap(reaction));
+            }
+        }
+        map.putArray("reactionList", reactionList);
+
+        return map;
+    }
+
+    private WritableMap convertMomentMediaToWritableMap(MomentMedia media) {
+        WritableMap map = Arguments.createMap();
+        map.putString("type", media.getType() == MomentMediaType.IMAGE ? "image" : "video");
+        map.putString("url", media.getUrl());
+        map.putString("snapshotUrl", media.getSnapshotUrl());
+        map.putInt("width", media.getWidth());
+        map.putInt("height", media.getHeight());
+        map.putInt("duration", media.getDuration());
+        return map;
+    }
+
+    private WritableMap convertMomentCommentToWritableMap(MomentComment comment) {
+        WritableMap map = Arguments.createMap();
+        map.putString("commentId", comment.getCommentId());
+        map.putString("momentId", comment.getMomentId());
+        map.putString("parentCommentId", comment.getParentCommentId());
+        map.putString("content", comment.getContent());
+        map.putMap("userInfo", convertUserInfoToWritableMap(comment.getUserInfo()));
+        if (comment.getParentUserInfo() != null) {
+            map.putMap("parentUserInfo", convertUserInfoToWritableMap(comment.getParentUserInfo()));
+        }
+        map.putDouble("createTime", comment.getCreateTime());
+        return map;
+    }
+
+    private WritableMap convertMomentReactionToWritableMap(MomentReaction reaction) {
+        WritableMap map = Arguments.createMap();
+        map.putString("key", reaction.getKey());
+        WritableArray userList = Arguments.createArray();
+        if (reaction.getUserList() != null) {
+            for (UserInfo userInfo : reaction.getUserList()) {
+                userList.pushMap(convertUserInfoToWritableMap(userInfo));
+            }
+        }
+        map.putArray("userList", userList);
+        return map;
+    }
+
+    private WritableMap convertUserInfoToWritableMap(UserInfo userInfo) {
+        WritableMap map = Arguments.createMap();
+        map.putString("userId", userInfo.getUserId());
+        map.putString("nickname", userInfo.getUserName());
+        map.putString("avatar", userInfo.getPortrait());
+        // Add other fields if necessary
+        return map;
+    }
+}

package/ios/JModelFactory.m

@@ -391,7 +391,7 @@
   return @{
     @"url" : media.url ?: @"",
     @"type" : @(media.type),
-    @"snapshot_url" : media.snapshotUrl ?: @"",
+    @"snapshotUrl" : media.snapshotUrl ?: @"",
     @"height" : @(media.height),
     @"width" : @(media.width),
     @"duration" : @(media.duration)
@@ -412,13 +412,13 @@
   if (!comment)
     return @{};
   return @{
-    @"comment_id" : comment.commentId ?: @"",
-    @"moment_id" : comment.momentId ?: @"",
-    @"parent_comment_id" : comment.parentCommentId ?: @"",
+    @"commentId" : comment.commentId ?: @"",
+    @"momentId" : comment.momentId ?: @"",
+    @"parentCommentId" : comment.parentCommentId ?: @"",
     @"content" : comment.content ?: @"",
-    @"user_info" : [self userInfoToDic:comment.userInfo],
-    @"parent_user_info" : [self userInfoToDic:comment.parentUserInfo],
-    @"comment_time" : @(comment.createTime)
+    @"userInfo" : [self userInfoToDic:comment.userInfo],
+    @"parentUserInfo" : [self userInfoToDic:comment.parentUserInfo],
+    @"commentTime" : @(comment.createTime)
   };
 }
 
@@ -427,12 +427,12 @@
     return @{};
   NSMutableDictionary *resultDic = [NSMutableDictionary dictionary];
   NSString *momentId = moment.momentId ?: @"";
-  resultDic[@"moment_id"] = momentId;
+  resultDic[@"momentId"] = momentId;
   NSString *contentText = moment.content ?: @"";
-  resultDic[@"content"] = @{@"text" : contentText};
-  resultDic[@"moment_time"] = @(moment.createTime);
+  resultDic[@"content"] = contentText ?: @"";
+  resultDic[@"createTime"] = @(moment.createTime);
   if (moment.userInfo && [moment.userInfo isKindOfClass:[JUserInfo class]]) {
-    resultDic[@"user_info"] = [self userInfoToDic:moment.userInfo];
+    resultDic[@"userInfo"] = [self userInfoToDic:moment.userInfo];
   }
   NSArray *mediaArray = moment.mediaArray ?: @[];
   NSMutableArray *mediasDicArray =
@@ -442,7 +442,7 @@
       [mediasDicArray addObject:[self momentMediaToDic:media]];
     }
   }
-  resultDic[@"medias"] = mediasDicArray;
+  resultDic[@"mediaList"] = mediasDicArray;
 
   NSArray *reactionArray = moment.reactionArray ?: @[];
   NSMutableArray *reactionsDicArray =
@@ -462,7 +462,7 @@
       [commentsDicArray addObject:[self momentCommentToDic:comment]];
     }
   }
-  resultDic[@"top_comments"] = commentsDicArray;
+  resultDic[@"commentList"] = commentsDicArray;
 
   return [resultDic copy];
 }
@@ -543,7 +543,7 @@
   JMomentMedia *media = [[JMomentMedia alloc] init];
 
   media.url = dictionary[@"url"];
-  media.snapshotUrl = dictionary[@"snapshot_url"];
+  media.snapshotUrl = dictionary[@"snapshotUrl"];
   media.type = [dictionary[@"type"] intValue];
   media.height = [dictionary[@"height"] intValue];
   media.width = [dictionary[@"width"] intValue];

package/ios/moment/JuggleIMMomentModule.h

@@ -0,0 +1,5 @@
+#import <React/RCTBridgeModule.h>
+
+@interface JuggleIMMomentModule : NSObject <RCTBridgeModule>
+
+@end

package/ios/moment/JuggleIMMomentModule.m

@@ -0,0 +1,207 @@
+#import "JuggleIMMomentModule.h"
+#import "../JModelFactory.h"
+#import <JuggleIM/JuggleIM.h>
+
+@implementation JuggleIMMomentModule
+
+RCT_EXPORT_MODULE()
+
+- (id<JMomentProtocol>)getMomentManager {
+  return [JIM.shared momentManager];
+}
+
+RCT_EXPORT_METHOD(addMoment : (NSString *)content mediaList : (NSArray *)
+                      mediaList resolver : (RCTPromiseResolveBlock)
+                          resolve rejecter : (RCTPromiseRejectBlock)reject) {
+  NSMutableArray *mediaArray = [NSMutableArray array];
+  if (mediaList) {
+    for (NSDictionary *dic in mediaList) {
+      JMomentMedia *media = [JModelFactory momentMediaFromDic:dic];
+      if (media) {
+        [mediaArray addObject:media];
+      }
+    }
+  }
+
+  [[self getMomentManager]
+      addMoment:content
+      mediaList:mediaArray
+       complete:^(JErrorCode errorCode, JMoment *_Nullable moment) {
+         if (errorCode == JErrorCodeNone) {
+           resolve([JModelFactory momentToDic:moment]);
+         } else {
+           reject([NSString stringWithFormat:@"%ld", (long)errorCode],
+                  @"addMoment failed", nil);
+         }
+       }];
+}
+
+RCT_EXPORT_METHOD(removeMoment : (NSString *)momentId resolver : (
+    RCTPromiseResolveBlock)resolve rejecter : (RCTPromiseRejectBlock)reject) {
+  [[self getMomentManager]
+      removeMoment:momentId
+          complete:^(JErrorCode errorCode) {
+            if (errorCode == JErrorCodeNone) {
+              resolve(nil);
+            } else {
+              reject([NSString stringWithFormat:@"%ld", (long)errorCode],
+                     @"removeMoment failed", nil);
+            }
+          }];
+}
+
+RCT_EXPORT_METHOD(getCachedMomentList : (NSDictionary *)optionMap resolver : (
+    RCTPromiseResolveBlock)resolve rejecter : (RCTPromiseRejectBlock)reject) {
+  JGetMomentOption *option = [JModelFactory getMomentOptionFromDic:optionMap];
+  NSArray *list = [[self getMomentManager] getCachedMomentList:option];
+  NSMutableArray *array = [NSMutableArray array];
+  for (JMoment *moment in list) {
+    [array addObject:[JModelFactory momentToDic:moment]];
+  }
+  resolve(array);
+}
+
+RCT_EXPORT_METHOD(getMomentList : (NSDictionary *)optionMap resolver : (
+    RCTPromiseResolveBlock)resolve rejecter : (RCTPromiseRejectBlock)reject) {
+  JGetMomentOption *option = [JModelFactory getMomentOptionFromDic:optionMap];
+  [[self getMomentManager]
+      getMomentList:option
+           complete:^(JErrorCode errorCode,
+                      NSArray<JMoment *> *_Nullable momentList, BOOL isFinish) {
+             if (errorCode == JErrorCodeNone) {
+               NSMutableArray *array = [NSMutableArray array];
+               for (JMoment *moment in momentList) {
+                 [array addObject:[JModelFactory momentToDic:moment]];
+               }
+               resolve(@{@"list" : array, @"isFinished" : @(isFinish)});
+             } else {
+               reject([NSString stringWithFormat:@"%ld", (long)errorCode],
+                      @"getMomentList failed", nil);
+             }
+           }];
+}
+
+RCT_EXPORT_METHOD(getMoment : (NSString *)momentId resolver : (
+    RCTPromiseResolveBlock)resolve rejecter : (RCTPromiseRejectBlock)reject) {
+  [[self getMomentManager]
+      getMoment:momentId
+       complete:^(JErrorCode errorCode, JMoment *_Nullable moment) {
+         if (errorCode == JErrorCodeNone) {
+           resolve([JModelFactory momentToDic:moment]);
+         } else {
+           reject([NSString stringWithFormat:@"%ld", (long)errorCode],
+                  @"getMoment failed", nil);
+         }
+       }];
+}
+
+RCT_EXPORT_METHOD(addComment : (NSString *)momentId parentCommentId : (
+    NSString *)parentCommentId content : (NSString *)
+                      content resolver : (RCTPromiseResolveBlock)
+                          resolve rejecter : (RCTPromiseRejectBlock)reject) {
+  [[self getMomentManager]
+           addComment:momentId
+      parentCommentId:parentCommentId
+              content:content
+             complete:^(JErrorCode errorCode,
+                        JMomentComment *_Nullable comment) {
+               if (errorCode == JErrorCodeNone) {
+                 resolve([JModelFactory momentCommentToDic:comment]);
+               } else {
+                 reject([NSString stringWithFormat:@"%ld", (long)errorCode],
+                        @"addComment failed", nil);
+               }
+             }];
+}
+
+RCT_EXPORT_METHOD(removeComment : (NSString *)momentId commentId : (NSString *)
+                      commentId resolver : (RCTPromiseResolveBlock)
+                          resolve rejecter : (RCTPromiseRejectBlock)reject) {
+  [[self getMomentManager]
+      removeComment:commentId
+           momentId:momentId
+           complete:^(JErrorCode errorCode) {
+             if (errorCode == JErrorCodeNone) {
+               resolve(nil);
+             } else {
+               reject([NSString stringWithFormat:@"%ld", (long)errorCode],
+                      @"removeComment failed", nil);
+             }
+           }];
+}
+
+RCT_EXPORT_METHOD(getCommentList : (NSDictionary *)optionMap resolver : (
+    RCTPromiseResolveBlock)resolve rejecter : (RCTPromiseRejectBlock)reject) {
+  JGetMomentCommentOption *option =
+      [JModelFactory getMomentCommentOptionFromDic:optionMap];
+  [[self getMomentManager]
+      getCommentList:option
+            complete:^(JErrorCode errorCode,
+                       NSArray<JMomentComment *> *_Nullable commentList,
+                       BOOL isFinish) {
+              if (errorCode == JErrorCodeNone) {
+                NSMutableArray *array = [NSMutableArray array];
+                for (JMomentComment *comment in commentList) {
+                  [array addObject:[JModelFactory momentCommentToDic:comment]];
+                }
+                resolve(@{@"list" : array, @"isFinished" : @(isFinish)});
+              } else {
+                reject([NSString stringWithFormat:@"%ld", (long)errorCode],
+                       @"getCommentList failed", nil);
+              }
+            }];
+}
+
+RCT_EXPORT_METHOD(addReaction : (NSString *)momentId key : (NSString *)
+                      key resolver : (RCTPromiseResolveBlock)
+                          resolve rejecter : (RCTPromiseRejectBlock)reject) {
+  [[self getMomentManager]
+      addReaction:momentId
+              key:key
+         complete:^(JErrorCode errorCode) {
+           if (errorCode == JErrorCodeNone) {
+             resolve(nil);
+           } else {
+             reject([NSString stringWithFormat:@"%ld", (long)errorCode],
+                    @"addReaction failed", nil);
+           }
+         }];
+}
+
+RCT_EXPORT_METHOD(removeReaction : (NSString *)momentId key : (NSString *)
+                      key resolver : (RCTPromiseResolveBlock)
+                          resolve rejecter : (RCTPromiseRejectBlock)reject) {
+  [[self getMomentManager]
+      removeReaction:momentId
+                 key:key
+            complete:^(JErrorCode errorCode) {
+              if (errorCode == JErrorCodeNone) {
+                resolve(nil);
+              } else {
+                reject([NSString stringWithFormat:@"%ld", (long)errorCode],
+                       @"removeReaction failed", nil);
+              }
+            }];
+}
+
+RCT_EXPORT_METHOD(getReactionList : (NSString *)momentId resolver : (
+    RCTPromiseResolveBlock)resolve rejecter : (RCTPromiseRejectBlock)reject) {
+  [[self getMomentManager]
+      getReactionList:momentId
+             complete:^(JErrorCode errorCode,
+                        NSArray<JMomentReaction *> *_Nullable reactionList) {
+               if (errorCode == JErrorCodeNone) {
+                 NSMutableArray *array = [NSMutableArray array];
+                 for (JMomentReaction *reaction in reactionList) {
+                   [array
+                       addObject:[JModelFactory momentReactionToDic:reaction]];
+                 }
+                 resolve(array);
+               } else {
+                 reject([NSString stringWithFormat:@"%ld", (long)errorCode],
+                        @"getReactionList failed", nil);
+               }
+             }];
+}
+
+@end

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.30"
+  s.dependency "JuggleIM", "~> 1.8.31"
   s.dependency 'JZegoCall', '1.8.25'
 
 end

package/package.json

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

package/src/index.d.ts

@@ -1,6 +1,9 @@
 
 export * from './types';
 export * from './call';
+export * from './moment/index';
+export * from './moment/types';
+
 
 import {
   ConnectionStatusListener,

package/src/index.js

@@ -983,4 +983,11 @@ class JuggleIM {
 
 export * from './types';
 export * from './call';
+export * from './moment/types';
+import { JuggleIMMoment } from './moment/index';
+
+export {
+  JuggleIMMoment,
+  JuggleIM
+};
 export default JuggleIM;

package/src/moment/index.ts

@@ -0,0 +1,85 @@
+
+import { NativeModules, Platform } from 'react-native';
+import { Moment, MomentComment, MomentReaction, GetMomentOption, GetMomentCommentOption } from './types';
+import { SimpleCallback, UserInfo } from '../types';
+
+const { JuggleIMMomentModule } = NativeModules;
+
+export class JuggleIMMoment {
+    /**
+     * 发布朋友圈
+     */
+    static addMoment(content: string, mediaList: any[]): Promise<Moment> {
+        return JuggleIMMomentModule.addMoment(content, mediaList);
+    }
+
+    /**
+     * 删除朋友圈
+     */
+    static removeMoment(momentId: string): Promise<void> {
+        return JuggleIMMomentModule.removeMoment(momentId);
+    }
+
+    /**
+     * 获取缓存的朋友圈列表
+     */
+    static getCachedMomentList(option: GetMomentOption): Promise<Moment[]> {
+        return JuggleIMMomentModule.getCachedMomentList(option);
+    }
+
+    /**
+     * 获取朋友圈列表
+     */
+    static getMomentList(option: GetMomentOption): Promise<{ list: Moment[], isFinished: boolean }> {
+        return JuggleIMMomentModule.getMomentList(option);
+    }
+
+    /**
+     * 获取朋友圈详情
+     */
+    static getMoment(momentId: string): Promise<Moment> {
+        return JuggleIMMomentModule.getMoment(momentId);
+    }
+
+    /**
+     * 发布评论
+     */
+    static addComment(momentId: string, parentCommentId: string, content: string): Promise<MomentComment> {
+        return JuggleIMMomentModule.addComment(momentId, parentCommentId, content);
+    }
+
+    /**
+     * 删除评论
+     */
+    static removeComment(momentId: string, commentId: string): Promise<void> {
+        return JuggleIMMomentModule.removeComment(momentId, commentId);
+    }
+
+    /**
+     * 获取评论列表
+     */
+    static getCommentList(option: GetMomentCommentOption): Promise<{ list: MomentComment[], isFinished: boolean }> {
+        return JuggleIMMomentModule.getCommentList(option);
+    }
+
+    /**
+     * 添加点赞
+     */
+    static addReaction(momentId: string, key: string): Promise<void> {
+        return JuggleIMMomentModule.addReaction(momentId, key);
+    }
+
+    /**
+     * 取消点赞
+     */
+    static removeReaction(momentId: string, key: string): Promise<void> {
+        return JuggleIMMomentModule.removeReaction(momentId, key);
+    }
+
+    /**
+     * 获取点赞列表
+     */
+    static getReactionList(momentId: string): Promise<MomentReaction[]> {
+        return JuggleIMMomentModule.getReactionList(momentId);
+    }
+}

package/src/moment/types.ts

@@ -0,0 +1,51 @@
+
+import { UserInfo, SimpleCallback } from '../types';
+
+export type MomentMediaType = 'image' | 'video';
+
+export interface MomentMedia {
+    type: MomentMediaType;
+    url: string;
+    snapshotUrl?: string; // For video thumbnail or image thumbnail
+    height: number;
+    width: number;
+    duration?: number; // Only for video
+}
+
+export interface MomentComment {
+    commentId: string;
+    momentId: string;
+    parentCommentId?: string;
+    content: string;
+    userInfo: UserInfo;
+    parentUserInfo?: UserInfo;
+    createTime: number;
+}
+
+export interface MomentReaction {
+    key: string;
+    userList: UserInfo[];
+}
+
+export interface Moment {
+    momentId: string;
+    content: string;
+    mediaList: MomentMedia[];
+    userInfo: UserInfo;
+    commentList: MomentComment[];
+    reactionList: MomentReaction[];
+    createTime: number;
+}
+
+export interface GetMomentOption {
+    count: number;
+    timestamp: number; // 0 for initial
+    direction: number; // 0 for new, 1 for old
+}
+
+export interface GetMomentCommentOption {
+    momentId: string;
+    count: number;
+    timestamp: number;
+    direction: number;
+}

package/ios/call/README.md

@@ -1,51 +0,0 @@
-# iOS Call Module - File Summary
-
-## Created Files
-
-### Bridge Module
-- `ios/call/JuggleIMCallModule.h` - Main bridge module header
-- `ios/call/JuggleIMCallModule.m` - Main bridge module implementation (450+ lines)
-
-### View Components
-- `ios/call/view/ZegoSurfaceView.h` - Video surface view header
-- `ios/call/view/ZegoSurfaceView.m` - Video surface view implementation
-- `ios/call/view/ZegoSurfaceViewManager.h` - View manager header
-- `ios/call/view/ZegoSurfaceViewManager.m` - View manager implementation
-
-## Modified Files
-
-### Field Mapping Fixes
-- `ios/JModelFactory.m`
-  - Line 330: `inviterId` → `inviter`
-  - Line 343: Added `currentMember` field
-  - Line 163: `userName` → `nickname`
-  - Line 167: `portrait` → `avatar`
-
-## Directory Structure
-```
-ios/
-├── call/
-│   ├── JuggleIMCallModule.h
-│   ├── JuggleIMCallModule.m
-│   └── view/
-│       ├── ZegoSurfaceView.h
-│       ├── ZegoSurfaceView.m
-│       ├── ZegoSurfaceViewManager.h
-│       └── ZegoSurfaceViewManager.m
-├── JModelFactory.h (existing, no changes)
-└── JModelFactory.m (modified)
-```
-
-## TODO Items
-
-See `walkthrough.md` for detailed TODO items that need verification:
-1. Zego engine initialization appSign parameter
-2. Remove delegate methods availability
-3. Video denoise parameters conversion
-
-## Next Steps
-
-1. Verify TODO items against iOS SDK
-2. Register modules in Xcode project/podspec
-3. Test compilation
-4. Test runtime functionality