feat. support 2.4.0.1 ios

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.3.3"
+    implementation "io.agora.rtc:full-sdk:2.4.0"
     // from node_modules
     implementation "com.facebook.react:react-native:+"
 }

ios/RCTAgora/AgoraConst.h

 static NSString *AGMediaEngineLoaded = @"mediaEngineLoaded";
 static NSString *AGMediaEngineStartCall = @"mediaEngineStartCall";
 
+static NSString *AGIntervalTest = @"startEchoTestWithInterval";
+static NSString *AGAudioMixingStateChanged = @"audioMixingStateChanged";
+static NSString *AGLastmileProbeTestResult = @"lastmileProbeTestResult";
+
 typedef NS_ENUM(NSInteger, AgoraModeType) {
   AgoraAudioMode,
   AgoraVideoMode

ios/RCTAgora/RCTAgora.m

      [self.rtcEngine enableAudio];
    }
   
+  if ([options objectForKey:@"beauty"]) {
+    AgoraBeautyOptions *beautyOption = [[AgoraBeautyOptions alloc] init];
+    beautyOption.lighteningContrastLevel = [options[@"beauty"][@"lighteningContrastLevel"] integerValue];
+    beautyOption.lighteningLevel = [options[@"beauty"][@"lighteningLevel"] floatValue];
+    beautyOption.smoothnessLevel = [options[@"beauty"][@"smoothnessLevel"] floatValue];
+    beautyOption.rednessLevel = [options[@"beauty"][@"rednessLevel"] floatValue];
+      [self.rtcEngine setBeautyEffectOptions:true options:beautyOption];
+  }
+  if ([options objectForKey:@"voice"]) {
+    NSInteger voiceValue = [options[@"voice"][@"value"] integerValue];
+    NSString *voiceType = options[@"voice"][@"type"];
+    if ([voiceType isEqualToString: @"changer"]) {
+      [self.rtcEngine setLocalVoiceChanger:(AgoraAudioVoiceChanger)voiceValue];
+    }
+    if ([voiceType isEqualToString: @"reverbPreset"]) {
+      [self.rtcEngine setLocalVoiceReverbPreset:(AgoraAudioReverbPreset)voiceValue];
+    }
+  }
    if (options[@"secret"] != nil) {
      [self.rtcEngine setEncryptionSecret:[options[@"secret"] stringValue]];
      if (options[@"secretMode"] != nil) {
      }
    }
      
-   AgoraVideoEncoderConfiguration *video_encoder_config = [[AgoraVideoEncoderConfiguration new] initWithWidth:[options[@"videoEncoderConfig"][@"width"] integerValue] height:[options[@"videoEncoderConfig"][@"height"] integerValue] frameRate:(AgoraVideoFrameRate)[options[@"videoEncoderConfig"][@"frameRate"] integerValue] bitrate:[options[@"videoEncoderConfig"][@"bitrate"] integerValue] orientationMode: (AgoraVideoOutputOrientationMode)[options[@"videoEncoderConfig"][@"orientationMode"] integerValue]];
+   AgoraVideoEncoderConfiguration *video_encoder_config = [[AgoraVideoEncoderConfiguration new] initWithWidth:[options[@"videoEncoderConfig"][@"width"] integerValue] height:[options[@"videoEncoderConfig"][@"height"] integerValue] frameRate:[options[@"videoEncoderConfig"][@"frameRate"] integerValue] bitrate:[options[@"videoEncoderConfig"][@"bitrate"] integerValue] orientationMode: (AgoraVideoOutputOrientationMode)[options[@"videoEncoderConfig"][@"orientationMode"] integerValue]];
    [self.rtcEngine setVideoEncoderConfiguration:video_encoder_config];
    [self.rtcEngine setClientRole:(AgoraClientRole)[options[@"clientRole"] integerValue]];
    [self.rtcEngine setAudioProfile:(AgoraAudioProfile)[options[@"audioProfile"] integerValue]
   [self.rtcEngine enableAudioVolumeIndication:interval smooth:smooth];
 }
 
-// create data stream
-RCT_EXPORT_METHOD(createDataStream
+RCT_EXPORT_METHOD(sendMessage
                   :(NSDictionary *)options
                   resolve:(RCTPromiseResolveBlock)resolve
                   reject:(RCTPromiseRejectBlock)reject) {
-  NSInteger streamId = 0;
-  if (options[@"streamId"] != nil) {
-    streamId = [options[@"streamId"] integerValue];
+  NSInteger uid = 0;
+  if (options[@"streamID"] != nil) {
+    uid = [options[@"streamID"] integerValue];
+  }
+  NSInteger streamID = [self.rtcEngine createDataStream:&uid reliable:[options[@"reliable"] boolValue] ordered:[options[@"ordered"] boolValue]];
+  if (streamID < 0) {
+    reject(@"131001", @"createDataStream failed", [self makeNSError:@{
+                                                                      @"code": @(131001),
+                                                                      @"message":@{
+                                                                        @"success": @(NO),
+                                                                        @"value":[NSNumber numberWithInteger:uid]
+                                                                        }
+                                                                    }]);
+  }
+  NSString *dataStr = options[@"data"];
+  NSData *data = [dataStr dataUsingEncoding:NSUTF8StringEncoding];
+  NSInteger res = [self.rtcEngine sendStreamMessage:uid data:data];
+  if (res == 0) {
+    resolve(@{@"success": @(YES), @"streamID": @(uid)});
+  } else {
+    reject(@"131001", @"sendStreamMessage failed", [self makeNSError:@{
+                                                                       @"code": @(131001),
+                                                                       @"message":@{
+                                                                         @"success": @(NO),
+                                                                         @"value":[NSNumber numberWithInteger:res]
+                                                                         }
+                                                                     }]);
   }
-  [self.rtcEngine createDataStream:streamId reliable:[options[@"reliable"] boolValue] ordered:[options[@"ordered"] boolValue]];
-  resolve(@[[NSNumber numberWithInteger:streamId]]);
 }
 
+
 // is speaker phone enabled
 RCT_EXPORT_METHOD(methodisSpeakerphoneEnabled:(RCTResponseSenderBlock)callback) {
   callback(@[@{@"status": @([self.rtcEngine isSpeakerphoneEnabled])}]);
   [self.rtcEngine setAudioSessionOperationRestriction:restrictionType];
 }
 
+// deprecated
 // gateway test start echo
-RCT_EXPORT_METHOD(startEchoTest
-                  :(RCTPromiseResolveBlock)resolve
-                  reject:(RCTPromiseRejectBlock)reject) {
-  NSInteger res = [self.rtcEngine startEchoTest:^(NSString * _Nonnull channel, NSUInteger uid, NSInteger elapsed) {
-    _block(@{
-             @"channel": channel,
-             @"uid": @(uid),
-             @"elapsed": @(elapsed)
-             });
-  }];
-  if (res != 0) {
-    reject(@"131019", @"startEchoTest failed", [self makeNSError:@{
-                                                                   @"code": @(131019),
-                                                                   @"message":@{
-                                                                       @"success": @(NO),
-                                                                       @"value":@(res)
-                                                                       }
-                                                                   }]);
-  } else {
-    resolve(@{
-              @"success": @(YES),
-              @"value": @(res)
-              });
-  }
-}
+//RCT_EXPORT_METHOD(startEchoTest
+//                  :(RCTPromiseResolveBlock)resolve
+//                  reject:(RCTPromiseRejectBlock)reject) {
+//  NSInteger res = [self.rtcEngine startEchoTest:^(NSString * _Nonnull channel, NSUInteger uid, NSInteger elapsed) {
+//    _block(@{
+//             @"channel": channel,
+//             @"uid": @(uid),
+//             @"elapsed": @(elapsed)
+//             });
+//  }];
+//  if (res != 0) {
+//    reject(@"131019", @"startEchoTest failed", [self makeNSError:@{
+//                                                                   @"code": @(131019),
+//                                                                   @"message":@{
+//                                                                       @"success": @(NO),
+//                                                                       @"value":@(res)
+//                                                                       }
+//                                                                   }]);
+//  } else {
+//    resolve(@{
+//              @"success": @(YES),
+//              @"value": @(res)
+//              });
+//  }
+//}
 
 // gateway test stop echo
 RCT_EXPORT_METHOD(stopEchoTest
   }
 }
 
+// deprecated
 // set video quality
-RCT_EXPORT_METHOD(setVideoQualityParameters
-                  :(BOOL) quality
-                  resolve:(RCTPromiseResolveBlock)resolve
-                  reject:(RCTPromiseRejectBlock)reject) {
-  NSInteger res = [self.rtcEngine setVideoQualityParameters:quality];
-  if (res == 0) {
-    resolve(@{@"success": @(YES)});
-  } else {
-    reject(@"131033", @"setVideoQualityParameters failed", [self makeNSError:@{
-                                                                               @"code": @(131033),
-                                                                               @"message":@{
-                                                                                   @"success": @(NO),
-                                                                                   @"value":[NSNumber numberWithInteger:res]
-                                                                                   }
-                                                                               }]);
-  }
-}
+//RCT_EXPORT_METHOD(setVideoQualityParameters
+//                  :(BOOL) quality
+//                  resolve:(RCTPromiseResolveBlock)resolve
+//                  reject:(RCTPromiseRejectBlock)reject) {
+//  NSInteger res = [self.rtcEngine setVideoQualityParameters:quality];
+//  if (res == 0) {
+//    resolve(@{@"success": @(YES)});
+//  } else {
+//    reject(@"131033", @"setVideoQualityParameters failed", [self makeNSError:@{
+//                                                                               @"code": @(131033),
+//                                                                               @"message":@{
+//                                                                                   @"success": @(NO),
+//                                                                                   @"value":[NSNumber numberWithInteger:res]
+//                                                                                   }
+//                                                                               }]);
+//  }
+//}
 
 // set local video mirror mode
 RCT_EXPORT_METHOD(setLocalVideoMirrorMode
 // setLogFile and setLogFilter
 RCT_EXPORT_METHOD(setLog
                   :(NSString *)filePath
-                  level:(NSUInteger)level
+                    level:(NSUInteger)level
+                    size:(NSUInteger)size
                   resolve:(RCTPromiseResolveBlock)resolve
                   reject:(RCTPromiseRejectBlock)reject) {
-  int res = [self.rtcEngine setLogFilter:level];
+  int res = [self.rtcEngine setLogFileSize:size];
+  if (res != 0) {
+    reject(@"131036", @"setLogFileSize failed", [self makeNSError:@{
+                                                                  @"code": @(131036),
+                                                                  @"message":@{
+                                                                      @"success": @(NO),
+                                                                      @"value":[NSNumber numberWithInteger:res]
+                                                                      }
+                                                                  }]);
+  } else {
+    resolve(@{
+              @"success": @(YES),
+              @"value": @(res)
+              });
+  }
+  
+  res = [self.rtcEngine setLogFilter:level];
   if (res != 0) {
     reject(@"131036", @"setLogFilter failed", [self makeNSError:@{
                                                                   @"code": @(131036),
   }
 }
 
-// set
-
-// send stream message
-RCT_EXPORT_METHOD(sendStreamMessage:(NSInteger)streamId data:(NSData*)data
-                  resolve:(RCTPromiseResolveBlock)resolve
-                  reject:(RCTPromiseRejectBlock)reject) {
-  NSInteger res = [self.rtcEngine sendStreamMessage:(streamId) data:data];
-  if (res == 0) {
-    resolve(@{@"success": @(YES)});
-  } else {
-    reject(@"131001", @"sendStreamMessage failed", [self makeNSError:@{
-                                                                       @"code": @(131001),
-                                                                       @"message":@{
-                                                                           @"success": @(NO),
-                                                                           @"value":[NSNumber numberWithInteger:res]
-                                                                           }
-                                                                       }]);
-  }
-}
-
 // get sdk version
 RCT_EXPORT_METHOD(getSdkVersion
                   :(RCTPromiseResolveBlock) resolve
   [self.rtcEngine setLiveTranscoding:transcoding];
 }
 
+RCT_EXPORT_METHOD(setBeautyEffectOptions:(bool) enabled
+                  options:(NSDictionary *)options
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject) {
+  int res = [self.rtcEngine setBeautyEffectOptions:enabled options:options];
+  if (res != 0) {
+    reject(@"131037", @"setBeautyEffectOptions failed", [self makeNSError:@{
+                                                                @"code": @(131037),
+                                                                @"message":@{
+                                                                    @"success": @(NO),
+                                                                    @"value":[NSNumber numberWithInteger:res]
+                                                                    }
+                                                                }]);
+  } else {
+    resolve(@{
+              @"success": @(YES),
+              @"value": @(res)
+              });
+  }
+}
+
+RCT_EXPORT_METHOD(setLocalVoiceChanger:(NSInteger) voiceChanger
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject) {
+  int res = [self.rtcEngine setLocalVoiceChanger:(AgoraAudioVoiceChanger)voiceChanger];
+  if (res != 0) {
+    reject(@"131037", @"setBeautyEffectOptions failed", [self makeNSError:@{
+                                                                            @"code": @(131037),
+                                                                            @"message":@{
+                                                                                @"success": @(NO),
+                                                                                @"value":[NSNumber numberWithInteger:res]
+                                                                                }
+                                                                            }]);
+  } else {
+    resolve(@{
+              @"success": @(YES),
+              @"value": @(res)
+              });
+  }
+}
+
+RCT_EXPORT_METHOD(setLocalVoiceReverbPreset:(NSInteger) reverbPreset
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject) {
+  int res = [self.rtcEngine setLocalVoiceReverbPreset:(AgoraAudioReverbPreset)reverbPreset];
+  if (res != 0) {
+    reject(@"131037", @"setLocalVoiceReverbPreset failed", [self makeNSError:@{
+                                                                            @"code": @(131037),
+                                                                            @"message":@{
+                                                                                @"success": @(NO),
+                                                                                @"value":[NSNumber numberWithInteger:res]
+                                                                                }
+                                                                            }]);
+  } else {
+    resolve(@{
+              @"success": @(YES),
+              @"value": @(res)
+              });
+  }
+}
+
+RCT_EXPORT_METHOD(enableSoundPositionIndication:(bool) enabled
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject) {
+  int res = [self.rtcEngine enableSoundPositionIndication:enabled];
+  if (res != 0) {
+    reject(@"131037", @"enableSoundPositionIndication failed", [self makeNSError:@{
+                                                                               @"code": @(131037),
+                                                                               @"message":@{
+                                                                                   @"success": @(NO),
+                                                                                   @"value":[NSNumber numberWithInteger:res]
+                                                                                   }
+                                                                               }]);
+  } else {
+    resolve(@{
+              @"success": @(YES),
+              @"value": @(res)
+              });
+  }
+}
+
+RCT_EXPORT_METHOD(setRemoteVoicePosition:(NSInteger) uid
+                  pan:(float)pan
+                  gain:(float)gain
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject) {
+  int res = [self.rtcEngine setRemoteVoicePosition:uid pan:pan gain: gain];
+  if (res != 0) {
+    reject(@"131037", @"setRemoteVoicePosition failed", [self makeNSError:@{
+                                                                                   @"code": @(131037),
+                                                                                   @"message":@{
+                                                                                       @"success": @(NO),
+                                                                                       @"value":[NSNumber numberWithInteger:res]
+                                                                                       }
+                                                                                   }]);
+  } else {
+    resolve(@{
+              @"success": @(YES),
+              @"value": @(res)
+              });
+  }
+}
+
+RCT_EXPORT_METHOD(startLastmileProbeTest:(NSDictionary*)config
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject) {
+  AgoraLastmileProbeConfig* probeConfig = [[AgoraLastmileProbeConfig alloc] init];
+  probeConfig.probeUplink = [config[@"probeUplink"] boolValue];
+  probeConfig.probeDownlink = [config[@"probeDownlink"] boolValue];
+  probeConfig.expectedUplinkBitrate = [config[@"expectedUplinkBitrate"] integerValue];
+  probeConfig.expectedDownlinkBitrate = [config[@"expectedDownlinkBitrate"] integerValue];
+
+  int res = [self.rtcEngine startLastmileProbeTest:probeConfig];
+  if (res != 0) {
+    reject(@"131037", @"startLastmileProbeTest failed", [self makeNSError:@{
+                                                                            @"code": @(131037),
+                                                                            @"message":@{
+                                                                                @"success": @(NO),
+                                                                                @"value":[NSNumber numberWithInteger:res]
+                                                                                }
+                                                                            }]);
+  } else {
+    resolve(@{
+              @"success": @(YES),
+              @"value": @(res)
+              });
+  }
+}
+
+
+RCT_EXPORT_METHOD(setRemoteUserPriority:(NSUInteger)uid
+                  userPriority:(NSInteger)userPriority
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject) {
+ 
+  int res = [self.rtcEngine setRemoteUserPriority:uid type:(AgoraUserPriority)userPriority];
+  if (res != 0) {
+    reject(@"131037", @"setRemoteUserPriority failed", [self makeNSError:@{
+                                                                            @"code": @(131037),
+                                                                            @"message":@{
+                                                                                @"success": @(NO),
+                                                                                @"value":[NSNumber numberWithInteger:res]
+                                                                                }
+                                                                            }]);
+  } else {
+    resolve(@{
+              @"success": @(YES),
+              @"value": @(res)
+              });
+  }
+}
+
+RCT_EXPORT_METHOD(startEchoTestWithInterval:(NSInteger)interval
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject) {
+  
+  int res = [self.rtcEngine startEchoTestWithInterval:interval successBlock:^(NSString * _Nonnull channel, NSUInteger uid, NSInteger elapsed) {
+    [self sendEvent:AGIntervalTest params:@{
+                                            @"message": @"StartEchoTestWithInterval",
+                                            @"channel": channel,
+                                            @"uid": @(uid),
+                                            @"elapsed": @(elapsed),
+                                            }];
+  }];
+  if (res != 0) {
+    reject(@"131037", @"startEchoTestWithInterval failed", [self makeNSError:@{
+                                                                           @"code": @(131037),
+                                                                           @"message":@{
+                                                                               @"success": @(NO),
+                                                                               @"value":[NSNumber numberWithInteger:res]
+                                                                               }
+                                                                           }]);
+  } else {
+    resolve(@{
+              @"success": @(YES),
+              @"value": @(res)
+              });
+  }
+}
+
+RCT_EXPORT_METHOD(setCameraCapturerConfiguration:(NSDictionary *)config
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject) {
+  
+  AgoraCameraCapturerConfiguration* configuration = [[AgoraCameraCapturerConfiguration alloc] init];
+  configuration.preference = [config[@"preference"] integerValue];
+  
+  int res = [self.rtcEngine setCameraCapturerConfiguration:configuration];
+  if (res != 0) {
+    reject(@"131037", @"setCameraCapturerConfiguration failed", [self makeNSError:@{
+                                                                               @"code": @(131037),
+                                                                               @"message":@{
+                                                                                   @"success": @(NO),
+                                                                                   @"value":[NSNumber numberWithInteger:res]
+                                                                                   }
+                                                                               }]);
+  } else {
+    resolve(@{
+              @"success": @(YES),
+              @"value": @(res)
+              });
+  }
+}
+
 - (NSArray<NSString *> *)supportedEvents {
   return @[
            AGWarning,
            
            AGMediaEngineLoaded,
            AGMediaEngineStartCall,
+           AGIntervalTest,
+           AGAudioMixingStateChanged,
+           AGLastmileProbeTestResult
            ];
 }
 
                                                    }];
 }
 
+- (void)rtcEngine:(AgoraRtcEngineKit *_Nonnull)engine localAudioMixingStateDidChanged:(AgoraAudioMixingStateCode)state errorCode:(AgoraAudioMixingErrorCode)errorCode {
+  [self sendEvent:AGAudioMixingStateChanged params:@{
+                                                     @"message": @"AudioMixingStateChanged",
+                                                     @"state": @(state),
+                                                     @"errorCode": @(errorCode)
+                                                     }];
+}
+
+- (void)rtcEngine:(AgoraRtcEngineKit *_Nonnull)engine lastmileProbeTestResult:(AgoraLastmileProbeResult *_Nonnull)result {
+  [self sendEvent:AGLastmileProbeTestResult params:@{
+                                                     @"message":@"LastmileProbeTestResult",
+                                                     @"result": @{
+                                                         @"state": @(result.state),
+                                                         @"rtt": @(result.rtt),
+                                                         @"uplinkReport": @{
+                                                             @"packetLossRate": @(result.uplinkReport.packetLossRate),
+                                                             @"jitter": @(result.uplinkReport.jitter),
+                                                             @"availableBandwidth": @(result.uplinkReport.availableBandwidth),
+                                                             },
+                                                         @"downlinkReport": @{
+                                                             @"packetLossRate": @(result.downlinkReport.packetLossRate),
+                                                             @"jitter": @(result.downlinkReport.jitter),
+                                                             @"availableBandwidth": @(result.downlinkReport.availableBandwidth),
+                                                             }
+                                                         }
+                                                     }];
+}
+
 @end

lib/RtcEngine.native.js

      * @param data
      * @returns Promise<{success, value}>
      */
-    static sendStreamMessage(uid, data) {
-        return Agora.sendStreamMessage(uid, data);
+    static sendMessage(streamID, data, reliable, ordered) {
+        return Agora.sendMessage({ streamID, data, reliable, ordered });
     }
     /**
      * add publish stream url
     static muteLocalAudioStream(enabled) {
         Agora.muteLocalAudioStream(enabled);
     }
+    /**
+     * video pre-process/post-process
+     *
+     * This method enables/disables image enhancement and sets the options.
+     *
+     * @param enable boolean
+     * @param options {@link BeautyOptions}
+     * @returns operate result boolean
+     */
+    static setBeautyEffectOptions(enabled, options) {
+        return Agora.setBeautyEffectOptions(enabled, options);
+    }
+    /**
+     * set local voice change
+     *
+     * This method changes local speaker voice with voiceChanger
+     *
+     * @param voiceChanger integer
+     * @voiceChanger value ranges [
+     *          0: "The original voice",
+     *          1: "An old man’s voice",
+     *          2: "A little boy’s voice.",
+     *          3: "A little girl’s voice.",
+     *          4: "TBD",
+     *          5: "Ethereal vocal effects.",
+     *          6: "Hulk’s voice."
+     *      ]
+     * @returns result boolean
+     */
+    static setLocalVoiceChanger(voiceChanger) {
+        return Agora.setLocalVoiceChanger(voiceChanger);
+    }
+    /**
+     * set the preset local voice reverberation effect.
+     *
+     * This method sets the preset local voice reverberation effect.
+     *
+     * @param preset integer
+     * @returns result boolean
+     */
+    static setLocalVoiceReverbPreset(preset) {
+        return Agora.setLocalVoiceReverbPreset(preset);
+    }
+    /**
+     * control stereo panning for remote users
+     *
+     * This method enables/disables stereo panning for remote users.
+     *
+     * @param enabled boolean
+     * @returns result boolean
+     */
+    static enableSoundPositionIndication(enabled) {
+        return Agora.enableSoundPositionIndication(enabled);
+    }
+    /**
+     * set the sound position of a remote user
+     *
+     * This method sets the sound position of a remote user by uid
+     *
+     * @param uid number | The ID of the remote user
+     * @param pan float | The sound position of the remote user. The value ranges from -1.0 to 1.0
+     * @pan
+     *  0.0: the remote sound comes from the front.
+     *  -1.0: the remote sound comes from the left.
+     *  1.0: the remote sound comes from the right.
+     * @param gain float | Gain of the remote user. The value ranges from 0.0 to 100.0. The default value is 100.0 (the original gain of the remote user). The smaller the value, the less the gain.
+     * @returns result boolean
+     */
+    static setRemoteVoicePosition(uid, pan, gain) {
+        return Agora.setRemoteVoicePosition(uid, pan, gain);
+    }
+    /**
+     * start the lastmile probe test
+     *
+     * This method start the last-mile network probe test before joining a channel to get the uplink and downlink last-mile network statistics, including the bandwidth, packet loss, jitter, and round-trip time (RTT).
+     *
+     * @param config LastmileProbeConfig {@link LastmileProbeConfig}
+     *
+     * @event onLastmileQuality: the SDK triggers this callback within two seconds depending on the network conditions. This callback rates the network conditions with a score and is more closely linked to the user experience.
+     * @event onLastmileProbeResult: the SDK triggers this callback within 30 seconds depending on the network conditions. This callback returns the real-time statistics of the network conditions and is more objective.
+     * @returns result boolean
+     */
+    static startLastmileProbeTest(config) {
+        return Agora.startLastmileProbeTest(config);
+    }
+    /**
+     * stop the lastmile probe test
+     *
+     * This method stop the lastmile probe test.
+     *
+     * @returns result boolean
+     */
+    static stopLastmileProbeTest() {
+        return Agora.stopLastmileProbeTest();
+    }
+    /**
+     * sets the priority of a remote user's media stream.
+     *
+     * note: Use this method with the setRemoteSubscribeFallbackOption method. If the fallback function is enabled for a subscribed stream, the SDK ensures the high-priority user gets the best possible stream quality.
+     *
+     * This method sets the priority of a remote user's media stream.
+     * @param uid number
+     * @param userPriority number | The value range is  [50 is "user's priority is hgih", 100 is "the default user's priority is normal"]
+     *
+     * @returns result boolean
+     */
+    static setRemoteUserPriority(uid, userPrority) {
+        return Agora.setRemoteUserPriority(uid, userPrority);
+    }
+    /**
+     * start an audio call test.
+     *
+     * note:
+     *   Call this method before joining a channel.
+     *   After calling this method, call the stopEchoTest method to end the test. Otherwise, the app cannot run the next echo test, or call the joinchannel method.
+     *   In the Live-broadcast profile, only a host can call this method.
+     * This method will start an audio call test with interval parameter.
+     * In the audio call test, you record your voice. If the recording plays back within the set time interval, the audio devices and the network connection are working properly.
+     *
+     * @param interval number
+     *
+     * @returns result boolean
+     */
+    static startEchoTestWithInterval(interval) {
+        return Agora.startEchoTestWithInterval(interval);
+    }
+    /**
+     * set the camera capture preference.
+     *
+     * note:
+     *  For a video call or live broadcast, generally the SDK controls the camera output parameters. When the default camera capture settings do not meet special requirements or cause performance problems, we recommend using this method to set the camera capture preference:
+     *  If the resolution or frame rate of the captured raw video data are higher than those set by setVideoEncoderConfiguration, processing video frames requires extra CPU and RAM usage and degrades performance. We recommend setting config as CAPTURER_OUTPUT_PREFERENCE_PERFORMANCE(1) to avoid such problems.
+     *  If you do not need local video preview or are willing to sacrifice preview quality, we recommend setting config as CAPTURER_OUTPUT_PREFERENCE_PERFORMANCE(1) to optimize CPU and RAM usage.
+     *  If you want better quality for the local video preview, we recommend setting config as CAPTURER_OUTPUT_PREFERENCE_PREVIEW(2).
+     *
+     * This method will set the camera capture preference.
+     *
+     * @param config {@link CameraCapturerConfiguration}
+     *
+     * @returns result boolean
+     */
+    static setCameraCapturerConfiguration(config) {
+        return Agora.setCameraCapturerConfiguration(config);
+    }
 }
 RtcEngine.eventTypes = new Set();
 exports.default = RtcEngine;

react-native-agora.podspec

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

src/RtcEngine.native.ts

     PublishStreamOption,
     RemovePublishStreamOption,
     LiveTranscodingOption,
-    PositionOption
+    PositionOption,
+    BeautyOption,
+    LastmileProbeConfig,
+    CameraCapturerConfiguration
 } from "./types.d";
 
 
      * 
      * This method sets the log file generated path and specified the log level.
      *
-     * @param filepath
-     * @param level
+     * @param filepath string
+     * @param level enum
+     * @param maxfileSize integer (KB)
      * @returns Promise<{success, value}>
      */
-    public static setLog(filepath: string, level: number): Promise<any> {
-        return Agora.setLog(filepath, level)
+    public static setLog(filepath: string, level: number, maxfileSize: number): Promise<any> {
+        return Agora.setLog(filepath, level, maxfileSize)
     }
     
     /**
      * @param data 
      * @returns Promise<{success, value}>
      */
-    public static sendStreamMessage(uid: number, data: any): Promise<any> {
-        return Agora.sendStreamMessage(uid, data);
+    public static sendMessage(streamID: number, data: any, reliable: boolean, ordered: boolean): Promise<any> {
+        return Agora.sendMessage({streamID, data, reliable, ordered});
     }
 
     /**
      public static muteLocalAudioStream(enabled: boolean) {
         Agora.muteLocalAudioStream(enabled);
      }
+
+    /**
+     * video pre-process/post-process
+     * 
+     * This method enables/disables image enhancement and sets the options.
+     * 
+     * @param enable boolean
+     * @param options {@link BeautyOptions}
+     * @returns Promise<{success, value}>
+     */
+    static setBeautyEffectOptions(enabled: boolean, options: BeautyOption): Promise<any> {
+        return Agora.setBeautyEffectOptions(enabled, options);
+    }
+
+    /**
+     * set local voice change
+     * 
+     * This method changes local speaker voice with voiceChanger
+     * 
+     * @param voiceChanger integer
+     * @voiceChanger value ranges [
+     *          0: "The original voice",
+     *          1: "An old man’s voice",
+     *          2: "A little boy’s voice.",
+     *          3: "A little girl’s voice.",
+     *          4: "TBD",
+     *          5: "Ethereal vocal effects.",
+     *          6: "Hulk’s voice."
+     *      ]
+     * @returns Promise<{success, value}>
+     */
+    static setLocalVoiceChanger(voiceChanger: number): Promise<any> {
+        return Agora.setLocalVoiceChanger(voiceChanger);
+    }
+
+    /**
+     * set the preset local voice reverberation effect.
+     * 
+     * This method sets the preset local voice reverberation effect.
+     * 
+     * @param preset integer
+     * @returns Promise<{success, value}>
+     */
+    static setLocalVoiceReverbPreset(preset: number): Promise<any> {
+        return Agora.setLocalVoiceReverbPreset(preset);
+    }
+
+    /**
+     * control stereo panning for remote users
+     * 
+     * This method enables/disables stereo panning for remote users.
+     * 
+     * @param enabled boolean
+     * @returns Promise<{success, value}>
+     */
+    static enableSoundPositionIndication(enabled: boolean): Promise<any> {
+        return Agora.enableSoundPositionIndication(enabled);
+    }
+
+    /**
+     * set the sound position of a remote user
+     * 
+     * This method sets the sound position of a remote user by uid
+     * 
+     * @param uid number | The ID of the remote user
+     * @param pan float | The sound position of the remote user. The value ranges from -1.0 to 1.0
+     * @pan 
+     *  0.0: the remote sound comes from the front.
+     *  -1.0: the remote sound comes from the left.
+     *  1.0: the remote sound comes from the right.
+     * @param gain float | Gain of the remote user. The value ranges from 0.0 to 100.0. The default value is 100.0 (the original gain of the remote user). The smaller the value, the less the gain.
+     * @returns Promise<{success, value}>
+     */
+    static setRemoteVoicePosition(uid: number, pan: number, gain: number): Promise<any> {
+        return Agora.setRemoteVoicePosition(uid, pan, gain)
+    }
+
+    /**
+     * start the lastmile probe test
+     *
+     * This method start the last-mile network probe test before joining a channel to get the uplink and downlink last-mile network statistics, including the bandwidth, packet loss, jitter, and round-trip time (RTT).
+     * 
+     * @param config LastmileProbeConfig {@link LastmileProbeConfig}
+     * 
+     * @event onLastmileQuality: the SDK triggers this callback within two seconds depending on the network conditions. This callback rates the network conditions with a score and is more closely linked to the user experience.
+     * @event onLastmileProbeResult: the SDK triggers this callback within 30 seconds depending on the network conditions. This callback returns the real-time statistics of the network conditions and is more objective.
+     * @returns Promise<{success, value}>
+     */
+    static startLastmileProbeTest(config: LastmileProbeConfig): Promise<any> {
+        return Agora.startLastmileProbeTest(config);
+    }
+
+    /**
+     * stop the lastmile probe test
+     *
+     * This method stop the lastmile probe test.
+     * 
+     * @returns Promise<{success, value}>
+     */
+    static stopLastmileProbeTest(): Promise<any> {
+        return Agora.stopLastmileProbeTest();
+    }
+
+    /**
+     * sets the priority of a remote user's media stream.
+     * 
+     * note: Use this method with the setRemoteSubscribeFallbackOption method. If the fallback function is enabled for a subscribed stream, the SDK ensures the high-priority user gets the best possible stream quality.
+     * 
+     * This method sets the priority of a remote user's media stream.
+     * @param uid number
+     * @param userPriority number | The value range is  [50 is "user's priority is hgih", 100 is "the default user's priority is normal"]
+     * 
+     * @returns Promise<{success, value}>
+     */
+    static setRemoteUserPriority(uid: number, userPrority: number): Promise<any> {
+        return Agora.setRemoteUserPriority(uid, userPrority);
+    }
+
+    /**
+     * start an audio call test.
+     * 
+     * note:
+     *   Call this method before joining a channel.
+     *   After calling this method, call the stopEchoTest method to end the test. Otherwise, the app cannot run the next echo test, or call the joinchannel method.
+     *   In the Live-broadcast profile, only a host can call this method.
+     * This method will start an audio call test with interval parameter.
+     * In the audio call test, you record your voice. If the recording plays back within the set time interval, the audio devices and the network connection are working properly.
+     * 
+     * @param interval number
+     * 
+     * @returns Promise<{success, value}>
+     */
+    static startEchoTestWithInterval(interval: number): Promise<any> {
+        return Agora.startEchoTestWithInterval(interval)
+    }
+
+    /**
+     * set the camera capture preference.
+     *
+     * note:
+     *  For a video call or live broadcast, generally the SDK controls the camera output parameters. When the default camera capture settings do not meet special requirements or cause performance problems, we recommend using this method to set the camera capture preference:
+     *  If the resolution or frame rate of the captured raw video data are higher than those set by setVideoEncoderConfiguration, processing video frames requires extra CPU and RAM usage and degrades performance. We recommend setting config as CAPTURER_OUTPUT_PREFERENCE_PERFORMANCE(1) to avoid such problems.
+     *  If you do not need local video preview or are willing to sacrifice preview quality, we recommend setting config as CAPTURER_OUTPUT_PREFERENCE_PERFORMANCE(1) to optimize CPU and RAM usage.
+     *  If you want better quality for the local video preview, we recommend setting config as CAPTURER_OUTPUT_PREFERENCE_PREVIEW(2).
+     * 
+     * This method will set the camera capture preference.
+     * 
+     * @param config {@link CameraCapturerConfiguration}
+     * 
+     * @returns Promise<{success, value}>
+     */
+    static setCameraCapturerConfiguration(config: CameraCapturerConfiguration): Promise<any> {
+        return Agora.setCameraCapturerConfiguration(config);
+    }
+
+    /**
+     * set the log file size (KB).
+     * TODO: setLogFileSize
+     * This method will set the log file size
+     */
+
+
+    
+
 }
 
 

src/types.d.ts

 
 declare module "IAgora"
 
+/**
+ * VideoEncoderConfig details
+ * @property width: number | The encoder video's width
+ * @property height: number | The encoder video's height
+ * @property bitrate: number | The encoder video's bitrate
+ * @property frameRate: number | The frameRate of encoder video
+ * @property orientationMode: number | The video orientation mode of the video
+ * @orientationMode value range is [0 is "mode adapative", 1 is "mode fixed landscape", 2 is "mode fixed portrait"]
+ */
 export interface VideoEncoderConfig {
   width: number,
   height: number,
   mode: number,
   clientRole: number,
   audioProfile: number,
-  audioScenario: number
+  audioScenario: number,
+  beauty?: BeautyOption,
+  voice?: VoiceDecorator,
+}
+
+/**
+ * VoiceDecorator is decorate local audio voice
+ * 
+ * @property type: string | the range values ['changer' | 'reverbPreset'] This property is the identifier for audio voice decorator 
+ * @property value: number | the value for voice parameter option.
+ * type 'reverbPreset' range values: [0 is "off", 1 is "popular", 2 is "rnb", 3 is "rock", 4 is "hiphop", 5 is "vocal concert", 6 is "KTV", 7 is "studio"]
+ * type 'changer' range values: [0 is "off", 1 is "old man", 2 is "baby boy", 3 is "baby girl", 4 is "zhubajie", 5 is "ethereal", 6 is "hulk"]
+ */
+export interface VoiceDecorator {
+  type: string,
+  value: number
 }
 
 export interface PublisherConfig {
 export interface PositionOption {
   x: number,
   y: number
+}
+
+/**
+ * BeautyOption is setBeautyEffectOptions's option parameter
+ * @property lighteningContrastLevel: integer | lightening contrast level and the value ranges is low: 0, normal: 1, high: 2
+ * @property lighteningLevel: float | brightness level and the value ranges between 0.0 (original) and 1.0.
+ * @property smoothnessLevel: float | The sharpness level. The value ranges between 0.0 (original) and 1.0. This parameter is usually used to remove blemishes.
+ * @property rednessLevel: float | The redness level. The value ranges between 0.0 (original) and 1.0. This parameter adjusts the red saturation level.
+ */
+export interface BeautyOption {
+  lighteningContrastLevel: number,
+  lighteningLevel: number,
+  smoothnessLevel: number,
+  rednessLevel: number,
+}
+
+/**
+ * LastmileProbeConfig is startLastmileProbeTest's config parameter
+ * @property probeUplink: boolean | sets whether or not to test the uplink networks. some users, for example, the audience in a Live-broadcast channel, do not need such a test. true: enables the probe test. false: disables the probe test.
+ * @property probeDownlink: boolean | sets whether or not to probe the downlink network. true: enables the probe test. false: disables the probe test.
+ * @property expectedUplinkBitrate: integer | The expected maximum sending bitrate (Kbps) of the local user. The value ranges between 100 and 5000. We recommend setting this parameter according to the bitrate value set by setVideoEncoderConfiguration.
+ * @property expectedDownlinkBitrate: integer | The expected maximum receiving bitrate (Kbps) of the local user. The value ranges between 100 and 5000.
+ */
+export interface LastmileProbeConfig {
+  probeUplink: boolean,
+  probeDownlink: boolean,
+  expectedUplinkBitrate: number,
+  expectedDownlinkBitrate: number
+}
+
+
+/**
+ * CameraCapturerConfiguration is setCameraCapturerConfiguration's config parameter
+ * @property preference: number | The Camera capture preference and the value range is [0 is "(default) self-adapts the camera output parameters to the system performance and network conditions to balance CPU consumption and video preview quality.", 1 is "prioritizes the system performance. The SDK chooses the dimension and frame rate of the local camera capture closest to those set by setVideoEncoderConfiguration.", 2 is "prioritizes the local preview quality. The SDK chooses higher camera output parameters to improve the local video preview quality. This option requires extra CPU and RAM usage for video pre-processing."]
+ */
+export interface CameraCapturerConfiguration {
+  preference: number
 }