Merge pull request #75 from syanbo/feature/2.4.1-alpha.1

Feature integrate android & ios sdk 2.4.1

CHANGELOG

 ## THE CHANGELOG
 
+#### 2.4.1-alpha
+- support 2.4.1-alpha.1 agora video sdk android-2.4.1 / iOS-2.4.1
+  1. Deprecate iOS
+  2. Add methods getAudioMixingPlayoutVolume, getAudioMixingPublishVolume for audio mixing troubleshooting.
+  3. Add `txPacketLossRate`, `rxPacketLossRate` on `rtcStats` interface. usage: `RtcEngine.on('rtcStats', (data) => console.log(data))`.
+  4. Rename `receivedFrameRate` to `rendererOutputFrameRate` this property related on `localVideoStats` and `remoteVideoStats`.
+  5. Add event 'localVideoChanged' and Deprecate events `cameraReady` and `videoStopped`. You can listen `localVideoChanged` event instead  `cameraReady` & `videoStopped`.
+  6. Add event `rtmpStreamingStateChanged` for rtmp streaming troubleshooting
+  7. Add event `audioCodecProfile` on `liveTranscoding` interface.
+  8. Add event `networkTypeChanged` for network troubleshooting.
+  9. Add method `registerMediaMetadataObserver` method, 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. note: Call this method before the joinChannel method. and applies to `channelProfile` with 1. 
+  10. Add method `sendMediaData`, this method enables you send media data under the live broadcast mode (`channelProfile` = 1) note: call this method after the `registerMediaMetadataObserver` method.
+  11. Add event `audioMixingStateChanged` and Deprecate event 'localAudioMixingFinish`.
+  11. Add `firstRemoteAudioDecoded` event you can get more detail [here](https://docs.agora.io/en/Interactive%20Broadcast/release_android_video?platform=Android#v241)
 
 #### 2.4.0-alpha
 - support 2.4.0-alpha.1 agora video sdk android-2.4.0 / iOS-2.4.0.1 and add sendMessage support in the same channel. Deprecate: startEchoTest and setVideoQualityParameters

android/build.gradle

     def androidSupportVersion = rootProject.hasProperty("androidSupportVersion")  ? rootProject.androidSupportVersion : DEFAULT_ANDROID_SUPPORT_VERSION
     // from internet
     implementation "com.android.support:appcompat-v7:$androidSupportVersion"
-    implementation "io.agora.rtc:full-sdk:2.4.0"
+    implementation "io.agora.rtc:full-sdk:2.4.1"
     // from node_modules
     implementation "com.facebook.react:react-native:+"
 }

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

 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

 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;
     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 AGMediaMetaDataReceived = "mediaMetaDataReceived";
+    private final static String AGLocalVideoChanged = "localVideoChanged";
     private final static String AGRemoteVideoStateChanged = "remoteVideoStateChanged";
     private final static String AGLocalPublishFallbackToAudioOnly = "localPublishFallbackToAudioOnly";
     private final static String AGRemoteSubscribeFallbackToAudioOnly = "remoteSubscribeFallbackToAudioOnly";
     private final static String AGAudioTransportStatsOfUid = "audioTransportStatsOfUid";
     private final static String AGVideoTransportStatsOfUid = "videoTransportStatsOfUid";
 
-    private final static String AGLocalAudioMixingFinish = "localAudioMixingFinish";
     private final static String AGRemoteAudioMixingStart = "remoteAudioMixingStart";
     private final static String AGRemoteAudioMixingFinish = "remoteAudioMixingFinish";
     private final static String AGAudioEffectFinish = "audioEffectFinish";
+    private final static String AGAudioMixingStateChanged = "audioMixingStateChanged";
 
     private final static String AGStreamPublished = "streamPublished";
     private final static String AGStreamUnpublish = "streamUnpublish";
     private final static String AGLastmileProbeResult = "lastmileProbeTestResult";
 //    private final static String AGIntervalTest = "startEchoTestWithInterval";
 
+    private MediaObserver mediaObserver = null;
+
     private IRtcEngineEventHandler mRtcEventHandler = new IRtcEngineEventHandler() {
 
         @Override
                     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);
             });
         }
 
-        @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) {
             runOnUiThread(new Runnable() {
             });
         }
 
+        @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() {
             });
         }
 
-        @Override
-        public void onCameraReady() {
-            runOnUiThread(new Runnable() {
-                @Override
-                public void run() {
-                    WritableMap map = Arguments.createMap();
-                    map.putString("message", "CameraDidReady");
-                    sendEvent(getReactApplicationContext(), AGCameraReady, map);
-                }
-            });
-        }
-
         @Override
         public void onCameraFocusAreaChanged(final Rect rect) {
             runOnUiThread(new Runnable() {
                     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);
                     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);
                     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);
         }
 
         @Override
-        public void onAudioMixingFinished() {
+        public void onAudioMixingStateChanged(final int state, final int errorCode) {
             runOnUiThread(new Runnable() {
                 @Override
                 public void run() {
                     WritableMap map = Arguments.createMap();
-                    map.putString("message", "LocalAudioMixingSucceedFinish");
-                    sendEvent(getReactApplicationContext(), AGLocalAudioMixingFinish, map);
+                    map.putInt("state", state);
+                    map.putInt("errorCode", errorCode);
+                    sendEvent(getReactApplicationContext(), AGAudioMixingStateChanged, map);
                 }
             });
         }
             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);
                 }
             });
         }
+
+        @Override
+        public void onLocalVideoStateChanged(final int localVideoState, final int error) {
+            super.onLocalVideoStateChanged(localVideoState, error);
+            runOnUiThread(new Runnable() {
+                @Override
+                public void run() {
+                    WritableMap map = Arguments.createMap();
+                    map.putString("message", "LocalVideoChanged");
+                    map.putInt("state", localVideoState);
+                    sendEvent(getReactApplicationContext(), AGLocalVideoChanged, map);
+                }
+            });
+        }
     };
 
     @ReactMethod
         }
     }
 
+    @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.putBoolean("success", true);
+            map.putInt("value", 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 {
             map.putInt("value", res);
             promise.resolve(map);
         } catch (Exception e) {
-            promise.reject("131004", e);
+            promise.reject("-1", e);
         }
     }
 
             map.putInt("value", res);
             promise.resolve(map);
         } catch (Exception e) {
-            promise.reject("131030", e);
+            promise.reject("-1", e);
+        }
+    }
+
+    @ReactMethod
+    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 {
+            mediaObserver = new MediaObserver(getReactApplicationContext());
+            int res = AgoraManager.getInstance().mRtcEngine
+                    .registerMediaMetadataObserver(mediaObserver, IMetadataObserver.VIDEO_METADATA);
+            if (res < 0) {
+                new ReactNativeAgoraException("registerMediaMetadataObserver Failed", res);
+            }
+            WritableMap map = Arguments.createMap();
+            map.putBoolean("success", true);
+            map.putInt("value", res);
+            promise.resolve(map);
+        } catch (Exception e) {
+            promise.reject("-1", e);
         }
     }
 
             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);
     }
 
 
-
     @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 *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";
 static NSString *AGAudioTransportStatsOfUid = @"audioTransportStatsOfUid";
 static NSString *AGVideoTransportStatsOfUid = @"videoTransportStatsOfUid";
 
-static NSString *AGLocalAudioMixingFinish = @"localAudioMixingFinish";
 static NSString *AGRemoteAudioMixingStart = @"remoteAudioMixingStart";
 static NSString *AGRemoteAudioMixingFinish = @"remoteAudioMixingFinish";
 static NSString *AGAudioEffectFinish = @"audioEffectFinish";
 static NSString *AGAudioMixingStateChanged = @"audioMixingStateChanged";
 static NSString *AGLastmileProbeTestResult = @"lastmileProbeTestResult";
 
+static NSString *AGRtmpStreamingStateChanged = @"rtmpStreamingStateChanged";
+static NSString *AGLocalVideoChanged = @"localVideoChanged";
+static NSString *AGNetworkTypeChanged = @"networkTypeChanged";
+static NSString *AGMediaMetaDataReceived = @"mediaMetaDataReceived";
+
 typedef NS_ENUM(NSInteger, AgoraModeType) {
   AgoraAudioMode,
   AgoraVideoMode

ios/RCTAgora/RCTAgora.h

 #import <UIKit/UIKit.h>
 #import <React/RCTBridgeModule.h>
 #import <React/RCTEventEmitter.h>
+#import <AgoraRtcEngineKit/AgoraRtcEngineKit.h>
 
-@interface RCTAgora : RCTEventEmitter<RCTBridgeModule>
-
+@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

 #import <React/RCTView.h>
 #import "AgoraConst.h"
 
+#define MAX_DATA_LENGTH 1024
+
 @interface RCTAgora ()
 @property (strong, nonatomic) AgoraRtcEngineKit *rtcEngine;
-
+@property (strong, nonatomic) NSData *metadata;
 @end
 
 @implementation RCTAgora {
   return YES;
 }
 
+
+- (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];
+  [self sendEvent:AGMediaMetaDataReceived params:@{
+                                               @"uid": @(uid),
+                                               @"data": dataStr,
+                                               @"ts": @(timestamp)
+                                               }];
+}
+
+
 RCT_EXPORT_MODULE();
 
 - (NSError *) makeNSError:(NSDictionary *)options {
                   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]
   }
 }
 
+// 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
   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"]) {
   }
 }
 
+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) {
+  if (YES == [_rtcEngine setMediaMetadataDataSource:self withType:AgoraMetadataTypeVideo] &&
+    YES == [_rtcEngine setMediaMetadataDelegate:self withType:AgoraMetadataTypeVideo]
+    ) {
+    resolve(@{
+              @"success": @(YES)
+              });
+  } else {
+    reject(@"-1", @"registerMediaMetadataObserver failed", [self makeNSError:@{
+                                                                             @"code": @(-1),
+                                                                             @"message":@{
+                                                                                 @"success": @(NO),
+                                                                                 @"value":@(0)
+                                                                                 }
+                                                                             }]);
+  }
+}
+
 - (NSArray<NSString *> *)supportedEvents {
   return @[
            AGWarning,
            AGActiveSpeaker,
            AGFirstLocalAudioFrame,
            AGFirstRemoteAudioFrame,
+           AGFirstRemoteAudioDecoded,
            AGVideoStopped,
            AGFirstLocalVideoFrame,
            AGFirstRemoteVideoDecoded,
            AGAudioTransportStatsOfUid,
            AGVideoTransportStatsOfUid,
            
-           AGLocalAudioMixingFinish,
+           AGAudioMixingStateChanged,
            AGRemoteAudioMixingStart,
            AGRemoteAudioMixingFinish,
            AGAudioEffectFinish,
            AGMediaEngineLoaded,
            AGMediaEngineStartCall,
            AGIntervalTest,
-           AGAudioMixingStateChanged,
-           AGLastmileProbeTestResult
+           AGLastmileProbeTestResult,
+           AGRtmpStreamingStateChanged,
+           AGLocalVideoChanged,
+           AGNetworkTypeChanged,
+           AGFirstRemoteAudioFrame,
+           AGMediaMetaDataReceived
            ];
 }
 
                                            }];
 }
 
+- (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),
                                                       }];
 }
 
-- (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 {
                                                 }];
 }
 
-- (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)
   [self sendEvent:AGRtcStats params:@{
                                           @"stats": @{
                                               @"duration": @(stats.duration),
+                                              @"txPacketLossRate": @(stats.txPacketLossRate),
+                                              @"rxPacketLossRate": @(stats.rxPacketLossRate),
                                               @"txBytes": @(stats.txBytes),
                                               @"rxBytes": @(stats.rxBytes),
                                               @"txAudioKBitrate": @(stats.txAudioKBitrate),
                                            @"stats": @{
                                                @"sentBitrate": @(stats.sentBitrate),
                                                @"sentFrameRate": @(stats.sentFrameRate)
-                                               }
+                                               },
+                                           @"encoderOutputFrameRate": @(stats.encoderOutputFrameRate),
+                                           @"rendererOutputFrameRate":
+                                               @(stats.rendererOutputFrameRate)
                                            }];
 }
 
                                                 @"width": @(stats.width),
                                                 @"height": @(stats.height),
                                                 @"receivedBitrate": @(stats.receivedBitrate),
-                                                @"receivedFrameRate": @(stats.receivedFrameRate),
-                                                @"rxStreamType": @(stats.rxStreamType)
+                                                @"rendererOutputFrameRate": @(stats.rendererOutputFrameRate),
+                                                @"rxStreamType": @(stats.rxStreamType),
+                                                @"decoderOutputFrameRate": @(stats.decoderOutputFrameRate)
                                                 }
                                             }];
 }
                                                     }];
 }
 
-- (void)rtcEngineLocalAudioMixingDidFinish:(AgoraRtcEngineKit *_Nonnull)engine {
-  [self sendEvent:AGLocalAudioMixingFinish params:@{
-                                                     @"message": @"LocalAudioMixingSucceedFinish"
-                                                     }];
-}
-
 - (void)rtcEngineRemoteAudioMixingDidStart:(AgoraRtcEngineKit *_Nonnull)engine {
   [self sendEvent:AGRemoteAudioMixingStart params:@{
                                                      @"message": @"RemoteAudioMixingStarted"
                                            }];
 }
 
+- (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,
                                               }];
 }
 
+- (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

      * @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
+     * @returns Promise<{success}>
+     */
+    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 'mediaMetaDataReceived' event, here is example:
+     * ```javascript
+     *      RtcEngine.on("mediaMetaDataReceived", (data) => {
+     *        console.log("mediaMetaDataReceived", 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

 "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);
     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
+     * @returns Promise<{success}>
+     */
+    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 'mediaMetaDataReceived' event, here is example:
+     * ```javascript
+     *      RtcEngine.on("mediaMetaDataReceived", (data) => {
+     *        console.log("mediaMetaDataReceived", 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;

package.json

 {
   "name": "react-native-agora",
-  "version": "2.4.0-alpha.5",
+  "version": "2.4.1-alpha.1",
   "description": "React Native around the Agora RTC SDKs for Android and iOS agora",
   "summary": "agora native sdk for react-native",
   "main": "lib/index.js",

react-native-agora.podspec

       "$(SDKROOT)../../ios/Pods"
     ]
   }
-  s.dependency "AgoraRtcEngine_iOS", "2.4.0.1"
+  s.dependency "AgoraRtcEngine_iOS", "2.4.1"
   s.dependency 'React'
 
 end

src/RtcEngine.native.ts

     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
+     * @returns Promise<{success}>
+     */
+    static sendMediaData(data: String): Promise<any> {
+        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 'mediaMetaDataReceived' event, here is example:
+     * ```javascript
+     *      RtcEngine.on("mediaMetaDataReceived", (data) => {
+     *        console.log("mediaMetaDataReceived", 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
+        }
+    }
+
 }