react-native-shengwang 4.6.2-rc.2

package/android/src/main/java/io/agora/rtc/ng/react/AgoraRtcNgModule.java

@@ -0,0 +1,278 @@
+package io.agora.rtc.ng.react;
+
+import android.app.Activity;
+import android.util.Base64;
+import android.graphics.Rect;
+import android.os.Build;
+import android.util.Rational;
+
+import androidx.annotation.NonNull;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableArray;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.module.annotations.ReactModule;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+import io.agora.iris.IrisApiEngine;
+import io.agora.iris.IrisEventHandler;
+
+import io.agora.iris.pip.AgoraPIPActivityProxy;
+import io.agora.iris.pip.AgoraPIPController;
+
+@ReactModule(name = AgoraRtcNgModule.NAME)
+public class AgoraRtcNgModule extends AgoraRtcNgSpec implements IrisEventHandler {
+  public static final String NAME = "AgoraRtcNg";
+  public final Object irisApiLock = new Object();
+  public IrisApiEngine irisApiEngine;
+  private AgoraPIPController pipController;
+
+  AgoraRtcNgModule(ReactApplicationContext context) {
+    super(context);
+  }
+
+  @Override
+  @NonNull
+  public String getName() {
+    return NAME;
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public boolean newIrisApiEngine() {
+    synchronized (irisApiLock) {
+      if (irisApiEngine == null) {
+        IrisApiEngine.enableUseJsonArray(true);
+        irisApiEngine = new IrisApiEngine(getReactApplicationContext());
+        irisApiEngine.setEventHandler(this);
+        Activity currentActivity = getReactApplicationContext().getCurrentActivity();
+        if (currentActivity != null) {
+          initPipController(currentActivity);
+        }
+        return true;
+      }
+    }
+    return false;
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public boolean destroyIrisApiEngine() {
+    synchronized (irisApiLock) {
+      if (irisApiEngine != null) {
+        irisApiEngine.setEventHandler(null);
+        irisApiEngine.destroy();
+        irisApiEngine = null;
+        pipController = null;
+        return true;
+      }
+    }
+    return false;
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public String callApi(ReadableMap args) {
+    synchronized (irisApiLock) {
+      String funcName = args.getString("funcName");
+      String params = args.getString("params");
+      List<byte[]> buffers = null;
+
+      ReadableArray array = args.getArray("buffers");
+      if (array != null) {
+        buffers = new ArrayList<>();
+        for (int i = 0; i < array.size(); i++) {
+          buffers.add(Base64.decode(array.getString(i), Base64.DEFAULT));
+        }
+      }
+
+      try {
+        newIrisApiEngine();
+        return irisApiEngine.callIrisApi(funcName, params, buffers);
+      } catch (Exception e) {
+        e.printStackTrace();
+        try {
+          return new JSONObject().put("result", e.getMessage()).toString();
+        } catch (JSONException ex) {
+          throw new RuntimeException(ex);
+        }
+      }
+    }
+  }
+
+  private void initPipController(@NonNull Activity activity) {
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+
+      if (!(activity instanceof AgoraPIPActivityProxy)) {
+        return;
+      }
+
+      if (pipController != null) {
+        pipController.dispose();
+      }
+
+      pipController = new AgoraPIPController(
+          (AgoraPIPActivityProxy) activity,
+          new AgoraPIPController.PIPStateChangedListener() {
+            @Override
+            public void onPIPStateChangedListener(
+                AgoraPIPController.PIPState state, String error) {
+              try {
+                OnEvent("AgoraPip_onPipStateChanged",
+                    new JSONObject().put("state", state.getValue()).put("error", error).toString(), null);
+              } catch (JSONException e) {
+                throw new RuntimeException(e);
+              }
+            }
+          });
+    }
+  }
+
+  @ReactMethod
+  public void showRPSystemBroadcastPickerView(boolean showsMicrophoneButton, Promise promise) {
+    promise.reject("", "not support");
+  }
+
+  @ReactMethod
+  public void addListener(String eventName) {
+
+  }
+
+  @ReactMethod
+  public void removeListeners(double count) {
+
+  }
+
+  private boolean checkPipIsReady() {
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
+      return false;
+    }
+    if (pipController == null) {
+      return false;
+    }
+    return true;
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public boolean pipIsSupported() {
+    synchronized (irisApiLock) {
+      return checkPipIsReady() && pipController.isSupported();
+    }
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public boolean pipIsAutoEnterSupported() {
+    synchronized (irisApiLock) {
+      return checkPipIsReady() && pipController.isAutoEnterSupported();
+    }
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public boolean isPipActivated() {
+    synchronized (irisApiLock) {
+      return checkPipIsReady() && pipController.isActivated();
+    }
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public boolean pipSetup(ReadableMap options) {
+    synchronized (irisApiLock) {
+      if (!checkPipIsReady()) {
+        return false;
+      }
+      Rational aspectRatio = null;
+      if (options.hasKey("aspectRatioX") && options.hasKey("aspectRatioY")) {
+        aspectRatio = new Rational(options.getInt("aspectRatioX"),
+            options.getInt("aspectRatioY"));
+      }
+      Boolean autoEnterEnabled = null;
+      if (options.hasKey("autoEnterEnabled")) {
+        autoEnterEnabled = options.getBoolean("autoEnterEnabled");
+      }
+      Rect sourceRectHint = null;
+      if (options.hasKey("sourceRectHintLeft") &&
+          options.hasKey("sourceRectHintTop") &&
+          options.hasKey("sourceRectHintRight") &&
+          options.hasKey("sourceRectHintBottom")) {
+        sourceRectHint = new Rect(
+            options.getInt("sourceRectHintLeft"),
+            options.getInt("sourceRectHintTop"),
+            options.getInt("sourceRectHintRight"),
+            options.getInt("sourceRectHintBottom"));
+      }
+      Boolean seamlessResizeEnabled = null;
+      if (options.hasKey("seamlessResizeEnabled")) {
+        seamlessResizeEnabled = options.getBoolean("seamlessResizeEnabled");
+      }
+      Boolean useExternalStateMonitor = null;
+      if (options.hasKey("useExternalStateMonitor")) {
+        useExternalStateMonitor = options.getBoolean("useExternalStateMonitor");
+      } else {
+        useExternalStateMonitor = true;
+      }
+      Integer externalStateMonitorInterval = null;
+      if (options.hasKey("externalStateMonitorInterval")) {
+        externalStateMonitorInterval = options.getInt("externalStateMonitorInterval");
+      } else {
+        externalStateMonitorInterval = 100;
+      }
+      boolean result = pipController.setup(
+          aspectRatio, autoEnterEnabled, sourceRectHint,
+          seamlessResizeEnabled, useExternalStateMonitor,
+          externalStateMonitorInterval);
+      return result;
+    }
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public boolean pipStart() {
+    synchronized (irisApiLock) {
+      return checkPipIsReady() && pipController.start();
+    }
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public void pipStop() {
+    synchronized (irisApiLock) {
+      if (checkPipIsReady()) {
+        pipController.stop();
+      }
+    }
+  }
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  public void pipDispose() {
+    synchronized (irisApiLock) {
+      if (checkPipIsReady()) {
+        pipController.dispose();
+      }
+    }
+  }
+
+  @Override
+  public void OnEvent(String event, String data, List<byte[]> buffers) {
+    final WritableMap map = Arguments.createMap();
+    map.putString("event", event);
+    map.putString("data", data);
+    if (buffers != null) {
+      WritableArray array = Arguments.createArray();
+      for (byte[] buffer : buffers) {
+        String base64 = Base64.encodeToString(buffer, Base64.DEFAULT);
+        array.pushString(base64);
+      }
+      map.putArray("buffers", array);
+    }
+    getReactApplicationContext()
+        .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+        .emit("AgoraRtcNg:onEvent", map);
+  }
+}

package/android/src/main/java/io/agora/rtc/ng/react/AgoraRtcNgPackage.java

@@ -0,0 +1,61 @@
+package io.agora.rtc.ng.react;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.facebook.react.TurboReactPackage;
+import com.facebook.react.bridge.ModuleHolder;
+import com.facebook.react.bridge.ModuleSpec;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.module.model.ReactModuleInfo;
+import com.facebook.react.module.model.ReactModuleInfoProvider;
+import com.facebook.react.uimanager.ViewManager;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class AgoraRtcNgPackage extends TurboReactPackage {
+
+  @Nullable
+  @Override
+  public NativeModule getModule(String name, ReactApplicationContext reactContext) {
+    if (name.equals(AgoraRtcNgModule.NAME)) {
+      return new AgoraRtcNgModule(reactContext);
+    } else {
+      return null;
+    }
+  }
+
+  @Override
+  public ReactModuleInfoProvider getReactModuleInfoProvider() {
+    return () -> {
+      final Map<String, ReactModuleInfo> moduleInfos = new HashMap<>();
+      boolean isTurboModule = BuildConfig.IS_NEW_ARCHITECTURE_ENABLED;
+      moduleInfos.put(
+        AgoraRtcNgModule.NAME,
+        new ReactModuleInfo(
+          AgoraRtcNgModule.NAME,
+          AgoraRtcNgModule.NAME,
+          false, // canOverrideExistingModule
+          false, // needsEagerInit
+          true, // hasConstants
+          false, // isCxxModule
+          isTurboModule // isTurboModule
+        ));
+      return moduleInfos;
+    };
+  }
+
+  @NonNull
+  @Override
+  public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
+    List<ViewManager> viewManagers = new ArrayList<>();
+    viewManagers.add(new AgoraRtcSurfaceViewManager());
+    viewManagers.add(new AgoraRtcTextureViewManager());
+    return viewManagers;
+  }
+}

package/android/src/main/java/io/agora/rtc/ng/react/AgoraRtcSurfaceViewManager.java

@@ -0,0 +1,60 @@
+package io.agora.rtc.ng.react;
+
+import android.view.SurfaceView;
+import android.widget.FrameLayout;
+
+import androidx.annotation.Nullable;
+
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.module.annotations.ReactModule;
+import com.facebook.react.uimanager.ThemedReactContext;
+import com.facebook.react.uimanager.annotations.ReactProp;
+
+@ReactModule(name = AgoraRtcSurfaceViewManager.NAME)
+public class AgoraRtcSurfaceViewManager extends AgoraRtcSurfaceViewManagerSpec<FrameLayout> {
+
+  public static final String NAME = "AgoraRtcSurfaceView";
+  private ThemedReactContext context;
+
+  @Override
+  public String getName() {
+    return NAME;
+  }
+
+  @Override
+  public FrameLayout createViewInstance(ThemedReactContext context) {
+    this.context = context;
+    FrameLayout layout = new FrameLayout(context.getReactApplicationContext());
+    layout.addView(new SurfaceView(context.getApplicationContext()));
+    return layout;
+  }
+
+  @Override
+  @ReactProp(name = "callApi")
+  public void setCallApi(FrameLayout view, @Nullable ReadableMap arguments) {
+    String funcName = arguments.getString("funcName");
+    String params = arguments.getString("params");
+    AgoraRtcNgModule module = context.getNativeModule(AgoraRtcNgModule.class);
+    synchronized (module.irisApiLock) {
+      if (module != null) {
+        try {
+          module.irisApiEngine.callIrisApi(funcName, params, view.getChildAt(0));
+        } catch (Exception e) {
+          e.printStackTrace();
+        }
+      }
+    }
+  }
+
+  @Override
+  @ReactProp(name = "zOrderOnTop")
+  public void setZOrderOnTop(FrameLayout view, boolean onTop) {
+    ((SurfaceView) view.getChildAt(0)).setZOrderOnTop(onTop);
+  }
+
+  @Override
+  @ReactProp(name = "zOrderMediaOverlay")
+  public void setZOrderMediaOverlay(FrameLayout view, boolean isMediaOverlay) {
+    ((SurfaceView) view.getChildAt(0)).setZOrderMediaOverlay(isMediaOverlay);
+  }
+}

package/android/src/main/java/io/agora/rtc/ng/react/AgoraRtcTextureViewManager.java

@@ -0,0 +1,45 @@
+package io.agora.rtc.ng.react;
+
+import android.view.TextureView;
+
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.module.annotations.ReactModule;
+import com.facebook.react.uimanager.ThemedReactContext;
+import com.facebook.react.uimanager.annotations.ReactProp;
+
+import javax.annotation.Nullable;
+
+@ReactModule(name = AgoraRtcTextureViewManager.NAME)
+public class AgoraRtcTextureViewManager extends AgoraRtcTextureViewManagerSpec<TextureView> {
+
+  public static final String NAME = "AgoraRtcTextureView";
+  private ThemedReactContext context;
+
+  @Override
+  public String getName() {
+    return NAME;
+  }
+
+  @Override
+  public TextureView createViewInstance(ThemedReactContext context) {
+    this.context = context;
+    return new TextureView(context.getApplicationContext());
+  }
+
+  @Override
+  @ReactProp(name = "callApi")
+  public void setCallApi(TextureView view, @Nullable ReadableMap arguments) {
+    String funcName = arguments.getString("funcName");
+    String params = arguments.getString("params");
+    AgoraRtcNgModule module = context.getNativeModule(AgoraRtcNgModule.class);
+    synchronized (module.irisApiLock) {
+      if (module != null) {
+        try {
+          module.irisApiEngine.callIrisApi(funcName, params, view);
+        } catch (Exception e) {
+          e.printStackTrace();
+        }
+      }
+    }
+  }
+}

package/android/src/newarch/io/agora/rtc/ng/react/AgoraRtcNgSpec.java

@@ -0,0 +1,9 @@
+package io.agora.rtc.ng.react;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+
+public abstract class AgoraRtcNgSpec extends NativeAgoraRtcNgSpec {
+  AgoraRtcNgSpec(ReactApplicationContext context) {
+    super(context);
+  }
+}

package/android/src/newarch/io/agora/rtc/ng/react/AgoraRtcSurfaceViewManagerSpec.java

@@ -0,0 +1,25 @@
+package io.agora.rtc.ng.react;
+
+import android.view.View;
+
+import com.facebook.react.uimanager.SimpleViewManager;
+import com.facebook.react.uimanager.ViewManagerDelegate;
+import com.facebook.react.viewmanagers.AgoraRtcSurfaceViewManagerDelegate;
+import com.facebook.react.viewmanagers.AgoraRtcSurfaceViewManagerInterface;
+
+import javax.annotation.Nullable;
+
+public abstract class AgoraRtcSurfaceViewManagerSpec<T extends View> extends SimpleViewManager<T> implements AgoraRtcSurfaceViewManagerInterface<T> {
+
+  private final ViewManagerDelegate<T> mDelegate;
+
+  public AgoraRtcSurfaceViewManagerSpec() {
+    mDelegate = new AgoraRtcSurfaceViewManagerDelegate(this);
+  }
+
+  @Nullable
+  @Override
+  protected ViewManagerDelegate<T> getDelegate() {
+    return mDelegate;
+  }
+}

package/android/src/newarch/io/agora/rtc/ng/react/AgoraRtcTextureViewManagerSpec.java

@@ -0,0 +1,25 @@
+package io.agora.rtc.ng.react;
+
+import android.view.View;
+
+import com.facebook.react.uimanager.SimpleViewManager;
+import com.facebook.react.uimanager.ViewManagerDelegate;
+import com.facebook.react.viewmanagers.AgoraRtcTextureViewManagerDelegate;
+import com.facebook.react.viewmanagers.AgoraRtcTextureViewManagerInterface;
+
+import javax.annotation.Nullable;
+
+public abstract class AgoraRtcTextureViewManagerSpec<T extends View> extends SimpleViewManager<T> implements AgoraRtcTextureViewManagerInterface<T> {
+
+  private final ViewManagerDelegate<T> mDelegate;
+
+  public AgoraRtcTextureViewManagerSpec() {
+    mDelegate = new AgoraRtcTextureViewManagerDelegate(this);
+  }
+
+  @Nullable
+  @Override
+  protected ViewManagerDelegate<T> getDelegate() {
+    return mDelegate;
+  }
+}

package/android/src/oldarch/io/agora/rtc/ng/react/AgoraRtcNgSpec.java

@@ -0,0 +1,40 @@
+package io.agora.rtc.ng.react;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableMap;
+
+public abstract class AgoraRtcNgSpec extends ReactContextBaseJavaModule {
+  AgoraRtcNgSpec(ReactApplicationContext context) {
+    super(context);
+  }
+
+  public abstract boolean newIrisApiEngine();
+
+  public abstract boolean destroyIrisApiEngine();
+
+  public abstract String callApi(ReadableMap arguments);
+
+  public abstract void showRPSystemBroadcastPickerView(boolean showsMicrophoneButton, Promise promise);
+
+  public abstract void addListener(String eventName);
+
+  public abstract void removeListeners(double count);
+
+  public abstract boolean pipIsSupported();
+
+  public abstract boolean pipIsAutoEnterSupported();
+
+  public abstract boolean isPipActivated();
+
+  public abstract boolean pipSetup(ReadableMap options);
+
+  public abstract boolean pipStart();
+
+  public abstract void pipStop();
+
+  public abstract void pipDispose();
+
+}

package/android/src/oldarch/io/agora/rtc/ng/react/AgoraRtcSurfaceViewManagerSpec.java

@@ -0,0 +1,16 @@
+package io.agora.rtc.ng.react;
+
+import android.view.View;
+
+import androidx.annotation.Nullable;
+
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.uimanager.SimpleViewManager;
+
+public abstract class AgoraRtcSurfaceViewManagerSpec<T extends View> extends SimpleViewManager<T> {
+  public abstract void setCallApi(T view, @Nullable ReadableMap arguments);
+
+  public abstract void setZOrderOnTop(T view, boolean onTop);
+
+  public abstract void setZOrderMediaOverlay(T view, boolean isMediaOverlay);
+}

package/android/src/oldarch/io/agora/rtc/ng/react/AgoraRtcTextureViewManagerSpec.java

@@ -0,0 +1,12 @@
+package io.agora.rtc.ng.react;
+
+import android.view.View;
+
+import androidx.annotation.Nullable;
+
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.uimanager.SimpleViewManager;
+
+public abstract class AgoraRtcTextureViewManagerSpec<T extends View> extends SimpleViewManager<T> {
+  public abstract void setCallApi(T view, @Nullable ReadableMap arguments);
+}

package/ios/AgoraRtcNg.h

@@ -0,0 +1,20 @@
+#import <UIKit/UIKit.h>
+#import <AgoraRtcWrapper/iris_engine_base.h>
+#import <React/RCTEventEmitter.h>
+
+#ifdef RCT_NEW_ARCH_ENABLED
+#import "AgoraRtcNgSpec.h"
+
+@interface AgoraRtcNg : RCTEventEmitter <NativeAgoraRtcNgSpec>
+#else
+#import <React/RCTBridgeModule.h>
+
+@interface AgoraRtcNg : RCTEventEmitter <RCTBridgeModule, RCTInvalidating>
+#endif
+
+@property(nonatomic) IApiEngineBase *irisApiEngine;
+// @property(nonatomic) AgoraPIPController *pipController;
+
++ (instancetype)shareInstance;
+
+@end