feat. support 2.4.0 android

android/build.gradle

 
             reset()
 
-            include "armeabi-v7a", "arm64-v8a", "x86", "x86_64"
+            include "armeabi-v7a", "arm64-v8a", "x86"
             // Specify that we do not want an additional universal SDK
             universalApk false
         }

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

 
 import io.agora.rtc.IRtcEngineEventHandler;
 import io.agora.rtc.RtcEngine;
+import io.agora.rtc.video.BeautyOptions;
 import io.agora.rtc.video.VideoCanvas;
 import io.agora.rtc.video.VideoEncoderConfiguration;
 
                 mRtcEngine.enableAudio();
             }
 
+            if (options.hasKey("beauty") && null != options.getMap("beauty")) {
+                ReadableMap beauty = options.getMap("beauty");
+                BeautyOptions beautyOption = new BeautyOptions();
+                beautyOption.lighteningContrastLevel = beauty.getInt("lighteningContrastLevel");
+                beautyOption.lighteningLevel = (float) beauty.getDouble("lighteningLevel");
+                beautyOption.smoothnessLevel = (float) beauty.getDouble("smoothnessLevel");
+                beautyOption.rednessLevel = (float) beauty.getDouble("rednessLevel");
+                mRtcEngine.setBeautyEffectOptions(true, beautyOption);
+            }
+
+            if (options.hasKey("voice") && null != options.getMap("voice")) {
+                ReadableMap voice = options.getMap("voice");
+                final String voiceType = voice.getString("type");
+                final Integer voiceValue = voice.getInt("value");
+                if (voiceType.equals("changer")) {
+                    mRtcEngine.setLocalVoiceChanger(voiceValue);
+                }
+                if (voiceType.equals("reverbPreset")) {
+                    mRtcEngine.setLocalVoiceReverbPreset(voiceValue);
+                }
+            }
+
             if (options.hasKey("videoEncoderConfig") && null != options.getMap("videoEncoderConfig")) {
                 ReadableMap config = options.getMap("videoEncoderConfig");
                 VideoEncoderConfiguration encoderConfig = new VideoEncoderConfiguration(

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

 import io.agora.rtc.IAudioEffectManager;
 import io.agora.rtc.IRtcEngineEventHandler;
 import io.agora.rtc.RtcEngine;
+import io.agora.rtc.internal.LastmileProbeConfig;
 import io.agora.rtc.live.LiveInjectStreamConfig;
 import io.agora.rtc.live.LiveTranscoding;
 import io.agora.rtc.video.AgoraImage;
+import io.agora.rtc.video.BeautyOptions;
+import io.agora.rtc.video.CameraCapturerConfiguration;
 import io.agora.rtc.video.VideoEncoderConfiguration;
 
 import static com.facebook.react.bridge.UiThreadUtil.runOnUiThread;
     }
 
     @ReactMethod
-    public void setLog(String filePath, int level, Promise promise) {
+    public void setLog(String filePath, int level, int size, Promise promise) {
         try {
             int res = 0;
+            res = AgoraManager.getInstance().mRtcEngine.setLogFileSize(size);
+            if (res != 0) throw new ReactNativeAgoraException("setLogFileSize Failed", res);
             res = AgoraManager.getInstance().mRtcEngine.setLogFilter(level);
             if (res != 0) throw new ReactNativeAgoraException("setLogFilter Failed", res);
             res = AgoraManager.getInstance().mRtcEngine.setLogFile(filePath);
         }
     }
 
-    @ReactMethod
-    public void startEchoTest(Promise promise) {
-        try {
-            int res = AgoraManager.getInstance().mRtcEngine
-                    .startEchoTest();
-            if (res != 0) throw new ReactNativeAgoraException("startEchoTest Failed", res);
-            WritableMap map = Arguments.createMap();
-            map.putBoolean("success", true);
-            map.putInt("value", res);
-            promise.resolve(map);
-        } catch (Exception e) {
-            promise.reject("131009", e);
-        }
-    }
+//  deprecated
+//    @ReactMethod
+//    public void startEchoTest(Promise promise) {
+//        try {
+//            int res = AgoraManager.getInstance().mRtcEngine
+//                    .startEchoTest();
+//            if (res != 0) throw new ReactNativeAgoraException("startEchoTest Failed", res);
+//            WritableMap map = Arguments.createMap();
+//            map.putBoolean("success", true);
+//            map.putInt("value", res);
+//            promise.resolve(map);
+//        } catch (Exception e) {
+//            promise.reject("131009", e);
+//        }
+//    }
 
     @ReactMethod
     public void stopEchoTest(Promise promise) {
     }
 
     @ReactMethod
-    public void sendStreamMessage(int streamId, String data, Promise promise) {
+    public void sendMessage(ReadableMap options, Promise promise) {
         try {
-            int res = AgoraManager.getInstance().mRtcEngine.sendStreamMessage(streamId, data.getBytes());
+            boolean reliable = options.getBoolean("reliable");
+            boolean ordered = options.getBoolean("ordered");
+            String data = options.getString("data");
+            int streamID = AgoraManager.getInstance().mRtcEngine.createDataStream(reliable, ordered);
+            if (streamID < 0) throw new ReactNativeAgoraException("createDataStream Failed", streamID);
+            int res = AgoraManager.getInstance().mRtcEngine.sendStreamMessage(streamID, data.getBytes("utf8"));
             if (res != 0) throw new ReactNativeAgoraException("sendStreamMessage Failed", res);
             WritableMap map = Arguments.createMap();
             map.putBoolean("success", true);
+            map.putInt("streamID", streamID);
             promise.resolve(map);
         } catch (Exception e) {
             promise.reject(e);
         }
     }
 
+//    deprecated
+//    @ReactMethod
+//    public void setVideoQualityParameters(boolean quality, Promise promise) {
+//        try {
+//            int res = AgoraManager.getInstance().mRtcEngine.setVideoQualityParameters(quality);
+//            if (res != 0) throw new ReactNativeAgoraException("sendStreamMessage Failed", res);
+//            WritableMap map = Arguments.createMap();
+//            map.putBoolean("success", true);
+//            map.putInt("value", res);
+//            promise.resolve(map);
+//        } catch (Exception e) {
+//            promise.reject(e);
+//        }
+//    }
+
     @ReactMethod
-    public void setVideoQualityParameters(boolean quality, Promise promise) {
+    public void setLocalVideoMirrorMode(int mode, Promise promise) {
         try {
-            int res = AgoraManager.getInstance().mRtcEngine.setVideoQualityParameters(quality);
-            if (res != 0) throw new ReactNativeAgoraException("sendStreamMessage Failed", res);
+            int res = AgoraManager.getInstance().mRtcEngine.setLocalVideoMirrorMode(mode);
+            if (res != 0) throw new ReactNativeAgoraException("setLocalVideoMirrorMode Failed", res);
             WritableMap map = Arguments.createMap();
             map.putBoolean("success", true);
-            map.putInt("value", res);
             promise.resolve(map);
         } catch (Exception e) {
             promise.reject(e);
     }
 
     @ReactMethod
-    public void setLocalVideoMirrorMode(int mode, Promise promise) {
+    public void setBeautyEffectOptions(boolean enabled, ReadableMap options, Promise promise) {
         try {
-            int res = AgoraManager.getInstance().mRtcEngine.setLocalVideoMirrorMode(mode);
-            if (res != 0) throw new ReactNativeAgoraException("setLocalVideoMirrorMode Failed", res);
+            BeautyOptions beautyOption = new BeautyOptions();
+            beautyOption.lighteningContrastLevel = options.getInt("lighteningContrastLevel");
+            beautyOption.lighteningLevel = (float) options.getDouble("lighteningLevel");
+            beautyOption.smoothnessLevel = (float) options.getDouble("smoothnessLevel");
+            beautyOption.rednessLevel = (float) options.getDouble("rednessLevel");
+            int res = AgoraManager.getInstance().mRtcEngine.setBeautyEffectOptions(true, beautyOption);
+            if (res != 0) throw new ReactNativeAgoraException("setBeautyEffectOptions Failed", res);
+            WritableMap map = Arguments.createMap();
+            map.putBoolean("success", true);
+            promise.resolve(map);
+        } catch (Exception e) {
+            promise.reject(e);
+        }
+    }
+
+    @ReactMethod
+    public void setLocalVoiceChanger(int voiceChanger, Promise promise) {
+        try {
+            int res = AgoraManager.getInstance().mRtcEngine.setLocalVoiceChanger(voiceChanger);
+            if (res != 0) throw new ReactNativeAgoraException("setLocalVoiceChanger Failed", res);
+            WritableMap map = Arguments.createMap();
+            map.putBoolean("success", true);
+            promise.resolve(map);
+        } catch (Exception e) {
+            promise.reject(e);
+        }
+    }
+
+    @ReactMethod
+    public void setLocalVoiceReverbPreset(int preset, Promise promise) {
+        try {
+            int res = AgoraManager.getInstance().mRtcEngine.setLocalVoiceReverbPreset(preset);
+            if (res != 0) throw new ReactNativeAgoraException("setLocalVoiceReverbPreset Failed", res);
+            WritableMap map = Arguments.createMap();
+            map.putBoolean("success", true);
+            promise.resolve(map);
+        } catch (Exception e) {
+            promise.reject(e);
+        }
+    }
+
+    @ReactMethod
+    public void enableSoundPositionIndication(boolean enabled, Promise promise) {
+        try {
+            int res = AgoraManager.getInstance().mRtcEngine.enableSoundPositionIndication(enabled);
+            if (res != 0) throw new ReactNativeAgoraException("enableSoundPositionIndication Failed", res);
+            WritableMap map = Arguments.createMap();
+            map.putBoolean("success", true);
+            promise.resolve(map);
+        } catch (Exception e) {
+            promise.reject(e);
+        }
+    }
+
+    @ReactMethod
+    public void setRemoteVoicePosition(int uid, int pan, int gain, Promise promise) {
+        try {
+            int res = AgoraManager.getInstance().mRtcEngine.setRemoteVoicePosition(uid, pan, gain);
+            if (res != 0) throw new ReactNativeAgoraException("setRemoteVoicePosition Failed", res);
             WritableMap map = Arguments.createMap();
             map.putBoolean("success", true);
             promise.resolve(map);
         }
     }
 
+    @ReactMethod
+    public void startLastmileProbeTest(ReadableMap config, Promise promise) {
+        try {
+            LastmileProbeConfig probeConfig = new LastmileProbeConfig();
+            probeConfig.probeUplink = config.getBoolean("probeUplink");
+            probeConfig.probeDownlink = config.getBoolean("probeDownlink");
+            probeConfig.expectedDownlinkBitrate = config.getInt("expectedDownlinkBitrate");
+            probeConfig.expectedUplinkBitrate = config.getInt("expectedUplinkBitrate");
+            int res = AgoraManager.getInstance().mRtcEngine.startLastmileProbeTest(probeConfig);
+            if (res != 0) throw new ReactNativeAgoraException("startLastmileProbeTest Failed", res);
+            WritableMap map = Arguments.createMap();
+            map.putBoolean("success", true);
+            promise.resolve(map);
+        } catch (Exception e) {
+            promise.reject(e);
+        }
+    }
+
+    @ReactMethod
+    public void stopLastmileProbeTest(Promise promise) {
+        try {
+            int res = AgoraManager.getInstance().mRtcEngine.stopLastmileProbeTest();
+            if (res != 0) throw new ReactNativeAgoraException("stopLastmileProbeTest Failed", res);
+            WritableMap map = Arguments.createMap();
+            map.putBoolean("success", true);
+            promise.resolve(map);
+        } catch (Exception e) {
+            promise.reject(e);
+        }
+    }
+
+    @ReactMethod
+    public void setRemoteUserPriority(int uid, int userPrority, Promise promise) {
+        try {
+            int res = AgoraManager.getInstance().mRtcEngine.setRemoteUserPriority(uid, userPrority);
+            if (res != 0) throw new ReactNativeAgoraException("setRemoteUserPriority Failed", res);
+            WritableMap map = Arguments.createMap();
+            map.putBoolean("success", true);
+            promise.resolve(map);
+        } catch (Exception e) {
+            promise.reject(e);
+        }
+    }
+
+    @ReactMethod
+    public void startEchoTestWithInterval(int interval, Promise promise) {
+        try {
+            int res = AgoraManager.getInstance().mRtcEngine.startEchoTest(interval);
+            if (res != 0) throw new ReactNativeAgoraException("startEchoTestWithInterval Failed", res);
+            WritableMap map = Arguments.createMap();
+            map.putBoolean("success", true);
+            promise.resolve(map);
+        } catch (Exception e) {
+            promise.reject(e);
+        }
+    }
+
+    @ReactMethod
+    public void setCameraCapturerConfiguration(ReadableMap options, Promise promise) {
+        try {
+            CameraCapturerConfiguration.CAPTURER_OUTPUT_PREFERENCE preference = CameraCapturerConfiguration.CAPTURER_OUTPUT_PREFERENCE.CAPTURER_OUTPUT_PREFERENCE_AUTO;
+            switch (options.getInt("preference")) {
+                case 0: {
+                    preference = CameraCapturerConfiguration.CAPTURER_OUTPUT_PREFERENCE.CAPTURER_OUTPUT_PREFERENCE_AUTO;
+                    break;
+                }
+                case 1: {
+                    preference = CameraCapturerConfiguration.CAPTURER_OUTPUT_PREFERENCE.CAPTURER_OUTPUT_PREFERENCE_PERFORMANCE;
+                    break;
+                }
+                case 2: {
+                    preference = CameraCapturerConfiguration.CAPTURER_OUTPUT_PREFERENCE.CAPTURER_OUTPUT_PREFERENCE_PREVIEW;
+                    break;
+                }
+            }
+            CameraCapturerConfiguration config = new CameraCapturerConfiguration(preference);
+
+            int res = AgoraManager.getInstance().mRtcEngine.setCameraCapturerConfiguration(config);
+            if (res != 0) throw new ReactNativeAgoraException("setCameraCapturerConfiguration Failed", res);
+            WritableMap map = Arguments.createMap();
+            map.putBoolean("success", true);
+            promise.resolve(map);
+        } catch (Exception e) {
+            promise.reject(e);
+        }
+    }
+
+
+
+    @ReactMethod
+
     private void sendEvent(ReactContext reactContext,
                            String eventName,
                            @Nullable WritableMap params) {

lib/RtcEngine.native.js

      *
      * 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}>
      */
-    static setLog(filepath, level) {
-        return Agora.setLog(filepath, level);
+    static setLog(filepath, level, maxfileSize) {
+        return Agora.setLog(filepath, level, maxfileSize);
     }
     /**
      * send stream message
      *
      * @param enable boolean
      * @param options {@link BeautyOptions}
-     * @returns operate result boolean
+     * @returns Promise<{success, value}>
      */
     static setBeautyEffectOptions(enabled, options) {
         return Agora.setBeautyEffectOptions(enabled, options);
      *          5: "Ethereal vocal effects.",
      *          6: "Hulk’s voice."
      *      ]
-     * @returns result boolean
+     * @returns Promise<{success, value}>
      */
     static setLocalVoiceChanger(voiceChanger) {
         return Agora.setLocalVoiceChanger(voiceChanger);
      * This method sets the preset local voice reverberation effect.
      *
      * @param preset integer
-     * @returns result boolean
+     * @returns Promise<{success, value}>
      */
     static setLocalVoiceReverbPreset(preset) {
         return Agora.setLocalVoiceReverbPreset(preset);
      * This method enables/disables stereo panning for remote users.
      *
      * @param enabled boolean
-     * @returns result boolean
+     * @returns Promise<{success, value}>
      */
     static enableSoundPositionIndication(enabled) {
         return Agora.enableSoundPositionIndication(enabled);
      *  -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
+     * @returns Promise<{success, value}>
      */
     static setRemoteVoicePosition(uid, pan, gain) {
         return Agora.setRemoteVoicePosition(uid, pan, gain);
      *
      * @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
+     * @returns Promise<{success, value}>
      */
     static startLastmileProbeTest(config) {
         return Agora.startLastmileProbeTest(config);
      *
      * This method stop the lastmile probe test.
      *
-     * @returns result boolean
+     * @returns Promise<{success, value}>
      */
     static stopLastmileProbeTest() {
         return Agora.stopLastmileProbeTest();
      * @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
+     * @returns Promise<{success, value}>
      */
     static setRemoteUserPriority(uid, userPrority) {
         return Agora.setRemoteUserPriority(uid, userPrority);
      *
      * @param interval number
      *
-     * @returns result boolean
+     * @returns Promise<{success, value}>
      */
     static startEchoTestWithInterval(interval) {
         return Agora.startEchoTestWithInterval(interval);
      *
      * @param config {@link CameraCapturerConfiguration}
      *
-     * @returns result boolean
+     * @returns Promise<{success, value}>
      */
     static setCameraCapturerConfiguration(config) {
         return Agora.setCameraCapturerConfiguration(config);

src/RtcEngine.native.ts

      }
 
     /**
+     * @deprecated
      * start echo test
      * 
      * This method launches an audio call test to determine whether the audio devices (for example, headset and speaker) and the network connection are working properly.
      * @returns Promise<{success, value}>
      */
-    public static startEchoTest(): Promise<any> {
-        return Agora.startEchoTest();
-    }
+    // public static startEchoTest(): Promise<any> {
+    //     return Agora.startEchoTest();
+    // }
 
     /**
+     * @deprecated
      * stop echo test
      * 
      * This method stop launched an audio call test.
      * @returns Promise<{success, value}>
      */
-    public static stopEchoTest(): Promise<any> {
-        return Agora.stopEchoTest();
-    }
+    // public static stopEchoTest(): Promise<any> {
+    //     return Agora.stopEchoTest();
+    // }
 
     /**
      * enable lastmile test
     }
 
     /**
+     * @deprecated
      * set video quality 
      * 
      * This method sets the preferences for the video quality. (Live broadcast only).
      * @param quality boolean
      * @returns Promise<{success, value}> 
      */
-    public static setVideoQualityParameters(quality: boolean): Promise<any> {
-        return Agora.setVideoQualityParameters(quality);
-    }
+    // public static setVideoQualityParameters(quality: boolean): Promise<any> {
+    //     return Agora.setVideoQualityParameters(quality);
+    // }
 
     /**
      * set local video mirror mode
     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
-     */
-
-
-    
-
 }