feat. native ios & android integrate

feat. react module integrate
stage 1

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

@@ -13,6 +13,7 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 
+import io.agora.rtc.IMetadataObserver;
 import io.agora.rtc.IRtcEngineEventHandler;
 import io.agora.rtc.RtcEngine;
 import io.agora.rtc.video.BeautyOptions;

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

@@ -17,12 +17,14 @@ import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.modules.core.DeviceEventManagerModule;
 
 
+import java.nio.charset.Charset;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.Map;
 
 import io.agora.rtc.Constants;
 import io.agora.rtc.IAudioEffectManager;
+import io.agora.rtc.IMetadataObserver;
 import io.agora.rtc.IRtcEngineEventHandler;
 import io.agora.rtc.RtcEngine;
 import io.agora.rtc.internal.LastmileProbeConfig;
@@ -285,6 +287,10 @@ public class AgoraModule extends ReactContextBaseJavaModule {
     private final static String AGUserEnableVideo = "userEnableVideo";
     private final static String AGUserEnableLocalVideo = "userEnableLocalVideo";
     private final static String AGVideoSizeChanged = "videoSizeChanged";
+    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 AGRemoteVideoStateChanged = "remoteVideoStateChanged";
     private final static String AGLocalPublishFallbackToAudioOnly = "localPublishFallbackToAudioOnly";
     private final static String AGRemoteSubscribeFallbackToAudioOnly = "remoteSubscribeFallbackToAudioOnly";
@@ -415,6 +421,8 @@ public class AgoraModule extends ReactContextBaseJavaModule {
                     statsMap.putInt("userCount", stats.users);
                     statsMap.putDouble("cpuAppUsage", stats.cpuAppUsage);
                     statsMap.putDouble("cpuTotalUsage", stats.cpuTotalUsage);
+                    statsMap.putInt("txPacketLossRate", stats.txPacketLossRate);
+                    statsMap.putInt("rxPacketLossRate", stats.rxPacketLossRate);
 
                     WritableMap map = Arguments.createMap();
                     map.putMap("stats", statsMap);
@@ -584,17 +592,17 @@ public class AgoraModule extends ReactContextBaseJavaModule {
             });
         }
 
-        @Override
-        public void onVideoStopped() {
-            runOnUiThread(new Runnable() {
-                @Override
-                public void run() {
-                    WritableMap map = Arguments.createMap();
-                    map.putString("message", "VideoStopped");
-                    sendEvent(getReactApplicationContext(), AGVideoStopped, map);
-                }
-            });
-        }
+//        @Override
+//        public void onVideoStopped() {
+//            runOnUiThread(new Runnable() {
+//                @Override
+//                public void run() {
+//                    WritableMap map = Arguments.createMap();
+//                    map.putString("message", "VideoStopped");
+//                    sendEvent(getReactApplicationContext(), AGVideoStopped, map);
+//                }
+//            });
+//        }
 
         @Override
         public void onFirstLocalVideoFrame(final int width, final int height, final int elapsed) {
@@ -710,6 +718,45 @@ public class AgoraModule extends ReactContextBaseJavaModule {
             });
         }
 
+        @Override
+        public void onRtmpStreamingStateChanged(final String url, final int state, final int errCode) {
+            runOnUiThread(new Runnable() {
+                @Override
+                public void run() {
+                    WritableMap map = Arguments.createMap();
+                    map.putString("url", url);
+                    map.putInt("state", state);
+                    map.putInt("errorCode", errCode);
+                    sendEvent(getReactApplicationContext(), AGRtmpStreamingStateChanged, map);
+                }
+            });
+        }
+
+        @Override
+        public void onNetworkTypeChanged(final int type) {
+            runOnUiThread(new Runnable() {
+                @Override
+                public void run() {
+                    WritableMap map = Arguments.createMap();
+                    map.putInt("type", type);
+                    sendEvent(getReactApplicationContext(), AGNetworkTypeChanged, map);
+                }
+            });
+        }
+
+        @Override
+        public void onFirstRemoteAudioDecoded(final int uid, final int elapsed) {
+            runOnUiThread(new Runnable() {
+                @Override
+                public void run() {
+                    WritableMap map = Arguments.createMap();
+                    map.putInt("uid", uid);
+                    map.putInt("elapsed", elapsed);
+                    sendEvent(getReactApplicationContext(), AGFirstRemoteAudioDecoded, map);
+                }
+            });
+        }
+
         @Override
         public void onRemoteVideoStateChanged(final int uid, final int state) {
             runOnUiThread(new Runnable() {
@@ -884,7 +931,8 @@ public class AgoraModule extends ReactContextBaseJavaModule {
                     WritableMap statsMap = Arguments.createMap();
                     statsMap.putInt("sentBitrate", stats.sentBitrate);
                     statsMap.putInt("sentFrameRate", stats.sentFrameRate);
-
+                    statsMap.putInt("encoderOutputFrameRate", stats.encoderOutputFrameRate);
+                    statsMap.putInt("rendererOutputFrameRate", stats.rendererOutputFrameRate);
                     WritableMap map = Arguments.createMap();
                     map.putMap("stats", statsMap);
                     sendEvent(getReactApplicationContext(), AGLocalVideoStats, map);
@@ -902,7 +950,7 @@ public class AgoraModule extends ReactContextBaseJavaModule {
                     statsMap.putInt("width", stats.width);
                     statsMap.putInt("height", stats.height);
                     statsMap.putInt("receivedBitrate", stats.receivedBitrate);
-                    statsMap.putInt("receivedFrameRate", stats.receivedFrameRate);
+                    statsMap.putInt("rendererOutputFrameRate", stats.rendererOutputFrameRate);
                     statsMap.putInt("rxStreamType", stats.rxStreamType);
                     WritableMap map = Arguments.createMap();
                     map.putMap("stats", statsMap);
@@ -1034,7 +1082,7 @@ public class AgoraModule extends ReactContextBaseJavaModule {
             runOnUiThread(new Runnable() {
                 @Override
                 public void run() {
-                    String msg = new String(data);
+                    String msg = new String(data, Charset.forName("UTF-8"));
                     WritableMap map = Arguments.createMap();
                     map.putInt("uid", uid);
                     map.putInt("streamId", streamId);
@@ -1713,6 +1761,33 @@ public class AgoraModule extends ReactContextBaseJavaModule {
         }
     }
 
+    @ReactMethod
+    public void getAudioMixingPlayoutVolume(Promise promise) {
+        try {
+            int res = AgoraManager.getInstance().mRtcEngine.getAudioMixingPlayoutVolume();
+            if (res < 0) throw new ReactNativeAgoraException("getAudioMixingPlayoutVolume Failed", res);
+            WritableMap map = Arguments.createMap();
+            map.putString("volume", Integer.toString(res));
+            promise.resolve(map);
+        } catch (Exception e) {
+            promise.reject("-1", e);
+        }
+    }
+
+    @ReactMethod
+    public void getAudioMixingPublishVolume(Promise promise) {
+        try {
+            int res = AgoraManager.getInstance().mRtcEngine.getAudioMixingPlayoutVolume();
+            if (res < 0) throw new ReactNativeAgoraException("getAudioMixingPublishVolume Failed", res);
+            WritableMap map = Arguments.createMap();
+            map.putBoolean("success", true);
+            map.putInt("value", res);
+            promise.resolve(map);
+        } catch (Exception e) {
+            promise.reject("-1", e);
+        }
+    }
+
     @ReactMethod
     public void getAudioMixingDuration(Promise promise) {
         try {
@@ -1723,7 +1798,7 @@ public class AgoraModule extends ReactContextBaseJavaModule {
             map.putInt("value", res);
             promise.resolve(map);
         } catch (Exception e) {
-            promise.reject("131004", e);
+            promise.reject("-1", e);
         }
     }
 
@@ -2007,7 +2082,57 @@ public class AgoraModule extends ReactContextBaseJavaModule {
             map.putInt("value", res);
             promise.resolve(map);
         } catch (Exception e) {
-            promise.reject("131030", e);
+            promise.reject("-1", e);
+        }
+    }
+
+    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"));
+    }
+
+    @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);
+            if (res < 0) {
+                new ReactNativeAgoraException("setRemoteDefaultVideoStreamType Failed", res);
+            }
+            WritableMap map = Arguments.createMap();
+            map.putBoolean("success", true);
+            map.putInt("value", res);
+            promise.resolve(map);
+        } catch (Exception e) {
+            promise.reject("-1", e);
         }
     }
 
@@ -2443,7 +2568,7 @@ public class AgoraModule extends ReactContextBaseJavaModule {
             String data = options.getString("data");
             int streamID = AgoraManager.getInstance().mRtcEngine.createDataStream(reliable, ordered);
             if (streamID < 0) throw new ReactNativeAgoraException("createDataStream Failed", streamID);
-            int res = AgoraManager.getInstance().mRtcEngine.sendStreamMessage(streamID, data.getBytes("utf8"));
+            int res = AgoraManager.getInstance().mRtcEngine.sendStreamMessage(streamID, data.getBytes(Charset.forName("UTF-8")));
             if (res != 0) throw new ReactNativeAgoraException("sendStreamMessage Failed", res);
             WritableMap map = Arguments.createMap();
             map.putBoolean("success", true);

ios/RCTAgora/AgoraConst.h

@@ -29,6 +29,7 @@ static NSString *AGAudioVolumeIndication = @"audioVolumeIndication";
 static NSString *AGActiveSpeaker = @"activeSpeaker";
 static NSString *AGFirstLocalAudioFrame = @"firstLocalAudioFrame";
 static NSString *AGFirstRemoteAudioFrame = @"firstRemoteAudioFrame";
+static NSString *AGFirstRemoteAudioDecoded = @"firstRemoteAudioDecoded";
 static NSString *AGVideoStopped = @"videoStopped";
 static NSString *AGFirstLocalVideoFrame = @"firstLocalVideoFrame";
 static NSString *AGFirstRemoteVideoDecoded = @"firstRemoteVideoDecoded";
@@ -77,6 +78,11 @@ static NSString *AGIntervalTest = @"startEchoTestWithInterval";
 static NSString *AGAudioMixingStateChanged = @"audioMixingStateChanged";
 static NSString *AGLastmileProbeTestResult = @"lastmileProbeTestResult";
 
+static NSString *AGRtmpStreamingStateChanged = @"rtmpStreamingStateChanged";
+static NSString *AGLocalVideoChanged = @"localVideoChanged";
+static NSString *AGNetworkTypeChanged = @"networkTypeChanged";
+static NSString *AGMediaMetaDataRecevied = @"mediaMetaDataRecevied";
+
 typedef NS_ENUM(NSInteger, AgoraModeType) {
   AgoraAudioMode,
   AgoraVideoMode

ios/RCTAgora/RCTAgora.h

@@ -13,4 +13,5 @@
 
 @interface RCTAgora : RCTEventEmitter<RCTBridgeModule>
 
++(void) sendEvent:(NSString *)name params:(NSDictionary*)params;
 @end

ios/RCTAgora/RCTAgora.m

@@ -13,16 +13,62 @@
 #import <React/RCTView.h>
 #import "AgoraConst.h"
 
+#define MAX_DATA_LENGTH 1024
+
 @interface RCTAgora ()
 @property (strong, nonatomic) AgoraRtcEngineKit *rtcEngine;
 
 @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;
+
+
+@end
+
+@implementation MediaMetaDataObserver
+  - (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;
+  }
+
+  - (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)
+                                                         }];
+  }
+@end
+
 @implementation RCTAgora {
   RCTResponseSenderBlock _block;
   bool hasListeners;
 }
 
++(void) sendEvent:(NSString *)name params:(NSDictionary*)params {
+  [self sendEvent:name params:params];
+  return;
+}
+
 +(BOOL)requiresMainQueueSetup {
   return YES;
 }
@@ -594,8 +640,8 @@ RCT_EXPORT_METHOD(getAudioMixingDuration
                   reject:(RCTPromiseRejectBlock)reject) {
   NSInteger res = [self.rtcEngine getAudioMixingDuration];
   if (res != 0) {
-    reject(@"131004", @"getAudioMixingDuration failed", [self makeNSError:@{
-                                                                            @"code": @(131004),
+    reject(@"-1", @"getAudioMixingDuration failed", [self makeNSError:@{
+                                                                            @"code": @(-1),
                                                                             @"message":@{
                                                                                 @"success": @(NO),
                                                                                 @"value":[NSNumber numberWithInteger:res]
@@ -609,6 +655,49 @@ RCT_EXPORT_METHOD(getAudioMixingDuration
   }
 }
 
+// get the volume of local audio mixing
+RCT_EXPORT_METHOD(getAudioMixingPlayoutVolume
+                  :(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject) {
+  int res = [_rtcEngine getAudioMixingPlayoutVolume];
+  if (res < 0) {
+    reject(@"-1", @"getAudioMixingPlayoutVolume failed", [self makeNSError:@{
+                                                                            @"code": @(-1),
+                                                                            @"message":@{
+                                                                                @"success": @(NO),
+                                                                                @"value":[NSNumber numberWithInteger:res]
+                                                                                }
+                                                                            }]);
+  } else {
+    resolve(@{
+              @"success": @(YES),
+              @"value": @(res)
+              });
+  }
+}
+
+// get the volume of remote audio mixing
+RCT_EXPORT_METHOD(getAudioMixingPublishVolume
+                  :(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject) {
+  int res = [_rtcEngine getAudioMixingPublishVolume];
+  if (res < 0) {
+    reject(@"-1", @"getAudioMixingPublishVolume failed", [self makeNSError:@{
+                                                                             @"code": @(-1),
+                                                                             @"message":@{
+                                                                                 @"success": @(NO),
+                                                                                 @"value":[NSNumber numberWithInteger:res]
+                                                                                 }
+                                                                             }]);
+  } else {
+    resolve(@{
+              @"success": @(YES),
+              @"value": @(res)
+              });
+  }
+}
+
+
 // get audio mixing current position
 RCT_EXPORT_METHOD(getAudioMixingCurrentPosition
                   :(RCTPromiseResolveBlock)resolve
@@ -1631,6 +1720,9 @@ RCT_EXPORT_METHOD(setLiveTranscoding:(NSDictionary *)options) {
   if (options[@"videoCodecProfile"] != nil) {
     transcoding.videoCodecProfile = (AgoraVideoCodecProfileType)[options[@"videoCodecProfile"] integerValue];
   }
+  if (options[@"audioCodecProfile"] != nil) {
+    transcoding.audioCodecProfile = (AgoraAudioCodecProfileType)[options[@"audioCodecProfile"] integerValue];
+  }
   if (options[@"transcodingUsers"] != nil) {
     NSMutableArray<AgoraLiveTranscodingUser*> *transcodingUsers = [NSMutableArray new];
     for (NSDictionary *optionUser in options[@"users"]) {
@@ -1885,6 +1977,26 @@ RCT_EXPORT_METHOD(setCameraCapturerConfiguration:(NSDictionary *)config
   }
 }
 
+RCT_EXPORT_METHOD(registerMediaMetadataObserver
+                  :(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject) {
+  MediaMetaDataObserver *observer = [[MediaMetaDataObserver alloc] init];
+  BOOL res = [_rtcEngine setMediaMetadataDataSource:observer withType:AgoraMetadataTypeVideo];
+  if (res == YES) {
+    resolve(@{
+              @"success": @(YES)
+              });
+  } else {
+    reject(@"-1", @"registerMediaMetadataObserver failed", [self makeNSError:@{
+                                                                             @"code": @(-1),
+                                                                             @"message":@{
+                                                                                 @"success": @(NO),
+                                                                                 @"value":[NSNumber numberWithInteger:res]
+                                                                                 }
+                                                                             }]);
+  }
+}
+
 - (NSArray<NSString *> *)supportedEvents {
   return @[
            AGWarning,
@@ -1906,6 +2018,7 @@ RCT_EXPORT_METHOD(setCameraCapturerConfiguration:(NSDictionary *)config
            AGActiveSpeaker,
            AGFirstLocalAudioFrame,
            AGFirstRemoteAudioFrame,
+           AGFirstRemoteAudioDecoded,
            AGVideoStopped,
            AGFirstLocalVideoFrame,
            AGFirstRemoteVideoDecoded,
@@ -1951,7 +2064,12 @@ RCT_EXPORT_METHOD(setCameraCapturerConfiguration:(NSDictionary *)config
            AGMediaEngineStartCall,
            AGIntervalTest,
            AGAudioMixingStateChanged,
-           AGLastmileProbeTestResult
+           AGLastmileProbeTestResult,
+           AGRtmpStreamingStateChanged,
+           AGLocalVideoChanged,
+           AGNetworkTypeChanged,
+           AGFirstRemoteAudioFrame,
+           AGMetaMediaDataRecevied
            ];
 }
 
@@ -2050,6 +2168,12 @@ RCT_EXPORT_METHOD(setCameraCapturerConfiguration:(NSDictionary *)config
                                            }];
 }
 
+- (void)rtcEngine:(AgoraRtcEngineKit *_Nonnull)engine networkTypeChangedToType:(AgoraNetworkType)type {
+  [self sendEvent:AGNetworkTypeChanged params:@{
+                                                @"type": @(type)
+                                                }];
+}
+
 - (void)rtcEngine:(AgoraRtcEngineKit *_Nonnull)engine connectionChangedToState:(AgoraConnectionStateType)state reason:(AgoraConnectionChangedReason)reason {
   [self sendEvent:AGConnectionStateChanged params:@{
                                                     @"state": @(state),
@@ -2114,10 +2238,11 @@ RCT_EXPORT_METHOD(setCameraCapturerConfiguration:(NSDictionary *)config
                                                       }];
 }
 
-- (void)rtcEngineVideoDidStop:(AgoraRtcEngineKit *_Nonnull)engine {
-  [self sendEvent:AGVideoStopped params:@{
-                                        @"message": @"VideoStopped"
-                                        }];
+- (void)rtcEngine:(AgoraRtcEngineKit *_Nonnull)engine firstRemoteAudioFrameDecodedOfUid:(NSUInteger)uid elapsed:(NSInteger)elapsed {
+  [self sendEvent:AGFirstRemoteAudioDecoded params:@{
+                                                     @"uid": @(uid),
+                                                     @"elapsed": @(elapsed)
+                                                     }];
 }
 
 - (void)rtcEngine:(AgoraRtcEngineKit *_Nonnull)engine firstLocalVideoFrameWithSize:(CGSize)size elapsed:(NSInteger)elapsed {
@@ -2208,12 +2333,6 @@ RCT_EXPORT_METHOD(setCameraCapturerConfiguration:(NSDictionary *)config
                                                 }];
 }
 
-- (void)rtcEngineCameraDidReady:(AgoraRtcEngineKit *_Nonnull)engine {
-  [self sendEvent:AGCameraReady params:@{
-                                          @"message": @"CameraDidReady"
-                                          }];
-}
-
 - (void)rtcEngine:(AgoraRtcEngineKit *_Nonnull)engine cameraFocusDidChangedToRect:(CGRect)rect {
   [self sendEvent:AGCameraFocusAreaChanged params:@{
                                                        @"rect": @(rect)
@@ -2242,6 +2361,8 @@ RCT_EXPORT_METHOD(setCameraCapturerConfiguration:(NSDictionary *)config
   [self sendEvent:AGRtcStats params:@{
                                           @"stats": @{
                                               @"duration": @(stats.duration),
+                                              @"txPacketLossRate": @(stats.txPacketLossRate),
+                                              @"rxPacketLossRate": @(stats.rxPacketLossRate),
                                               @"txBytes": @(stats.txBytes),
                                               @"rxBytes": @(stats.rxBytes),
                                               @"txAudioKBitrate": @(stats.txAudioKBitrate),
@@ -2275,7 +2396,10 @@ RCT_EXPORT_METHOD(setCameraCapturerConfiguration:(NSDictionary *)config
                                            @"stats": @{
                                                @"sentBitrate": @(stats.sentBitrate),
                                                @"sentFrameRate": @(stats.sentFrameRate)
-                                               }
+                                               },
+                                           @"encoderOutputFrameRate": @(stats.encoderOutputFrameRate),
+                                           @"rendererOutputFrameRate":
+                                               @(stats.rendererOutputFrameRate)
                                            }];
 }
 
@@ -2286,8 +2410,9 @@ RCT_EXPORT_METHOD(setCameraCapturerConfiguration:(NSDictionary *)config
                                                 @"width": @(stats.width),
                                                 @"height": @(stats.height),
                                                 @"receivedBitrate": @(stats.receivedBitrate),
-                                                @"receivedFrameRate": @(stats.receivedFrameRate),
-                                                @"rxStreamType": @(stats.rxStreamType)
+                                                @"rendererOutputFrameRate": @(stats.rendererOutputFrameRate),
+                                                @"rxStreamType": @(stats.rxStreamType),
+                                                @"decoderOutputFrameRate": @(stats.decoderOutputFrameRate)
                                                 }
                                             }];
 }
@@ -2341,6 +2466,14 @@ RCT_EXPORT_METHOD(setCameraCapturerConfiguration:(NSDictionary *)config
                                            }];
 }
 
+- (void)rtcEngine:(AgoraRtcEngineKit *_Nonnull)engine rtmpStreamingChangedToState:(NSString *_Nonnull)url state:(AgoraRtmpStreamingState)state errorCode:(AgoraRtmpStreamingErrorCode)errorCode {
+  [self sendEvent:AGRtmpStreamingStateChanged params:@{
+                                                       @"url": url,
+                                                       @"state": @(state),
+                                                       @"errorCode": @(errorCode)
+                                                       }];
+}
+
 - (void)rtcEngine:(AgoraRtcEngineKit *_Nonnull)engine streamUnpublishedWithUrl:(NSString *_Nonnull)url {
   [self sendEvent:AGStreamUnpublish params:@{
                                            @"url": url,
@@ -2353,6 +2486,13 @@ RCT_EXPORT_METHOD(setCameraCapturerConfiguration:(NSDictionary *)config
                                               }];
 }
 
+- (void)rtcEngine:(AgoraRtcEngineKit *_Nonnull)engine localVideoStateChange:(AgoraLocalVideoStreamState)state error:(AgoraLocalVideoStreamError)error {
+  [self sendEvent:AGLocalVideoChanged params:@{
+                                               @"state": @(state),
+                                               @"errorCode": @(error)
+                                               }];
+}
+
 - (void)rtcEngine:(AgoraRtcEngineKit *_Nonnull)engine streamInjectedStatusOfUrl:(NSString *_Nonnull)url uid:(NSUInteger)uid status:(AgoraInjectStreamStatus)status {
   [self sendEvent:AGStreamInjectedStatus params:@{
                                                 @"uid": @(uid),

lib/RtcEngine.native.d.ts

@@ -952,5 +952,60 @@ declare class RtcEngine {
      * @returns Promise<{success, value}>
      */
     static setCameraCapturerConfiguration(config: CameraCapturerConfiguration): Promise<any>;
+    /**
+     * Gets the audio mixing volume for local playback.
+     *
+     * note:
+     * This method helps troubleshoot audio volume related issues.
+     *
+     * @returns Promise{<success, value}>
+     */
+    static getAudioMixingPlayoutVolume(): Promise<any>;
+    /**
+     * Gets the audio mixing volume for publishing.
+     *
+     * note:
+     * This method helps troubleshoot audio volume related issues.
+     *
+     * @returns Promise{<success, value}>
+     */
+    static getAudioMixingPublishVolume(): Promise<any>;
+    /**
+     * sendMediaData for media observer.
+     *
+     * note:
+     * 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
+     */
+    static sendMediaData(data: String): void;
+    /**
+     * 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:
+     * ```javascript
+     *      RtcEngine.on("metaMediaDataRecevied", (data) => {
+     *        console.log("metaMediaDataRecevied", data);
+     *      })
+     * ```
+     * @returns Promise{<success, value}>
+     */
+    static registerMediaMetadataObserver(): Promise<any>;
+    /**
+     * Get local device camera support info
+     *
+     * note:
+     * This method returns your current device camera support info.
+     * ```javascript
+     *      RtcEngine.getCameraInfo().then(info => {
+     *         console.log("your currrent camera", info);
+     *      })
+     * ```
+     * @returns Promise{cameraSupportInfo}>
+     */
+    static getCameraInfo(): Promise<any>;
 }
 export default RtcEngine;

lib/RtcEngine.native.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
 const react_native_1 = require("react-native");
 const { Agora } = react_native_1.NativeModules;
 const AgoraEventEmitter = new react_native_1.NativeEventEmitter(Agora);
@@ -1186,6 +1187,86 @@ class RtcEngine {
     static setCameraCapturerConfiguration(config) {
         return Agora.setCameraCapturerConfiguration(config);
     }
+    /**
+     * Gets the audio mixing volume for local playback.
+     *
+     * note:
+     * This method helps troubleshoot audio volume related issues.
+     *
+     * @returns Promise{<success, value}>
+     */
+    static getAudioMixingPlayoutVolume() {
+        return Agora.getAudioMixingPlayoutVolume();
+    }
+    /**
+     * Gets the audio mixing volume for publishing.
+     *
+     * note:
+     * This method helps troubleshoot audio volume related issues.
+     *
+     * @returns Promise{<success, value}>
+     */
+    static getAudioMixingPublishVolume() {
+        return Agora.getAudioMixingPublishVolume();
+    }
+    /**
+     * sendMediaData for media observer.
+     *
+     * note:
+     * 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
+     */
+    static sendMediaData(data) {
+        return Agora.sendMediaData(data);
+    }
+    /**
+     * 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:
+     * ```javascript
+     *      RtcEngine.on("metaMediaDataRecevied", (data) => {
+     *        console.log("metaMediaDataRecevied", data);
+     *      })
+     * ```
+     * @returns Promise{<success, value}>
+     */
+    static registerMediaMetadataObserver() {
+        return Agora.registerMediaMetadataObserver();
+    }
+    /**
+     * Get local device camera support info
+     *
+     * note:
+     * This method returns your current device camera support info.
+     * ```javascript
+     *      RtcEngine.getCameraInfo().then(info => {
+     *         console.log("your currrent camera", info);
+     *      })
+     * ```
+     * @returns Promise{cameraSupportInfo}>
+     */
+    static getCameraInfo() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let zoomSupported = yield this.isCameraZoomSupported();
+            let torchSupported = yield this.isCameraTorchSupported();
+            let focusSupported = yield this.isCameraFocusSupported();
+            let exposurePositionSupported = yield this.isCameraExposurePositionSupported();
+            let autoFocusFaceModeSupported = yield this.isCameraAutoFocusFaceModeSupported();
+            let maxZoomFactor = yield this.getCameraMaxZoomFactor();
+            return {
+                zoomSupported,
+                torchSupported,
+                focusSupported,
+                exposurePositionSupported,
+                autoFocusFaceModeSupported,
+                maxZoomFactor
+            };
+        });
+    }
 }
 RtcEngine.eventTypes = new Set();
 exports.default = RtcEngine;

src/RtcEngine.native.ts

@@ -1336,6 +1336,90 @@ class RtcEngine {
     static setCameraCapturerConfiguration(config: CameraCapturerConfiguration): Promise<any> {
         return Agora.setCameraCapturerConfiguration(config);
     }
+
+    /**
+     * Gets the audio mixing volume for local playback.
+     * 
+     * note:
+     * This method helps troubleshoot audio volume related issues.
+     * 
+     * @returns Promise{<success, value}>
+     */
+    static getAudioMixingPlayoutVolume(): Promise<any> {
+        return Agora.getAudioMixingPlayoutVolume();
+    }
+
+    /**
+     * Gets the audio mixing volume for publishing.
+     * 
+     * note:
+     * This method helps troubleshoot audio volume related issues.
+     * 
+     * @returns Promise{<success, value}>
+     */
+    static getAudioMixingPublishVolume(): Promise<any> {
+        return Agora.getAudioMixingPublishVolume();
+    }
+
+    /**
+     * sendMediaData for media observer.
+     * 
+     * note:
+     * 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
+     */
+    static sendMediaData(data: String): void {
+        return Agora.sendMediaData(data);
+    }
+
+    /**
+     * 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:
+     * ```javascript
+     *      RtcEngine.on("metaMediaDataRecevied", (data) => {
+     *        console.log("metaMediaDataRecevied", data);
+     *      })
+     * ```
+     * @returns Promise{<success, value}>
+     */
+    static registerMediaMetadataObserver(): Promise<any> {
+        return Agora.registerMediaMetadataObserver();
+    }
+
+    /**
+     * Get local device camera support info
+     * 
+     * note:
+     * This method returns your current device camera support info.
+     * ```javascript
+     *      RtcEngine.getCameraInfo().then(info => {
+     *         console.log("your currrent camera", info);
+     *      })
+     * ```
+     * @returns Promise{cameraSupportInfo}>
+     */
+    static async getCameraInfo(): Promise<any> {
+        let zoomSupported = await this.isCameraZoomSupported();
+        let torchSupported = await this.isCameraTorchSupported();
+        let focusSupported = await this.isCameraFocusSupported();
+        let exposurePositionSupported = await this.isCameraExposurePositionSupported();
+        let autoFocusFaceModeSupported = await this.isCameraAutoFocusFaceModeSupported();
+        let maxZoomFactor = await this.getCameraMaxZoomFactor();
+        return {
+            zoomSupported,
+            torchSupported,
+            focusSupported,
+            exposurePositionSupported,
+            autoFocusFaceModeSupported,
+            maxZoomFactor
+        }
+    }
+
 }