Merge pull request #102 from syanbo/feat/upgrade-2.9.1

feat. support ios & android 2.9.1

CHANGELOG

 ## THE CHANGELOG
 
+#### 2.9.1-alpha.1
+  - support 2.9.1 native sdk
+
 #### 2.9.0-alpha.3
   - hotfix ios compile error
 

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

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

 import io.agora.rtc.IMetadataObserver;
 import io.agora.rtc.IRtcEngineEventHandler;
 import io.agora.rtc.RtcEngine;
+import io.agora.rtc.RtcEngineEx;
 import io.agora.rtc.video.BeautyOptions;
 import io.agora.rtc.video.VideoCanvas;
 import io.agora.rtc.video.VideoEncoderConfiguration;
 
     public static AgoraManager sAgoraManager;
 
-    public RtcEngine mRtcEngine;
+    public RtcEngineEx mRtcEngine;
 
     private Context context;
 
         //create rtcEngine instance and setup rtcEngine eventHandler
         try {
             this.context = context;
-            this.mRtcEngine = RtcEngine.create(context, options.getString("appid"), mRtcEventHandler);
+            this.mRtcEngine = (RtcEngineEx) RtcEngineEx.create(context, options.getString("appid"), mRtcEventHandler);
+            this.mRtcEngine.setAppType(8);
             if (options.hasKey("secret") && null != options.getString("secret")) {
                 mRtcEngine.setEncryptionSecret(options.getString("secret"));
                 if (options.hasKey("secretMode") && null != options.getString("secretMode")) {

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

 import io.agora.rtc.IMetadataObserver;
 import io.agora.rtc.IRtcEngineEventHandler;
 import io.agora.rtc.RtcEngine;
+import io.agora.rtc.RtcEngineEx;
 import io.agora.rtc.internal.LastmileProbeConfig;
 import io.agora.rtc.live.LiveInjectStreamConfig;
 import io.agora.rtc.live.LiveTranscoding;
 import io.agora.rtc.video.ChannelMediaInfo;
 import io.agora.rtc.video.ChannelMediaRelayConfiguration;
 import io.agora.rtc.video.VideoEncoderConfiguration;
+import io.agora.rtc.video.WatermarkOptions;
 
 import static com.facebook.react.bridge.UiThreadUtil.runOnUiThread;
 import static com.syan.agora.AgoraConst.*;
                         WritableMap obj = Arguments.createMap();
                         obj.putInt("uid", speakers[i].uid);
                         obj.putInt("volume", speakers[i].volume);
+                        obj.putInt("vad", speakers[i].vad);
                         arr.pushMap(obj);
                     }
 
         }
     };
 
+    public void setAppType(RtcEngineEx engineEx) {
+        engineEx.setAppType(8);
+    }
+
     @ReactMethod
     public void init(ReadableMap options) {
         AgoraManager.getInstance().init(getReactApplicationContext(), mRtcEventHandler, options);
         appId = options.getString("appid");
         rtcEngine = AgoraManager.getInstance().mRtcEngine;
+        setAppType((RtcEngineEx) rtcEngine);
     }
 
     @ReactMethod
     }
 
     @ReactMethod
-    public void enableAudioVolumeIndication(int interval, int smooth, Promise promise) {
-        Integer res = AgoraManager.getInstance().mRtcEngine.enableAudioVolumeIndication(interval, smooth);
+    public void enableAudioVolumeIndication(int interval, int smooth, boolean vad, Promise promise) {
+        Integer res = AgoraManager.getInstance().mRtcEngine.enableAudioVolumeIndication(interval, smooth, vad);
         if (res == 0) {
             promise.resolve(null);
         } else {
         Integer res = AgoraManager.getInstance().mRtcEngine
                 .startAudioRecording(
                         options.getString("filepath"),
+                        options.getInt("sampleRate"),
                         options.getInt("quality")
                 );
         if (res == 0) {
 
     @ReactMethod
     public void addVideoWatermark(ReadableMap options, Promise promise) {
+        String url = options.getString("url");
+        ReadableMap watermarkOptions = options.getMap("options");
+        ReadableMap positionLandscapeOptions = watermarkOptions.getMap("positionInPortraitMode");
+        WatermarkOptions watermarkOpts = new WatermarkOptions();
+        WatermarkOptions.Rectangle landscapePosition = new WatermarkOptions.Rectangle();
+        landscapePosition.height = positionLandscapeOptions.getInt("height");
+        landscapePosition.width = positionLandscapeOptions.getInt("width");
+        landscapePosition.x = positionLandscapeOptions.getInt("x");
+        landscapePosition.y = positionLandscapeOptions.getInt("y");
+
+        ReadableMap positionPortraitOptions = watermarkOptions.getMap("positionInPortraitMode");
+        WatermarkOptions.Rectangle portraitPosition = new WatermarkOptions.Rectangle();
+        portraitPosition.height = positionPortraitOptions.getInt("height");
+        portraitPosition.width = positionPortraitOptions.getInt("width");
+        portraitPosition.x = positionPortraitOptions.getInt("x");
+        portraitPosition.y = positionPortraitOptions.getInt("y");
+
+        watermarkOpts.positionInLandscapeMode = landscapePosition;
+        watermarkOpts.visibleInPreview = watermarkOptions.getBoolean("visibleInPreview");
+        watermarkOpts.positionInPortraitMode = portraitPosition;
         Integer res = AgoraManager.getInstance().mRtcEngine
-                .addVideoWatermark(createAgoraImage(options));
+                .addVideoWatermark(url, watermarkOpts);
         if (res == 0) {
             promise.resolve(null);
         } else {
                 break;
             }
         }
-        CameraCapturerConfiguration config = new CameraCapturerConfiguration(preference);
+        CameraCapturerConfiguration.CAMERA_DIRECTION cameraDirection = CameraCapturerConfiguration.CAMERA_DIRECTION.CAMERA_REAR;
+        switch (options.getInt("cameraDirection")) {
+            case 0: {
+                cameraDirection = CameraCapturerConfiguration.CAMERA_DIRECTION.CAMERA_REAR;
+                break;
+            }
+            case 1: {
+                cameraDirection = CameraCapturerConfiguration.CAMERA_DIRECTION.CAMERA_FRONT;
+                break;
+            }
+        }
+        CameraCapturerConfiguration config = new CameraCapturerConfiguration(preference, cameraDirection);
         Integer res = AgoraManager.getInstance().mRtcEngine.setCameraCapturerConfiguration(config);
         if (res == 0) {
             promise.resolve(null);
         }
     }
 
+    @ReactMethod
+    public void setParameters(String paramStr, Promise promise) {
+        Integer res = AgoraManager.getInstance().mRtcEngine.setParameters(paramStr);
+        if (res == 0) {
+            promise.resolve(null);
+        } else {
+            promise.reject("-1", res.toString());
+        }
+    }
 
     @ReactMethod
+    public void getParameter(String paramStr, String args, Promise promise) {
+        String res = AgoraManager.getInstance().mRtcEngine.getParameter(paramStr, args);
+        promise.resolve(res);
+    }
+
+    @ReactMethod
+    public void getParameters(String str, Promise promise) {
+        String res = AgoraManager.getInstance().mRtcEngine.getParameters(str);
+        promise.resolve(res);
+    }
 
     private void sendEvent(ReactContext reactContext,
                            String eventName,

ios/RCTAgora/AgoraConst.h

 
 #import <AgoraRtcEngineKit/AgoraRtcEngineKit.h>
 
+typedef NS_ENUM(NSUInteger, AgoraRtcQualityReportFormat) {
+    AgoraRtc_QualityReportFormat_Json = 0,
+    AgoraRtc_QualityReportFormat_Html = 1,
+};
+
+typedef NS_ENUM(NSUInteger, AgoraRtcAppType) {
+    AgoraRtc_APP_TYPE_NATIVE = 0,
+    AgoraRtc_APP_TYPE_COCOS = 1,
+    AgoraRtc_APP_TYPE_UNITY = 2,
+    AgoraRtc_APP_TYPE_ELECTRON = 3,
+    AgoraRtc_APP_TYPE_FLUTTER = 4,
+    AgoraRtc_APP_TYPE_UNREAL = 5,
+    AgoraRtc_APP_TYPE_XAMARIN = 6,
+    AgoraRtc_APP_TYPE_APICLOUD = 7,
+    AgoraRtc_APP_TYPE_REACTNATIVE = 8
+};
+
+
+@protocol AgoraRtcEngineExtensionDelegate <AgoraRtcEngineDelegate>
+@optional
+- (void)rtcEngine:(AgoraRtcEngineKit * _Nonnull)engine audioTransportQualityOfUid:(NSUInteger)uid delay:(NSUInteger)delay lost:(NSUInteger)lost;
+- (void)rtcEngine:(AgoraRtcEngineKit * _Nonnull)engine videoTransportQualityOfUid:(NSUInteger)uid delay:(NSUInteger)delay lost:(NSUInteger)lost;
+@end
+
+
+@interface AgoraRtcEngineKit (AgoraExtension)
+
++ (instancetype _Nonnull)sharedEngineWithAppId:(NSString * _Nonnull)appId
+                             extensionDelegate:(id<AgoraRtcEngineExtensionDelegate> _Nullable)delegate;
+
+/** Sets the profile to control the RTC engine.
+ *
+ *  @param profile SDK profile in JSON format.
+ *  @param merge Whether to merge the profile data with the original value.
+ */
+- (int)setProfile:(NSString * _Nonnull)profile
+            merge:(BOOL)merge;
+
+/** Set wrapper frame type by language wrapper.
+ *
+ *  @param appType wrapper frame type.
+ */
+- (int)setAppType:(AgoraRtcAppType)appType;
+
+/** END OF COMMON METHODS */
+
+/** BEGIN OF AUDIO METHODS */
+
+
+/**
+ *  Enable recap
+ *
+ *  @param interval &le; 0: Disabled, > 0: Interval in ms.
+ */
+- (int)enableRecap:(NSInteger)interval;
+
+/**
+ *  Start playing recap conversation
+ *
+ */
+- (int)playRecap;
+
+- (int)enableAudioQualityIndication:(BOOL)enabled;
+- (int)enableTransportQualityIndication:(BOOL)enabled;
+
+- (int)setVideoProfileEx:(NSInteger)width
+               andHeight:(NSInteger)height
+            andFrameRate:(NSInteger)frameRate
+              andBitrate:(NSInteger)andBitrate;
+
+- (int)sendReportData:(NSData * _Nonnull)data
+                 type:(NSInteger)type;
+/** END OF AUDIO METHODS */
+
+/** Queries internal states
+ * @param parameters
+ *     json string, array type
+ * @return a json string
+ */
+- (NSString * _Nullable)getParameters:(NSString * _Nonnull)parameters;
+
+/**
+ *  Generates a URL linking to the call quality reports. @param channel      The channel name specified in the joinChannel method.
+ *  @param listenerUid  The uid of the listener.
+ *  @param speakerUid   The uid of the speaker.
+ *  @param reportFormat The format of the report.
+                        AgoraRtc_QualityReportFormat_Json (0): JSON.: Returns the quality report data in Json.
+                        AgoraRtc_QualityReportFormat_Html (1): HTML.: Returns a report in HTML format, displayed on a web browser or WebVIEW components.
+ *
+ *  @return 0 when executed successfully. return minus value when failed. return AgoraRtc_Error_Invalid_Argument (-2)：Invalid argument. return AgoraRtc_Error_Buffer_Too_Small (-6)：The buffer length is too small.
+ */
+- (NSString * _Nullable)makeQualityReportUrl:(NSString * _Nonnull) channel
+                                 listenerUid:(NSUInteger)listenerUid
+                                 speakerrUid:(NSUInteger)speakerUid
+                                reportFormat:(AgoraRtcQualityReportFormat)reportFormat;
+
+/*********************************************************
+ * Large group conference call (experiment) - END
+ *********************************************************/
+@end
+
 static NSString *AG_PREFIX = @"ag_rtc";
 
 static NSString *RCTAgoraErrorDomain = @"RCTAgoraErrorDomain";

ios/RCTAgora/RCTAgora.m

 #import <React/RCTBridge.h>
 #import <React/RCTUIManager.h>
 #import <React/RCTView.h>
+#import <AgoraRtcEngineKit/AgoraRtcEngineKit.h>
 #import "AgoraConst.h"
 
 #define MAX_DATA_LENGTH 1024
   
   [AgoraConst share].rtcEngine = self.rtcEngine;
   
+  [self.rtcEngine setAppType:AgoraRtc_APP_TYPE_REACTNATIVE];
   //channel mode
   [self.rtcEngine setChannelProfile:[options[@"channelProfile"] integerValue]];
   //enable dual stream
 }
 
 // enable audio volume indication
-RCT_EXPORT_METHOD(enableAudioVolumeIndication: (NSInteger) interval smooth:(NSInteger)smooth
+RCT_EXPORT_METHOD(enableAudioVolumeIndication: (NSInteger) interval smooth:(NSInteger)smooth 
+                  report_vad:(BOOL)report_vad
                   resolve:(RCTPromiseResolveBlock)resolve
                   reject:(RCTPromiseRejectBlock)reject) {
-  NSInteger res = [self.rtcEngine enableAudioVolumeIndication:interval smooth:smooth];
+  NSInteger res = [self.rtcEngine enableAudioVolumeIndication:interval smooth:smooth report_vad:report_vad];
   if (res == 0) {
     resolve(nil);
   } else {
 RCT_EXPORT_METHOD(addVideoWatermark:(NSDictionary *)options
                   resolve:(RCTPromiseResolveBlock)resolve
                   reject:(RCTPromiseRejectBlock)reject) {
-  NSInteger res = [self.rtcEngine addVideoWatermark:[self makeAgoraImage:@{
-                                                                           @"url": options[@"url"],
-                                                                           @"x": options[@"x"],
-                                                                           @"y": options[@"y"],
-                                                                           @"width": options[@"width"],
-                                                                           @"height": options[@"height"]
-                                                                           }]];
+    NSString *urlStr = options[@"url"];
+    NSDictionary *watermarkOptions = options[@"options"];
+    WatermarkOptions *watermarkOpts = [WatermarkOptions new];
+    watermarkOpts.visibleInPreview = [watermarkOptions[@"visibleInPreview"] boolValue];
+    NSDictionary *optionPortrait = watermarkOptions[@"positionInPortraitMode"];
+    watermarkOpts.positionInPortraitMode = CGRectMake((CGFloat)[optionPortrait[@"x"] floatValue],
+                               (CGFloat)[optionPortrait[@"y"] floatValue],
+                               (CGFloat)[optionPortrait[@"width"] floatValue],
+                               (CGFloat)[optionPortrait[@"height"] floatValue]);
+    NSDictionary *optionLandscape = watermarkOptions[@"positionInLandscapeMode"];
+    watermarkOpts.positionInLandscapeMode = CGRectMake((CGFloat)[optionLandscape[@"x"] floatValue],
+                               (CGFloat)[optionLandscape[@"y"] floatValue],
+                               (CGFloat)[optionLandscape[@"width"] floatValue],
+                               (CGFloat)[optionLandscape[@"height"] floatValue]);
+    NSURL *url = [NSURL URLWithString:urlStr];
+    NSInteger res = [self.rtcEngine addVideoWatermark:url options:watermarkOpts];
   if (res == 0) {
     resolve(nil);
   } else {
   
   AgoraCameraCapturerConfiguration* configuration = [[AgoraCameraCapturerConfiguration alloc] init];
   configuration.preference = [config[@"preference"] integerValue];
+  configuration.cameraDirection = [config[@"cameraDirection"] integerValue];
   
   NSInteger res = [self.rtcEngine setCameraCapturerConfiguration:configuration];
   if (res == 0) {
   }
 }
 
+RCT_EXPORT_METHOD(setParameters:(NSString *)paramStr
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject) {
+  NSInteger res = [self.rtcEngine setParameters:paramStr];
+  if (res == 0) {
+    resolve(nil);
+  } else {
+    reject(@(-1).stringValue, @(-1).stringValue, nil);
+  }
+}
+
+RCT_EXPORT_METHOD(getParameter:(NSString *)paramStr
+                  args:(NSString *)args
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject) {
+  NSString *res = [self.rtcEngine getParameter:paramStr args:args];
+  resolve(res);
+}
+
+RCT_EXPORT_METHOD(getParameters:(NSString *)paramStr
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject) {
+  NSString *res = [self.rtcEngine getParameters:paramStr];
+  resolve(res);
+}
+
 - (NSArray<NSString *> *)supportedEvents {
   return [AgoraConst supportEvents];
 }
   for (AgoraRtcAudioVolumeInfo *speaker in speakers) {
     [result addObject:@{
                         @"uid": @(speaker.uid),
-                        @"volume": @(speaker.volume)
+                        @"volume": @(speaker.volume),
+                        @"vad": @(speaker.vad),
                         }];
   }
   [self sendEvent:AGAudioVolumeIndication params:@{

ios/RCTAgora/libs/AgoraRtcCryptoLoader.framework/Headers/AgoraRtcCryptoLoader.h

-//
-//  AgoraRtcCryptoLoader.h
-//  AgoraRtcCryptoLoader
-//
-//  Copyright © 2018 Agora. All rights reserved.
-//
-
-#import <Foundation/Foundation.h>
-
-@interface AgoraRtcCryptoLoader : NSObject
-
-@end

lib/RtcEngine.native.d.ts

      * This method creates and start event observer. You should call this method once.
      * @example `RtcEngine.init(option)`
      * @param options Defines the property of the client, see {@link Option} for details.
+     * @returns any
      */
     static init(options: Option): void;
     /**
      * @param uid
      * @param token
      * @param info
+     * @returns Promise<any>
      */
     static joinChannel(channelName: string, uid?: number, token?: string, info?: Object): Promise<any>;
     /**
      * Occurs joinChannelSuccess when achieve joining stage
      * @param channelName {@link string}
      * @param token {@link string}
+     * @returns Promise<any>
      */
     static switchChannel(channelName: string, token?: string): Promise<any>;
     /**
      *  Occurs mediaRelayStateChanged
      *  Occurs receivedChannelMediaRelay when peer channel received this message
      * @param config {@link ChannelMediaConfiguration}
+     * @returns Promise<any>
      */
     static startChannelMediaRelay(config: ChannelMediaConfiguration): Promise<any>;
     /**
      * It will occurs event:
      *  Occurs mediaRelayStateChanged
      * @param config {@link ChannelMediaConfiguration}
+     * @returns Promise<any>
      */
     static removeChannelMediaRelay(config: ChannelMediaConfiguration): Promise<any>;
     /**
      * It will occurs event:
      *  Occurs mediaRelayStateChanged
      * @param config {@link ChannelMediaConfiguration}
+     * @returns Promise<any>
      */
     static updateChannelMediaRelay(config: ChannelMediaConfiguration): Promise<any>;
     /**
      * It will occurs event:
      *  Occurs mediaRelayStateChanged
      * @param config {@link ChannelMediaConfiguration}
+     * @returns Promise<any>
      */
     static stopChannelMediaRelay(): Promise<any>;
     /**
      * @param smooth
      * @return Promise<any>
      */
-    static enableAudioVolumeIndication(interval: number, smooth: number): Promise<any>;
+    static enableAudioVolumeIndication(interval: number, smooth: number, vad: boolean): Promise<any>;
     /**
      * check for mobile phone speaker enabled
      *
      * @param options {@link ImageOption}
      * @return Promise<{success, value}>
      */
-    static addVideoWatermark(options: ImageOption): Promise<any>;
+    static addVideoWatermark(url: string, options: ImageOption): Promise<any>;
     /**
      * clear video watermarks
      *
      *         console.log("your currrent camera", info);
      *      })
      * ```
-     * @return Promise{cameraSupportInfo}>
+     * @return Promise<{cameraSupportInfo}>
      */
     static getCameraInfo(): Promise<any>;
+    /**
+     * Set Private Parameters
+     * @param paramsStr
+     * @return Promise<bool>
+     */
+    static setParameters(paramsStr: string): Promise<any>;
+    /**
+     * Get Private Parameter
+     * @param paramsStr
+     * @param args
+     * @return Promise<string>
+     */
+    static getParameter(paramsStr: string, args: string): Promise<string>;
+    /**
+     * Get Private Parameters
+     * @param paramsStr
+     * @param args
+     * @return Promise<string>
+     */
+    static getParameters(paramsStr: string): Promise<string>;
 }
 export default RtcEngine;

lib/RtcEngine.native.js

      * This method creates and start event observer. You should call this method once.
      * @example `RtcEngine.init(option)`
      * @param options Defines the property of the client, see {@link Option} for details.
+     * @returns any
      */
     static init(options) {
         Agora.init(options);
      * @param uid
      * @param token
      * @param info
+     * @returns Promise<any>
      */
     static joinChannel(channelName, uid, token, info) {
         return Agora.joinChannel({ channelName, uid, token, info });
      * Occurs joinChannelSuccess when achieve joining stage
      * @param channelName {@link string}
      * @param token {@link string}
+     * @returns Promise<any>
      */
     static switchChannel(channelName, token) {
         return Agora.switchChannel({ channelName, token });
      *  Occurs mediaRelayStateChanged
      *  Occurs receivedChannelMediaRelay when peer channel received this message
      * @param config {@link ChannelMediaConfiguration}
+     * @returns Promise<any>
      */
     static startChannelMediaRelay(config) {
         return Agora.startChannelMediaRelay(config);
      * It will occurs event:
      *  Occurs mediaRelayStateChanged
      * @param config {@link ChannelMediaConfiguration}
+     * @returns Promise<any>
      */
     static removeChannelMediaRelay(config) {
         return Agora.removeChannelMediaRelay(config);
      * It will occurs event:
      *  Occurs mediaRelayStateChanged
      * @param config {@link ChannelMediaConfiguration}
+     * @returns Promise<any>
      */
     static updateChannelMediaRelay(config) {
         return Agora.updateChannelMediaRelay(config);
      * It will occurs event:
      *  Occurs mediaRelayStateChanged
      * @param config {@link ChannelMediaConfiguration}
+     * @returns Promise<any>
      */
     static stopChannelMediaRelay() {
         return Agora.stopChannelMediaRelay();
      * @param smooth
      * @return Promise<any>
      */
-    static enableAudioVolumeIndication(interval, smooth) {
-        return Agora.enableAudioVolumeIndication(interval, smooth);
+    static enableAudioVolumeIndication(interval, smooth, vad) {
+        return Agora.enableAudioVolumeIndication(interval, smooth, vad);
     }
     /**
      * check for mobile phone speaker enabled
      * @param options {@link ImageOption}
      * @return Promise<{success, value}>
      */
-    static addVideoWatermark(options) {
-        return Agora.addVideoWatermark(options);
+    static addVideoWatermark(url, options) {
+        return Agora.addVideoWatermark({ url, options });
     }
     /**
      * clear video watermarks
      *         console.log("your currrent camera", info);
      *      })
      * ```
-     * @return Promise{cameraSupportInfo}>
+     * @return Promise<{cameraSupportInfo}>
      */
     static getCameraInfo() {
         return tslib_1.__awaiter(this, void 0, void 0, function* () {
             return Agora.getCameraInfo();
         });
     }
+    /**
+     * Set Private Parameters
+     * @param paramsStr
+     * @return Promise<bool>
+     */
+    static setParameters(paramsStr) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return Agora.setParameters(paramsStr);
+        });
+    }
+    /**
+     * Get Private Parameter
+     * @param paramsStr
+     * @param args
+     * @return Promise<string>
+     */
+    static getParameter(paramsStr, args) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return Agora.getParameter(paramsStr, args);
+        });
+    }
+    /**
+     * Get Private Parameters
+     * @param paramsStr
+     * @param args
+     * @return Promise<string>
+     */
+    static getParameters(paramsStr) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return Agora.getParameters(paramsStr);
+        });
+    }
 }
 /**
  * @ignore eventTypes

lib/types.d.ts

 }
 export interface AudioRecordingOption {
     filepath: String;
+    sampleRate: number;
     quality: number;
 }
 export declare type Callback<T> = (err: any, data: any) => T;
     samplesPerCall: number;
 }
 export interface ImageOption {
-    url: String;
-    height: number;
-    width: number;
-    x: number;
-    y: number;
+    visibleInPreview: boolean;
+    positionInPortraitMode: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    positionInLandscapeMode: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
 }
 export interface VideoStreamOption {
     uid: number;
  */
 export interface CameraCapturerConfiguration {
     preference: number;
+    cameraDirection: number;
 }

package.json

 {
   "name": "react-native-agora",
-  "version": "2.9.0-alpha.3",
+  "version": "2.9.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

     s.homepage       = package['homepage']
     s.license        = package['license']
     s.authors        = package["authors"]
-    s.platform       = :ios, "7.0"
+    s.platform       = :ios, "8.0"
 
     s.source         = { :git => package["repository"]["url"] }
     s.source_files   = 'ios/RCTAgora/*.{h,m}'
 
-    s.subspec 'AgoraRtcCryptoLoader' do |sp|
-        sp.source_files = './ios/RCTAgora/libs/AgoraRtcCryptoLoader.framework/**/*.{c,h,m,mm,S,cpp}'
-        sp.vendored_libraries = 'libcrypto.a'
-    end
-
     s.dependency 'React'
-    s.dependency "AgoraRtcEngine_iOS", "2.9"
+    s.dependency "AgoraRtcEngine_iOS", "2.9.1"
 end

src/RtcEngine.native.ts

      * @param smooth
      * @return Promise<any>
      */
-    public static enableAudioVolumeIndication(interval: number, smooth: number): Promise<any> {
-        return Agora.enableAudioVolumeIndication(interval, smooth);
+    public static enableAudioVolumeIndication(interval: number, smooth: number, vad: boolean): Promise<any> {
+        return Agora.enableAudioVolumeIndication(interval, smooth, vad);
     }
 
     /**
      * @param options {@link ImageOption}
      * @return Promise<{success, value}>
      */
-    public static addVideoWatermark(options: ImageOption): Promise<any> {
-        return Agora.addVideoWatermark(options);
+    public static addVideoWatermark(url: string, options: ImageOption): Promise<any> {
+        return Agora.addVideoWatermark({url, options});
     }
 
     /**
      *         console.log("your currrent camera", info);
      *      })
      * ```
-     * @return Promise{cameraSupportInfo}>
+     * @return Promise<{cameraSupportInfo}>
      */
     static async getCameraInfo(): Promise<any> {
         return Agora.getCameraInfo();
     }
+
+    /**
+     * Set Private Parameters
+     * @param paramsStr 
+     * @return Promise<bool>
+     */
+    static async setParameters(paramsStr: string): Promise<any> {
+        return Agora.setParameters(paramsStr);
+    }
+
+    /**
+     * Get Private Parameter
+     * @param paramsStr 
+     * @param args 
+     * @return Promise<string>
+     */
+    static async getParameter(paramsStr: string, args: string): Promise<string> {
+        return Agora.getParameter(paramsStr, args);
+    }
+
+    /**
+     * Get Private Parameters
+     * @param paramsStr 
+     * @param args 
+     * @return Promise<string>
+     */
+    static async getParameters(paramsStr: string): Promise<string> {
+        return Agora.getParameters(paramsStr);
+    }
 }
 
 export default RtcEngine;

src/types.ts

 
 export interface AudioRecordingOption {
   filepath: String,
+  sampleRate: number,
   quality: number
 }
 
 }
 
 export interface ImageOption {
-  url: String,
-  height: number,
-  width: number,
-  x: number,
-  y: number
+  visibleInPreview: boolean
+  positionInPortraitMode: {
+    x: number,
+    y: number,
+    width: number,
+    height: number,
+  }
+  positionInLandscapeMode: {
+    x: number,
+    y: number,
+    width: number,
+    height: number,
+  }
 }
 
 export interface VideoStreamOption {
  */
 export interface CameraCapturerConfiguration {
   preference: number
+  cameraDirection: number
 }