feat. add start & update & stop & remove channelMediaDelay

CHANGELOG

     * `mediaRelayStateChanged`, `receivedChannelMediaRelay`
   - new apis:
     * `switchChannel` switch to specified channel
-    * `startChannelMediaRelay`, `updateChannelMediaRelay`, `stopChannelMediaRelay` relay media streams operation for across channels.
+    * `startChannelMediaRelay`, `updateChannelMediaRelay`, `stopChannelMediaRelay`, `removeChannelMediaRelay` relay media streams operation for across channels.
 
 #### 2.8.0-alpha.1
   - add `string uid` api support

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

         AgoraManager.getInstance().init(getReactApplicationContext(), mRtcEventHandler, options);
         appId = options.getString("appid");
         rtcEngine = AgoraManager.getInstance().mRtcEngine;
+        rtcEngine.setParameters("{\"rtc.log_filter\": 65535}");
     }
 
     @ReactMethod
         RtcEngine.destroy();
     }
 
-
-
     @ReactMethod
     public void startChannelMediaRelay(ReadableMap options, Promise promise) {
         ChannelMediaRelayConfiguration config = new ChannelMediaRelayConfiguration();
-        ReadableMap srcOption = options.getMap("src");
         ChannelMediaInfo src = config.getSrcChannelMediaInfo();
-        if (srcOption.hasKey("token")) {
-            src.token = srcOption.getString("token");
-        }
-        if (srcOption.hasKey("channelName")) {
-            src.channelName = srcOption.getString("channelName");
-        }
-        ReadableMap dstMediaInfo = options.getMap("dst");
-        String dstChannelName = null;
-        Integer dstUid = 0;
-        String dstToken = null;
-        if (dstMediaInfo.hasKey("token")) {
-            dstToken = options.getString("token");
-        }
-        if (dstMediaInfo.hasKey("channelName")) {
-            dstChannelName = options.getString("channelName");
+        if (options.hasKey("src")) {
+            ReadableMap srcOption = options.getMap("src");
+            if (srcOption.hasKey("token")) {
+                src.token = srcOption.getString("token");
+            }
+            if (srcOption.hasKey("channelName")) {
+                src.channelName = srcOption.getString("channelName");
+            }
         }
-        if (dstMediaInfo.hasKey("uid")) {
-            dstUid = options.getInt("uid");
+        ReadableArray dstMediaInfo = options.getArray("channels");
+        for (int i = 0; i < dstMediaInfo.size(); i++) {
+            ReadableMap dst = dstMediaInfo.getMap(i);
+            String channelName = null;
+            String token = null;
+            Integer uid = 0;
+            if (dst.hasKey("token")) {
+                token = token;
+            }
+            if (dst.hasKey("channelName")) {
+                channelName = dst.getString("channelName");
+            }
+            if (dst.hasKey("uid")) {
+                uid = dst.getInt("uid");
+            }
+            config.setDestChannelInfo(channelName, new ChannelMediaInfo(channelName, token, uid));
         }
-        ChannelMediaInfo dest = new ChannelMediaInfo(dstChannelName, dstToken, dstUid);
-        config.setDestChannelInfo(dest.channelName, dest);
         Integer res = AgoraManager.getInstance().mRtcEngine.startChannelMediaRelay(config);
         if (res == 0) {
             promise.resolve(null);
     }
 
     @ReactMethod
-    public void updateChannelMediaRelay(ReadableMap options, Promise promise) {
+    public void removeChannelMediaRelay(ReadableMap options, Promise promise) {
         ChannelMediaRelayConfiguration config = new ChannelMediaRelayConfiguration();
-        ReadableMap srcOption = options.getMap("src");
         ChannelMediaInfo src = config.getSrcChannelMediaInfo();
-        if (srcOption.hasKey("token")) {
-            src.token = srcOption.getString("token");
+        if (options.hasKey("src")) {
+            ReadableMap srcOption = options.getMap("src");
+            if (srcOption.hasKey("token")) {
+                src.token = srcOption.getString("token");
+            }
+            if (srcOption.hasKey("channelName")) {
+                src.channelName = srcOption.getString("channelName");
+            }
         }
-        if (srcOption.hasKey("channelName")) {
-            src.channelName = srcOption.getString("channelName");
+        ReadableArray dstMediaInfo = options.getArray("channels");
+        for (int i = 0; i < dstMediaInfo.size(); i++) {
+            ReadableMap dst = dstMediaInfo.getMap(i);
+            if (dst.hasKey("channelName")) {
+                channelName = dst.getString("channelName");
+                config.removeDestChannelInfo(channelName);
+            }
         }
-        ReadableMap dstMediaInfo = options.getMap("dst");
-        String dstChannelName = null;
-        Integer dstUid = 0;
-        String dstToken = null;
-        if (dstMediaInfo.hasKey("token")) {
-            dstToken = options.getString("token");
+        Integer res = AgoraManager.getInstance().mRtcEngine.updateChannelMediaRelay(config);
+        if (res == 0) {
+            promise.resolve(null);
+        } else {
+            promise.reject("-1", res.toString());
         }
-        if (dstMediaInfo.hasKey("channelName")) {
-            dstChannelName = options.getString("channelName");
+    }
+
+    @ReactMethod
+    public void updateChannelMediaRelay(ReadableMap options, Promise promise) {
+        ChannelMediaRelayConfiguration config = new ChannelMediaRelayConfiguration();
+        ChannelMediaInfo src = config.getSrcChannelMediaInfo();
+        if (options.hasKey("src")) {
+            ReadableMap srcOption = options.getMap("src");
+            if (srcOption.hasKey("token")) {
+                src.token = srcOption.getString("token");
+            }
+            if (srcOption.hasKey("channelName")) {
+                src.channelName = srcOption.getString("channelName");
+            }
         }
-        if (dstMediaInfo.hasKey("uid")) {
-            dstUid = options.getInt("uid");
+        ReadableArray dstMediaInfo = options.getArray("channels");
+        for (int i = 0; i < dstMediaInfo.size(); i++) {
+            ReadableMap dst = dstMediaInfo.getMap(i);
+            String channelName = null;
+            String token = null;
+            Integer uid = 0;
+            if (dst.hasKey("token")) {
+                token = token;
+            }
+            if (dst.hasKey("channelName")) {
+                channelName = dst.getString("channelName");
+            }
+            if (dst.hasKey("uid")) {
+                uid = dst.getInt("uid");
+            }
+            config.setDestChannelInfo(src.channelName, new ChannelMediaInfo(channelName, token, uid));
         }
-        ChannelMediaInfo dest = new ChannelMediaInfo(dstChannelName, dstToken, dstUid);
-        config.setDestChannelInfo(dest.channelName, dest);
         Integer res = AgoraManager.getInstance().mRtcEngine.updateChannelMediaRelay(config);
         if (res == 0) {
             promise.resolve(null);
     }
 
     @ReactMethod
-    public void stopChannelMediaRelay() {
-        AgoraManager.getInstance().mRtcEngine.stopChannelMediaRelay();
+    public void stopChannelMediaRelay(Promise promise) {
+        Integer res = AgoraManager.getInstance().mRtcEngine.stopChannelMediaRelay();
+        if (res == 0) {
+            promise.resolve(null);
+        } else {
+            promise.reject("-1", res.toString());
+        }
     }
 
     @ReactMethod
     @ReactMethod
     public void setCameraFocusPositionInPreview(ReadableMap options, Promise promise) {
         Integer res = AgoraManager.getInstance().mRtcEngine.setCameraFocusPositionInPreview(
-                    (float)options.getDouble("x"),
-                    (float)options.getDouble("y")
-            );
+                (float)options.getDouble("x"),
+                (float)options.getDouble("y")
+        );
         if (res == 0) {
             promise.resolve(null);
         } else {
     @ReactMethod
     public void createDataStream(ReadableMap options, Promise promise) {
         Integer res = AgoraManager.getInstance().mRtcEngine
-                    .createDataStream(
-                            options.getBoolean("ordered"),
-                            options.getBoolean("reliable")
-                            );
+                .createDataStream(
+                        options.getBoolean("ordered"),
+                        options.getBoolean("reliable")
+                );
         if (res == 0) {
             promise.resolve(null);
         } else {
     @ReactMethod
     public void startAudioMixing(ReadableMap options, Promise promise) {
         Integer res = AgoraManager.getInstance().mRtcEngine.startAudioMixing(
-                    options.getString("filepath"),
-                    options.getBoolean("loopback"),
-                    options.getBoolean("replace"),
-                    options.getInt("cycle")
+                options.getString("filepath"),
+                options.getBoolean("loopback"),
+                options.getBoolean("replace"),
+                options.getInt("cycle")
         );
         if (res == 0) {
             promise.resolve(null);
     @ReactMethod
     public void startAudioRecording(ReadableMap options, Promise promise) {
         Integer res = AgoraManager.getInstance().mRtcEngine
-                    .startAudioRecording(
-                            options.getString("filepath"),
-                            options.getInt("quality")
-        );
+                .startAudioRecording(
+                        options.getString("filepath"),
+                        options.getInt("quality")
+                );
         if (res == 0) {
             promise.resolve(null);
         } else {
     @ReactMethod
     public void stopAudioRecording(Promise promise) {
         Integer res = AgoraManager.getInstance().mRtcEngine
-                    .stopAudioRecording();
+                .stopAudioRecording();
         if (res == 0) {
             promise.resolve(null);
         } else {
     @ReactMethod
     public void stopEchoTest(Promise promise) {
         Integer res = AgoraManager.getInstance().mRtcEngine
-                    .stopEchoTest();
+                .stopEchoTest();
         if (res == 0) {
             promise.resolve(null);
         } else {
     @ReactMethod
     public void enableLastmileTest(Promise promise) {
         Integer res = AgoraManager.getInstance().mRtcEngine
-                    .enableLastmileTest();
+                .enableLastmileTest();
         if (res == 0) {
             promise.resolve(null);
         } else {
     @ReactMethod
     public void disableLastmileTest(Promise promise) {
         Integer res = AgoraManager.getInstance().mRtcEngine
-                    .disableLastmileTest();
+                .disableLastmileTest();
         if (res == 0) {
             promise.resolve(null);
         } else {
     @ReactMethod
     public void setRecordingAudioFrameParameters(ReadableMap options, Promise promise) {
         Integer res = AgoraManager.getInstance().mRtcEngine
-                    .setRecordingAudioFrameParameters(
-                            options.getInt("sampleRate"),
-                            options.getInt("channel"),
-                            options.getInt("mode"),
-                            options.getInt("samplesPerCall")
-        );
+                .setRecordingAudioFrameParameters(
+                        options.getInt("sampleRate"),
+                        options.getInt("channel"),
+                        options.getInt("mode"),
+                        options.getInt("samplesPerCall")
+                );
         if (res == 0) {
             promise.resolve(null);
         } else {
     @ReactMethod
     public void setPlaybackAudioFrameParameters(ReadableMap options, Promise promise) {
         Integer res = AgoraManager.getInstance().mRtcEngine
-                    .setPlaybackAudioFrameParameters(
-                            options.getInt("sampleRate"),
-                            options.getInt("channel"),
-                            options.getInt("mode"),
-                            options.getInt("samplesPerCall")
-        );
+                .setPlaybackAudioFrameParameters(
+                        options.getInt("sampleRate"),
+                        options.getInt("channel"),
+                        options.getInt("mode"),
+                        options.getInt("samplesPerCall")
+                );
         if (res == 0) {
             promise.resolve(null);
         } else {
     @ReactMethod
     public void setMixedAudioFrameParameters(WritableMap options, Promise promise) {
         Integer res = AgoraManager.getInstance().mRtcEngine
-                    .setMixedAudioFrameParameters(
-                            options.getInt("sampleRate"),
-                            options.getInt("samplesPerCall")
-                    );
+                .setMixedAudioFrameParameters(
+                        options.getInt("sampleRate"),
+                        options.getInt("samplesPerCall")
+                );
         if (res == 0) {
             promise.resolve(null);
         } else {
     @ReactMethod
     public void addVideoWatermark(ReadableMap options, Promise promise) {
         Integer res = AgoraManager.getInstance().mRtcEngine
-                    .addVideoWatermark(createAgoraImage(options));
+                .addVideoWatermark(createAgoraImage(options));
         if (res == 0) {
             promise.resolve(null);
         } else {
     @ReactMethod
     public void clearVideoWatermarks(Promise promise) {
         Integer res = AgoraManager.getInstance().mRtcEngine
-                    .clearVideoWatermarks();
+                .clearVideoWatermarks();
         if (res == 0) {
             promise.resolve(null);
         } else {
     @ReactMethod
     public void setLocalPublishFallbackOption(int option, Promise promise) {
         Integer res = AgoraManager.getInstance().mRtcEngine
-                    .setLocalPublishFallbackOption(option);
+                .setLocalPublishFallbackOption(option);
         if (res == 0) {
             promise.resolve(null);
         } else {
     @ReactMethod
     public void setRemoteSubscribeFallbackOption(int option, Promise promise) {
         Integer res = AgoraManager.getInstance().mRtcEngine
-                    .setRemoteSubscribeFallbackOption(option);
+                .setRemoteSubscribeFallbackOption(option);
         if (res == 0) {
             promise.resolve(null);
         } else {
     @ReactMethod
     public void enableDualStreamMode(boolean enabled, Promise promise) {
         Integer res = AgoraManager.getInstance().mRtcEngine
-                    .enableDualStreamMode(enabled);
+                .enableDualStreamMode(enabled);
         if (res == 0) {
             promise.resolve(null);
         } else {
     @ReactMethod
     public void setRemoteVideoStreamType(ReadableMap options, Promise promise) {
         Integer res = AgoraManager.getInstance().mRtcEngine
-                    .setRemoteVideoStreamType(
-                            options.getInt("uid"),
-                            options.getInt("streamType")
-                        );
+                .setRemoteVideoStreamType(
+                        options.getInt("uid"),
+                        options.getInt("streamType")
+                );
         if (res == 0) {
             promise.resolve(null);
         } else {
     @ReactMethod
     public void setRemoteDefaultVideoStreamType(ReadableMap options, Promise promise) {
         Integer res = AgoraManager.getInstance().mRtcEngine
-                    .setRemoteDefaultVideoStreamType(
-                            options.getInt("streamType")
-                    );
+                .setRemoteDefaultVideoStreamType(
+                        options.getInt("streamType")
+                );
         if (res == 0) {
             promise.resolve(null);
         } else {
     @ReactMethod
     public void removeInjectStreamUrl(ReadableMap options, Promise promise) {
         Integer res = AgoraManager.getInstance().mRtcEngine
-                    .removeInjectStreamUrl(options.getString("url"));
+                .removeInjectStreamUrl(options.getString("url"));
         if (res == 0) {
             promise.resolve(null);
         } else {
     @ReactMethod
     public void addPublishStreamUrl(ReadableMap options, Promise promise) {
         Integer res = AgoraManager.getInstance().mRtcEngine
-                    .addPublishStreamUrl(
-                            options.getString("url"),
-                            options.getBoolean("enable")
-                    );
+                .addPublishStreamUrl(
+                        options.getString("url"),
+                        options.getBoolean("enable")
+                );
         if (res == 0) {
             promise.resolve(null);
         } else {
     @ReactMethod
     public void removePublishStreamUrl(ReadableMap options, Promise promise) {
         Integer res = AgoraManager.getInstance().mRtcEngine
-                    .removePublishStreamUrl(options.getString("url"));
+                .removePublishStreamUrl(options.getString("url"));
         if (res == 0) {
             promise.resolve(null);
         } else {
     public void playEffect(ReadableMap options, Promise promise) {
         IAudioEffectManager manager = AgoraManager.getInstance().mRtcEngine.getAudioEffectManager();
         Integer res = manager.playEffect(
-            options.getInt("soundid"),
-            options.getString("filepath"),
-            options.getInt("loopcount"),
-            options.getDouble("pitch"),
-            options.getDouble("pan"),
-            options.getDouble("gain"),
-            options.getBoolean("publish")
+                options.getInt("soundid"),
+                options.getString("filepath"),
+                options.getInt("loopcount"),
+                options.getDouble("pitch"),
+                options.getDouble("pan"),
+                options.getDouble("gain"),
+                options.getBoolean("publish")
         );
         if (res == 0) {
             promise.resolve(null);

ios/RCTAgora/AgoraConst.m

                                   AGTokenPrivilegeWillExpire,
                                   AGRequestToken,
                                   
-                                  AGLocalAudioStateChanged,
-                                  AGRemoteAudioStateChanged,
-                                  AGLocalAudioStats,
                                   AGAudioVolumeIndication,
                                   AGActiveSpeaker,
                                   AGFirstLocalAudioFrame,
                                   AGLocalVideoStats,
                                   AGRemoteVideoStats,
                                   AGRemoteAudioStats,
+                                  AGLocalAudioStateChanged,
+                                  AGRemoteAudioStateChanged,
+                                  AGLocalAudioStats,
+                                  AGMediaRelayStateChanged,
+                                  AGReceivedChannelMediaRelay,
                                   
                                   AGAudioMixingStateChanged,
                                   AGRemoteAudioMixingStart,
                                   AGReceiveStreamMessage,
                                   AGOccurStreamMessageError,
                                   
-                                  AGReceivedChannelMediaRelay,
-                                  AGMediaRelayStateChanged,
-                                  
                                   AGMediaEngineLoaded,
                                   AGMediaEngineStartCall,
                                   AGIntervalTest,

ios/RCTAgora/RCTAgora.m

                   resolve:(RCTPromiseResolveBlock)resolve
                   reject:(RCTPromiseRejectBlock)reject) {
   AgoraChannelMediaRelayConfiguration *config = [[AgoraChannelMediaRelayConfiguration alloc] init];
-  
   AgoraChannelMediaRelayInfo *src = [config sourceInfo];
   NSDictionary *srcOption = options[@"src"];
-  src.channelName = srcOption[@"channelName"];
-  src.uid = [srcOption[@"uid"] integerValue];
-  src.token = srcOption[@"token"];
-  AgoraChannelMediaRelayInfo *dst = [[AgoraChannelMediaRelayInfo alloc] init];
-  NSDictionary *dstOption = options[@"dst"];
-  dst.channelName = dstOption[@"channelName"];
-  dst.uid = [dstOption[@"uid"] integerValue];
-  dst.token = dstOption[@"token"];
-  [config setDestinationInfo:dst forChannelName:dstOption[@"channelName"]];
+  if (srcOption != nil) {
+    src.channelName = srcOption[@"channelName"];
+    src.uid = [srcOption[@"uid"] integerValue];
+    src.token = srcOption[@"token"];
+  }
+  NSArray *channels = options[@"channels"];
+  for (NSDictionary *channel in channels) {
+    AgoraChannelMediaRelayInfo *dst = [[AgoraChannelMediaRelayInfo alloc] init];
+    dst.channelName = channel[@"channelName"];
+    dst.uid = [channel[@"uid"] integerValue];
+    dst.token = channel[@"token"];
+    [config setDestinationInfo:dst forChannelName:dst.channelName];
+  }
   NSInteger res = [self.rtcEngine startChannelMediaRelay:config];
   if (res == 0) {
     resolve(nil);
                   resolve:(RCTPromiseResolveBlock)resolve
                   reject:(RCTPromiseRejectBlock)reject) {
   AgoraChannelMediaRelayConfiguration *config = [[AgoraChannelMediaRelayConfiguration alloc] init];
-  
   AgoraChannelMediaRelayInfo *src = [config sourceInfo];
   NSDictionary *srcOption = options[@"src"];
-  src.channelName = srcOption[@"channelName"];
-  src.uid = [srcOption[@"uid"] integerValue];
-  src.token = srcOption[@"token"];
-  AgoraChannelMediaRelayInfo *dst = [[AgoraChannelMediaRelayInfo alloc] init];
-  NSDictionary *dstOption = options[@"dst"];
-  dst.channelName = dstOption[@"channelName"];
-  dst.uid = [dstOption[@"uid"] integerValue];
-  dst.token = dstOption[@"token"];
-  [config setDestinationInfo:dst forChannelName:dstOption[@"channelName"]];
+  if (srcOption != nil) {
+    src.channelName = srcOption[@"channelName"];
+    src.uid = [srcOption[@"uid"] integerValue];
+    src.token = srcOption[@"token"];
+  }
+  NSArray *channels = options[@"channels"];
+  for (NSDictionary *channel in channels) {
+    AgoraChannelMediaRelayInfo *dst = [[AgoraChannelMediaRelayInfo alloc] init];
+    dst.channelName = channel[@"channelName"];
+    dst.uid = [channel[@"uid"] integerValue];
+    dst.token = channel[@"token"];
+    [config setDestinationInfo:dst forChannelName:dst.channelName];
+  }
+  NSInteger res = [self.rtcEngine updateChannelMediaRelay:config];
+  if (res == 0) {
+    resolve(nil);
+  } else {
+    reject(@(-1).stringValue, @(res).stringValue, nil);
+  }
+}
+
+// removeChannelMediaRelay
+RCT_EXPORT_METHOD(removeChannelMediaRelay:(NSDictionary *)options
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject) {
+  AgoraChannelMediaRelayConfiguration *config = [[AgoraChannelMediaRelayConfiguration alloc] init];
+  AgoraChannelMediaRelayInfo *src = [config sourceInfo];
+  NSDictionary *srcOption = options[@"src"];
+  if (srcOption != nil) {
+    src.channelName = srcOption[@"channelName"];
+    src.uid = [srcOption[@"uid"] integerValue];
+    src.token = srcOption[@"token"];
+  }
+  NSArray *channels = options[@"channels"];
+  for (NSDictionary *channel in channels) {
+    if (channel[@"channelName"] != nil) {
+      [config removeDestinationInfoForChannelName:channel[@"channelName"]];
+    }
+  }
   NSInteger res = [self.rtcEngine updateChannelMediaRelay:config];
   if (res == 0) {
     resolve(nil);
   AgoraUserInfo *info = [self.rtcEngine getUserInfoByUid:uid withError:&code];
   if ((int)code == 0) {
     resolve(@{
-        @"uid": @(info.uid),
-        @"userAccount": info.userAccount
-    });
+              @"uid": @(info.uid),
+              @"userAccount": info.userAccount
+              });
   } else {
     reject(@(-1).stringValue, @((int)code).stringValue, nil);
   }
 
 - (void)rtcEngine:(AgoraRtcEngineKit *_Nonnull)engine didUpdatedUserInfo:(AgoraUserInfo *_Nonnull)userInfo withUid:(NSUInteger)uid {
   [self sendEvent:AGUserInfoUpdated params:@{
-                                                 @"uid": @(uid),
-                                                 @"peer": @{
-                                                     @"uid": @(userInfo.uid),
-                                                     @"userAccount": userInfo.userAccount
+                                             @"uid": @(uid),
+                                             @"peer": @{
+                                                 @"uid": @(userInfo.uid),
+                                                 @"userAccount": userInfo.userAccount
                                                  }}];
 }
 
 
 - (void)rtcEngine:(AgoraRtcEngineKit *_Nonnull)engine localAudioStateChange:(AgoraAudioLocalState)state error:(AgoraAudioLocalError)error {
   [self sendEvent:AGLocalAudioStateChanged params:@{
-                                               @"state": @(state),
-                                               @"errorCode": @(error)
-                                               }];
+                                                    @"state": @(state),
+                                                    @"errorCode": @(error)
+                                                    }];
 }
 
 - (void)rtcEngine:(AgoraRtcEngineKit *_Nonnull)engine remoteAudioStateChangedOfUid:(NSUInteger)uid state:(AgoraAudioRemoteState)state reason:(AgoraAudioRemoteStateReason)reason elapsed:(NSInteger)elapsed {
   [self sendEvent:AGRemoteAudioStateChanged params:@{
-                                                    @"uid": @(uid),
-                                                    @"state": @(state),
-                                                    @"reason": @(reason),
-                                                    @"elapsed": @(elapsed)
-                                                    }];
+                                                     @"uid": @(uid),
+                                                     @"state": @(state),
+                                                     @"reason": @(reason),
+                                                     @"elapsed": @(elapsed)
+                                                     }];
 }
 
 - (void)rtcEngine:(AgoraRtcEngineKit *_Nonnull)engine localAudioStats:(AgoraRtcLocalAudioStats *_Nonnull)stats {
   [self sendEvent:AGLocalAudioStats params:@{
-                                                     @"numChannels": @(stats.numChannels),
-                                                     @"sentSampleRate": @(stats.sentSampleRate),
-                                                     @"sentBitrate": @(stats.sentBitrate),
-                                                     }];
+                                             @"numChannels": @(stats.numChannels),
+                                             @"sentSampleRate": @(stats.sentSampleRate),
+                                             @"sentBitrate": @(stats.sentBitrate),
+                                             }];
 }
 
 - (void)rtcEngine:(AgoraRtcEngineKit *_Nonnull)engine reportAudioVolumeIndicationOfSpeakers:(NSArray<AgoraRtcAudioVolumeInfo*> *_Nonnull)speakers totalVolume:(NSInteger)totalVolume {
   [self sendEvent:AGMediaRelayStateChanged params:@{
                                                     @"state": @(state),
                                                     @"errorCode": @(error),
-                                                   }];
+                                                    }];
 }
 
 - (void)rtcEngine:(AgoraRtcEngineKit *_Nonnull)engine didReceiveChannelMediaRelayEvent:(AgoraChannelMediaRelayEvent)event {
   [self sendEvent:AGReceivedChannelMediaRelay params:@{
-                                                  @"event": @(event),
-                                                  }];
+                                                       @"event": @(event),
+                                                       }];
 }
 
 - (void)rtcEngine:(AgoraRtcEngineKit *_Nonnull)engine receiveStreamMessageFromUid:(NSUInteger)uid streamId:(NSInteger)streamId data:(NSData *_Nonnull)data {

lib/RtcEngine.native.d.ts

-import { Option, Callback, AgoraUserInfo, AudioMixingOption, PlayEffectOption, AudioRecordingOption, AudioFrameOption, MixedAudioFrameOption, ImageOption, VideoStreamOption, DefaultVideoStreamOption, InjectStreamOption, RemoveInjectStreamOption, PublishStreamOption, RemovePublishStreamOption, LiveTranscodingOption, PositionOption, BeautyOption, LastmileProbeConfig, CameraCapturerConfiguration } from "./types";
+import { Option, Callback, AgoraUserInfo, AudioMixingOption, PlayEffectOption, AudioRecordingOption, AudioFrameOption, MixedAudioFrameOption, ImageOption, VideoStreamOption, DefaultVideoStreamOption, InjectStreamOption, RemoveInjectStreamOption, PublishStreamOption, RemovePublishStreamOption, LiveTranscodingOption, PositionOption, BeautyOption, LastmileProbeConfig, CameraCapturerConfiguration, ChannelMediaConfiguration } from "./types";
 /**
  * RtcEngine is the javascript object for control agora native sdk through react native bridge.
  *
      * @param token
      */
     static switchChannel(channelName: string, token?: string): Promise<any>;
-    static startChannelMediaRelay(): void;
-    static updateChannelMediaRelay(): void;
-    static stopChannelMediaRelay(): void;
+    /**
+     * Starts to relay media streams across channels.
+     *
+     * This method will start relay media stream across specified channels. (maximum support 4 channels)
+     * It will occurs event:
+     *  Occurs onChannelMediaRelayStateChanged
+     * @param config
+     */
+    static startChannelMediaRelay(config: ChannelMediaConfiguration): Promise<any>;
+    /**
+     * Remove to relay media streams across channels.
+     *
+     * This method will remove & update relay media stream across specified channels. (maximum support relay 4 channels)
+     * It will occurs event:
+     *  Occurs onChannelMediaRelayStateChanged
+     * @param config
+     */
+    static removeChannelMediaRelay(config: ChannelMediaConfiguration): Promise<any>;
+    /**
+     * Updates to relay media streams across channels.
+     *
+     * This method will update relay media stream across specified channels. (maximum support 4 channels)
+     * It will occurs event:
+     *  Occurs onChannelMediaRelayStateChanged
+     * @param config
+     */
+    static updateChannelMediaRelay(config: ChannelMediaConfiguration): Promise<any>;
+    /**
+     * Stop to relay media streams across channels.
+     *
+     * This method will stop relay media stream across specified channels.
+     * It will occurs event:
+     *  Occurs onChannelMediaRelayStateChanged
+     * @param config
+     */
+    static stopChannelMediaRelay(): Promise<any>;
     /**
      * Registers a user account.
      *

lib/RtcEngine.native.js

     static switchChannel(channelName, token) {
         return Agora.switchChannel({ channelName, token });
     }
-    static startChannelMediaRelay() {
+    /**
+     * Starts to relay media streams across channels.
+     *
+     * This method will start relay media stream across specified channels. (maximum support 4 channels)
+     * It will occurs event:
+     *  Occurs onChannelMediaRelayStateChanged
+     * @param config
+     */
+    static startChannelMediaRelay(config) {
+        return Agora.startChannelMediaRelay(config);
     }
-    static updateChannelMediaRelay() {
+    /**
+     * Remove to relay media streams across channels.
+     *
+     * This method will remove & update relay media stream across specified channels. (maximum support relay 4 channels)
+     * It will occurs event:
+     *  Occurs onChannelMediaRelayStateChanged
+     * @param config
+     */
+    static removeChannelMediaRelay(config) {
+        return Agora.removeChannelMediaRelay(config);
     }
+    /**
+     * Updates to relay media streams across channels.
+     *
+     * This method will update relay media stream across specified channels. (maximum support 4 channels)
+     * It will occurs event:
+     *  Occurs onChannelMediaRelayStateChanged
+     * @param config
+     */
+    static updateChannelMediaRelay(config) {
+        return Agora.updateChannelMediaRelay(config);
+    }
+    /**
+     * Stop to relay media streams across channels.
+     *
+     * This method will stop relay media stream across specified channels.
+     * It will occurs event:
+     *  Occurs onChannelMediaRelayStateChanged
+     * @param config
+     */
     static stopChannelMediaRelay() {
+        return Agora.stopChannelMediaRelay();
     }
     /**
      * Registers a user account.

lib/types.d.ts

 import { ViewProps } from 'react-native';
+/**
+ * ChannelMediaInfo
+ * @property channelName: string
+ * @property token: string
+ * @property uid: number
+ */
+export interface ChannelMediaInfo {
+    channelName: string;
+    token?: string;
+    uid?: number;
+}
+/**
+ * ChannelMediaConfiguration
+ * @property src: {
+ *    @member channelName,
+ *    @member token,
+ *    @member uid,
+ * }
+ * @property channels: {@link Array<ChannelMediaInfo>}
+ */
+export interface ChannelMediaConfiguration {
+    src?: {
+        channelName: string;
+        token?: string;
+        uid?: number;
+    };
+    channels: Array<ChannelMediaInfo>;
+}
 /**
  * AgoraViewMode
  * @mode hidden Uniformly scale the video until it fills the visible boundaries (cropped). One dimension of the video may have clipped contents.

lib/types.js.map

-{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":";;AAEA;;;;GAIG;AACH,IAAY,aAGX;AAHD,WAAY,aAAa;IACvB,qDAAU,CAAA;IACV,+CAAO,CAAA;AACT,CAAC,EAHW,aAAa,GAAb,qBAAa,KAAb,qBAAa,QAGxB;AAUA,CAAC;AAuGF,IAAY,iBAIX;AAJD,WAAY,iBAAiB;IAC3B,kEAAa,CAAA;IACb,0DAAS,CAAA;IACT,2DAAU,CAAA;AACZ,CAAC,EAJW,iBAAiB,GAAjB,yBAAiB,KAAjB,yBAAiB,QAI5B;AAED,IAAY,iBAGX;AAHD,WAAY,iBAAiB;IAC3B,6DAAU,CAAA;IACV,6DAAU,CAAA;AACZ,CAAC,EAHW,iBAAiB,GAAjB,yBAAiB,KAAjB,yBAAiB,QAG5B;AAED,IAAY,eAIX;AAJD,WAAY,eAAe;IACzB,qEAAkB,CAAA;IAClB,qEAAkB,CAAA;IAClB,qEAAkB,CAAA;AACpB,CAAC,EAJW,eAAe,GAAf,uBAAe,KAAf,uBAAe,QAI1B;AAED;;;GAGG;AACH,IAAY,kBAMX;AAND,WAAY,kBAAkB;IAC5B,yDAAO,CAAA;IACP,yDAAO,CAAA;IACP,6DAAS,CAAA;IACT,2DAAQ,CAAA;IACR,2DAAQ,CAAA;AACV,CAAC,EANW,kBAAkB,GAAlB,0BAAkB,KAAlB,0BAAkB,QAM7B"}
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":";;AA+BA;;;;GAIG;AACH,IAAY,aAGX;AAHD,WAAY,aAAa;IACvB,qDAAU,CAAA;IACV,+CAAO,CAAA;AACT,CAAC,EAHW,aAAa,GAAb,qBAAa,KAAb,qBAAa,QAGxB;AAUA,CAAC;AAuGF,IAAY,iBAIX;AAJD,WAAY,iBAAiB;IAC3B,kEAAa,CAAA;IACb,0DAAS,CAAA;IACT,2DAAU,CAAA;AACZ,CAAC,EAJW,iBAAiB,GAAjB,yBAAiB,KAAjB,yBAAiB,QAI5B;AAED,IAAY,iBAGX;AAHD,WAAY,iBAAiB;IAC3B,6DAAU,CAAA;IACV,6DAAU,CAAA;AACZ,CAAC,EAHW,iBAAiB,GAAjB,yBAAiB,KAAjB,yBAAiB,QAG5B;AAED,IAAY,eAIX;AAJD,WAAY,eAAe;IACzB,qEAAkB,CAAA;IAClB,qEAAkB,CAAA;IAClB,qEAAkB,CAAA;AACpB,CAAC,EAJW,eAAe,GAAf,uBAAe,KAAf,uBAAe,QAI1B;AAED;;;GAGG;AACH,IAAY,kBAMX;AAND,WAAY,kBAAkB;IAC5B,yDAAO,CAAA;IACP,yDAAO,CAAA;IACP,6DAAS,CAAA;IACT,2DAAQ,CAAA;IACR,2DAAQ,CAAA;AACV,CAAC,EANW,kBAAkB,GAAlB,0BAAkB,KAAlB,0BAAkB,QAM7B"}

src/RtcEngine.native.ts

     PositionOption,
     BeautyOption,
     LastmileProbeConfig,
-    CameraCapturerConfiguration
+    CameraCapturerConfiguration,
+    ChannelMediaConfiguration
 } from "./types";
 
 
         return Agora.switchChannel({channelName, token});
     }
     
-    public static startChannelMediaRelay() {
-
+    /**
+     * Starts to relay media streams across channels.
+     * 
+     * This method will start relay media stream across specified channels. (maximum support 4 channels)
+     * It will occurs event:
+     *  Occurs onChannelMediaRelayStateChanged
+     * @param config
+     */
+    public static startChannelMediaRelay(config: ChannelMediaConfiguration): Promise<any> {
+        return Agora.startChannelMediaRelay(config);
     }
 
-    public static updateChannelMediaRelay() {
+    /**
+     * Remove to relay media streams across channels.
+     * 
+     * This method will remove & update relay media stream across specified channels. (maximum support relay 4 channels)
+     * It will occurs event:
+     *  Occurs onChannelMediaRelayStateChanged
+     * @param config
+     */
+    public static removeChannelMediaRelay(config: ChannelMediaConfiguration): Promise<any> {
+        return Agora.removeChannelMediaRelay(config);
+    }
 
+    /**
+     * Updates to relay media streams across channels.
+     * 
+     * This method will update relay media stream across specified channels. (maximum support 4 channels)
+     * It will occurs event:
+     *  Occurs onChannelMediaRelayStateChanged
+     * @param config
+     */
+    public static updateChannelMediaRelay(config: ChannelMediaConfiguration): Promise<any> {
+        return Agora.updateChannelMediaRelay(config);
     }
 
-    public static stopChannelMediaRelay() {
-        
+    /**
+     * Stop to relay media streams across channels.
+     * 
+     * This method will stop relay media stream across specified channels.
+     * It will occurs event:
+     *  Occurs onChannelMediaRelayStateChanged
+     * @param config
+     */
+    public static stopChannelMediaRelay(): Promise<any> {
+        return Agora.stopChannelMediaRelay();
     }
 
     /**

src/types.ts

 import { ViewProps } from 'react-native';
 
+/**
+ * ChannelMediaInfo
+ * @property channelName: string
+ * @property token: string
+ * @property uid: number
+ */
+export interface ChannelMediaInfo {
+  channelName: string
+  token?: string
+  uid?: number
+}
+/**
+ * ChannelMediaConfiguration
+ * @property src: {
+ *    @member channelName,
+ *    @member token,
+ *    @member uid,
+ * }
+ * @property channels: {@link Array<ChannelMediaInfo>}
+ */
+export interface ChannelMediaConfiguration {
+  src?: {
+    channelName: string
+    token?: string
+    uid?: number
+  }
+  channels: Array<ChannelMediaInfo>
+}
+
 /**
  * AgoraViewMode
  * @mode hidden Uniformly scale the video until it fills the visible boundaries (cropped). One dimension of the video may have clipped contents.