feat. native ios & android refactor registerMediaMetaDataObserver

android/src/main/java/com/syan/agora/AgoraModule.java

     private final static String AGRtmpStreamingStateChanged = "rtmpStreamingStateChanged";
     private final static String AGNetworkTypeChanged = "networkTypeChanged";
     private final static String AGFirstRemoteAudioDecoded = "firstRemoteAudioDecoded";
-    private final static String AGMediaMetaDataRecevied = "mediaMetaDataRecevied";
+    private final static String AGMediaMetaDataReceived = "mediaMetaDataReceived";
     private final static String AGRemoteVideoStateChanged = "remoteVideoStateChanged";
     private final static String AGLocalPublishFallbackToAudioOnly = "localPublishFallbackToAudioOnly";
     private final static String AGRemoteSubscribeFallbackToAudioOnly = "remoteSubscribeFallbackToAudioOnly";
     private final static String AGLastmileProbeResult = "lastmileProbeTestResult";
 //    private final static String AGIntervalTest = "startEchoTestWithInterval";
 
+    private MediaObserver mediaObserver = null;
+
     private IRtcEngineEventHandler mRtcEventHandler = new IRtcEngineEventHandler() {
 
         @Override
         }
     }
 
-    private static final Integer MAX_META_DATA = 1024;
-
-    private byte[] metadata = null;
-
     @ReactMethod
-    public void sendMediaData(String data) {
-        metadata = data.getBytes(Charset.forName("UTF-8"));
+    public void sendMediaData(String data, final Promise promise) {
+        if (null == mediaObserver) {
+            promise.reject("-1", "sendMediaData failed");
+        } else {
+            mediaObserver.setMetadata(data.getBytes(Charset.forName("UTF-8")));
+            WritableMap map = Arguments.createMap();
+            map.putBoolean("success", true);
+            promise.resolve(map);
+        }
     }
 
     @ReactMethod
     public void registerMediaMetadataObserver(final Promise promise) {
         try {
-            int res = AgoraManager.getInstance().mRtcEngine.registerMediaMetadataObserver(new IMetadataObserver() {
-                @Override
-                public int getMaxMetadataSize() { return MAX_META_DATA; }
-
-                @Override
-                public byte[] onReadyToSendMetadata(long timeStampMs) {
-                    if (metadata == null) {
-                        return null;
-                    }
-                    byte[] toSend = metadata;
-                    if (toSend.length > MAX_META_DATA) {
-                        return null;
-                    }
-                    metadata = null;
-                    return toSend;
-                }
-
-                @Override
-                public void onMetadataReceived(byte[] buffer, int uid, long timeStampMs) {
-                    WritableMap map = Arguments.createMap();
-                    map.putString("data", new String(buffer, Charset.forName("UTF-8")));
-                    map.putString("uid", Integer.toString(uid));
-                    map.putString("ts", Long.toString(timeStampMs));
-                    sendEvent(getReactApplicationContext(), AGMediaMetaDataRecevied, map);
-                }
-            }, IMetadataObserver.VIDEO_METADATA);
+            mediaObserver = new MediaObserver(getReactApplicationContext());
+            int res = AgoraManager.getInstance().mRtcEngine
+                    .registerMediaMetadataObserver(mediaObserver, IMetadataObserver.VIDEO_METADATA);
             if (res < 0) {
-                new ReactNativeAgoraException("setRemoteDefaultVideoStreamType Failed", res);
+                new ReactNativeAgoraException("registerMediaMetadataObserver Failed", res);
             }
             WritableMap map = Arguments.createMap();
             map.putBoolean("success", true);
     }
 
 
-
     @ReactMethod
 
     private void sendEvent(ReactContext reactContext,
                 .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
                 .emit(eventName, params);
     }
-
 }

android/src/main/java/com/syan/agora/MediaObserver.java

+package com.syan.agora;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+
+import java.nio.charset.Charset;
+
+import io.agora.rtc.IMetadataObserver;
+
+public class MediaObserver implements IMetadataObserver {
+
+    private static final Integer MAX_DATA_LENGT = 1024;
+
+    private ReactContext reactCtx;
+
+    public byte[] getMetadata() {
+        return metadata;
+    }
+
+    public void setMetadata(byte[] metadata) {
+        this.metadata = metadata;
+    }
+
+    private byte[] metadata = null;
+
+    public MediaObserver(ReactContext reactCtx) {
+        this.reactCtx = reactCtx;
+    }
+
+    @Override
+    public int getMaxMetadataSize() {
+        return MAX_DATA_LENGT;
+    }
+
+    @Override
+    public byte[] onReadyToSendMetadata(long timeStampMs) {
+        if (metadata == null) {
+            return null;
+        }
+        byte[] toSend = metadata;
+        if (toSend.length > MAX_DATA_LENGT) {
+            return null;
+        }
+        metadata = null;
+        return toSend;
+    }
+
+    @Override
+    public void onMetadataReceived(byte[] buffer, int uid, long timeStampMs) {
+        WritableMap map = Arguments.createMap();
+        map.putString("data", new String(buffer, Charset.forName("UTF-8")));
+        map.putString("uid", Integer.toString(uid));
+        map.putString("ts", Long.toString(timeStampMs));
+        reactCtx.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+                .emit("mediaMetaDataReceived", map);
+    }
+}

ios/RCTAgora/AgoraConst.h

 static NSString *AGRtmpStreamingStateChanged = @"rtmpStreamingStateChanged";
 static NSString *AGLocalVideoChanged = @"localVideoChanged";
 static NSString *AGNetworkTypeChanged = @"networkTypeChanged";
-static NSString *AGMediaMetaDataRecevied = @"mediaMetaDataRecevied";
+static NSString *AGMediaMetaDataReceived = @"mediaMetaDataReceived";
 
 typedef NS_ENUM(NSInteger, AgoraModeType) {
   AgoraAudioMode,

ios/RCTAgora/RCTAgora.h

 #import <UIKit/UIKit.h>
 #import <React/RCTBridgeModule.h>
 #import <React/RCTEventEmitter.h>
+#import <AgoraRtcEngineKit/AgoraRtcEngineKit.h>
 
-@interface RCTAgora : RCTEventEmitter<RCTBridgeModule>
-
-+(void) sendEvent:(NSString *)name params:(NSDictionary*)params;
+@interface RCTAgora : RCTEventEmitter<RCTBridgeModule, AgoraMediaMetadataDelegate, AgoraMediaMetadataDataSource>
+- (void) sendEvent:(NSString *)msg params:(NSDictionary *)params;
+- (NSInteger) metadataMaxSize;
+- (NSData *_Nullable)readyToSendMetadataAtTimestamp:(NSTimeInterval)timestamp;
+- (void)receiveMetadata:(NSData *_Nonnull)data fromUser:(NSInteger)uid atTimestamp:(NSTimeInterval)timestamp;
 @end

ios/RCTAgora/RCTAgora.m

 
 @interface RCTAgora ()
 @property (strong, nonatomic) AgoraRtcEngineKit *rtcEngine;
-
+@property (strong, nonatomic) NSData *metadata;
 @end
 
-@interface MediaMetaDataObserver : NSObject<AgoraMediaMetadataDataSource, AgoraMediaMetadataDelegate>
-  @property (strong, nonatomic) NSData* metadata;
-
-  - (NSInteger) metadataMaxSize;
-
-  - (NSData *_Nullable)readyToSendMetadataAtTimestamp:(NSTimeInterval)timestamp;
-- (void)receiveMetadata:(NSData *_Nonnull)data fromUser:(NSInteger)uid atTimestamp:(NSTimeInterval)timestamp;
+@implementation RCTAgora {
+  RCTResponseSenderBlock _block;
+  bool hasListeners;
+}
 
++(BOOL)requiresMainQueueSetup {
+  return YES;
+}
 
-@end
 
-@implementation MediaMetaDataObserver
-  - (NSInteger) metadataMaxSize {
-    return MAX_DATA_LENGTH;
-  }
+- (NSInteger) metadataMaxSize {
+  return MAX_DATA_LENGTH;
+}
 
-  - (NSData *_Nullable)readyToSendMetadataAtTimestamp:(NSTimeInterval)timestamp
-  {
-    if (nil == _metadata) {
-      return nil;
-    }
-    NSData *toSend = [_metadata copy];
-    if ([toSend length] > MAX_DATA_LENGTH) {
-      return nil;
-    }
-    _metadata = nil;
-    return toSend;
+- (NSData *_Nullable)readyToSendMetadataAtTimestamp:(NSTimeInterval)timestamp
+{
+  if (nil == _metadata) {
+    return nil;
   }
-
-  - (void)receiveMetadata:(NSData *_Nonnull)data fromUser:(NSInteger)uid atTimestamp:(NSTimeInterval)timestamp {
-    NSString *dataStr = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
-    [RCTAgora sendEvent:AGMediaMetaDataRecevied params:@{
-                                                         @"uid": @(uid),
-                                                         @"data": dataStr,
-                                                         @"ts": @(timestamp)
-                                                         }];
+  NSData *toSend = [_metadata copy];
+  if ([toSend length] > MAX_DATA_LENGTH) {
+    return nil;
   }
-@end
-
-@implementation RCTAgora {
-  RCTResponseSenderBlock _block;
-  bool hasListeners;
+  _metadata = nil;
+  return toSend;
 }
 
-+(void) sendEvent:(NSString *)name params:(NSDictionary*)params {
-  [self sendEvent:name params:params];
-  return;
+- (void)receiveMetadata:(NSData *_Nonnull)data fromUser:(NSInteger)uid atTimestamp:(NSTimeInterval)timestamp {
+  NSString *dataStr = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
+  [self sendEvent:AGMediaMetaDataReceived params:@{
+                                               @"uid": @(uid),
+                                               @"data": dataStr,
+                                               @"ts": @(timestamp)
+                                               }];
 }
 
-+(BOOL)requiresMainQueueSetup {
-  return YES;
-}
 
 RCT_EXPORT_MODULE();
 
   }
 }
 
+RCT_EXPORT_METHOD(sendMediaData:(NSString *)dataStr
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject) {
+  if ([self respondsToSelector:@selector(readyToSendMetadataAtTimestamp:)]) {
+    self.metadata = [dataStr dataUsingEncoding:NSUTF8StringEncoding];
+    resolve(@{
+              @"success": @(YES)
+              });
+  } else {
+    reject(@"-1", @"sendMediaData failed", [self makeNSError:@{
+                                                        @"code": @(-1),
+                                                        @"message":@{
+                                                          @"success": @(NO),
+                                                        }}]);
+  }
+}
+
 RCT_EXPORT_METHOD(registerMediaMetadataObserver
                   :(RCTPromiseResolveBlock)resolve
                   reject:(RCTPromiseRejectBlock)reject) {
-  MediaMetaDataObserver *observer = [[MediaMetaDataObserver alloc] init];
-  BOOL res = [_rtcEngine setMediaMetadataDataSource:observer withType:AgoraMetadataTypeVideo];
+  BOOL res = [_rtcEngine setMediaMetadataDataSource:self withType:AgoraMetadataTypeVideo];
   if (res == YES) {
     resolve(@{
               @"success": @(YES)
            AGLocalVideoChanged,
            AGNetworkTypeChanged,
            AGFirstRemoteAudioFrame,
-           AGMetaMediaDataRecevied
+           AGMediaMetaDataReceived
            ];
 }
 

lib/RtcEngine.native.d.ts

      * This method needs you invoke registerMediaMetadataObserver success first and you could send media data through interval media observer feature.
      * The data have limit length is 1024 bytes, if you pass data length bigger than limit it will failed.
      * @param data String: 1024 bytes limit
+     * @returns Promise<{success}>
      */
-    static sendMediaData(data: String): void;
+    static sendMediaData(data: String): Promise<any>;
     /**
      * Registers the metadata observer.
      *
      * note:
      * This method only work in live mode
      * This method enables you to add synchronized metadata in the video stream for more diversified live broadcast interactions, such as sending shopping links, digital coupons, and online quizzes.
-     * This method trigger 'metaMediaDataRecevied' event, here is example:
+     * This method trigger 'mediaMetaDataReceived' event, here is example:
      * ```javascript
-     *      RtcEngine.on("metaMediaDataRecevied", (data) => {
-     *        console.log("metaMediaDataRecevied", data);
+     *      RtcEngine.on("mediaMetaDataReceived", (data) => {
+     *        console.log("mediaMetaDataReceived", data);
      *      })
      * ```
      * @returns Promise{<success, value}>

lib/RtcEngine.native.js

      * This method needs you invoke registerMediaMetadataObserver success first and you could send media data through interval media observer feature.
      * The data have limit length is 1024 bytes, if you pass data length bigger than limit it will failed.
      * @param data String: 1024 bytes limit
+     * @returns Promise<{success}>
      */
     static sendMediaData(data) {
         return Agora.sendMediaData(data);
      * note:
      * This method only work in live mode
      * This method enables you to add synchronized metadata in the video stream for more diversified live broadcast interactions, such as sending shopping links, digital coupons, and online quizzes.
-     * This method trigger 'metaMediaDataRecevied' event, here is example:
+     * This method trigger 'mediaMetaDataReceived' event, here is example:
      * ```javascript
-     *      RtcEngine.on("metaMediaDataRecevied", (data) => {
-     *        console.log("metaMediaDataRecevied", data);
+     *      RtcEngine.on("mediaMetaDataReceived", (data) => {
+     *        console.log("mediaMetaDataReceived", data);
      *      })
      * ```
      * @returns Promise{<success, value}>

src/RtcEngine.native.ts

      * This method needs you invoke registerMediaMetadataObserver success first and you could send media data through interval media observer feature.
      * The data have limit length is 1024 bytes, if you pass data length bigger than limit it will failed.
      * @param data String: 1024 bytes limit
+     * @returns Promise<{success}>
      */
-    static sendMediaData(data: String): void {
+    static sendMediaData(data: String): Promise<any> {
         return Agora.sendMediaData(data);
     }
 
      * note:
      * This method only work in live mode
      * This method enables you to add synchronized metadata in the video stream for more diversified live broadcast interactions, such as sending shopping links, digital coupons, and online quizzes.
-     * This method trigger 'metaMediaDataRecevied' event, here is example:
+     * This method trigger 'mediaMetaDataReceived' event, here is example:
      * ```javascript
-     *      RtcEngine.on("metaMediaDataRecevied", (data) => {
-     *        console.log("metaMediaDataRecevied", data);
+     *      RtcEngine.on("mediaMetaDataReceived", (data) => {
+     *        console.log("mediaMetaDataReceived", data);
      *      })
      * ```
      * @returns Promise{<success, value}>