@byteplus/react-native-rtc 1.1.1 → 1.3.2

package/android/src/main/java/com/volcengine/reactnative/vertc/events/ClassHelper.java

@@ -3,6 +3,13 @@
 
 package com.volcengine.reactnative.vertc.events;
 
+import com.ss.bytertc.engine.RTCRoomConfig;
+import com.ss.bytertc.engine.data.AudioPropertiesInfo;
+import com.ss.bytertc.engine.data.PublishState;
+import com.ss.bytertc.engine.data.PublishStateChangeReason;
+import com.ss.bytertc.engine.data.RemoteVideoConfig;
+import com.ss.bytertc.engine.data.SubscribeState;
+import com.ss.bytertc.engine.data.SubscribeStateChangeReason;
 import com.ss.bytertc.engine.handler.IRTCRoomEventHandler;
 import com.ss.bytertc.engine.handler.IRTCVideoEventHandler;
 import com.ss.bytertc.engine.SysStats;
@@ -30,7 +37,6 @@ import com.ss.bytertc.engine.data.VideoDenoiseModeChangedReason;
 import com.ss.bytertc.engine.data.VideoFrameInfo;
 import com.ss.bytertc.engine.data.VideoSuperResolutionMode;
 import com.ss.bytertc.engine.data.VideoSuperResolutionModeChangedReason;
-import com.ss.bytertc.engine.handler.IRTCVideoEventHandler;
 import com.ss.bytertc.engine.type.AudioDeviceType;
 import com.ss.bytertc.engine.type.AudioDumpStatus;
 import com.ss.bytertc.engine.type.AudioRecordingErrorCode;
@@ -45,6 +51,8 @@ import com.ss.bytertc.engine.type.LocalProxyState;
 import com.ss.bytertc.engine.type.LocalProxyType;
 import com.ss.bytertc.engine.type.LocalVideoStreamError;
 import com.ss.bytertc.engine.type.LocalVideoStreamState;
+import com.ss.bytertc.engine.type.MediaDeviceError;
+import com.ss.bytertc.engine.type.MediaDeviceState;
 import com.ss.bytertc.engine.type.NetworkDetectionLinkType;
 import com.ss.bytertc.engine.type.NetworkDetectionStopReason;
 import com.ss.bytertc.engine.type.PerformanceAlarmMode;
@@ -67,7 +75,6 @@ import com.ss.bytertc.engine.UserInfo;
 import com.ss.bytertc.engine.data.AVSyncState;
 import com.ss.bytertc.engine.data.ForwardStreamEventInfo;
 import com.ss.bytertc.engine.data.ForwardStreamStateInfo;
-import com.ss.bytertc.engine.handler.IRTCRoomEventHandler;
 import com.ss.bytertc.engine.type.LocalStreamStats;
 import com.ss.bytertc.engine.type.MediaStreamType;
 import com.ss.bytertc.engine.type.NetworkQualityStats;
@@ -83,7 +90,11 @@ import com.volcengine.VolcApiEngine.BeanFactory;
 import com.volcengine.VolcApiEngine.runtime.Util;
 
 public class ClassHelper {
-  public static void init() {
+  private static boolean initialized = false;
+  public static synchronized void init() {
+    if (initialized) {
+      return;
+    }
     BeanFactory.register(IRTCVideoEventHandler.class, IRTCVideoEventHandlerImpl.class);
     BeanFactory.register(IRTCRoomEventHandler.class, IRTCRoomEventHandlerImpl.class);
     Util.JsonAbleClass.add(SysStats.class);
@@ -160,5 +171,15 @@ public class ClassHelper {
     Util.JsonAbleClass.add(SubtitleMessage.class);
     Util.JsonAbleClass.add(SubtitleState.class);
     Util.JsonAbleClass.add(UserVisibilityChangeError.class);
+    Util.JsonAbleClass.add(PublishStateChangeReason.class);
+    Util.JsonAbleClass.add(PublishState.class);
+    Util.JsonAbleClass.add(SubscribeStateChangeReason.class);
+    Util.JsonAbleClass.add(SubscribeState.class);
+    Util.JsonAbleClass.add(RemoteVideoConfig.class);
+    Util.JsonAbleClass.add(RTCRoomConfig.class);
+    Util.JsonAbleClass.add(MediaDeviceState.class);
+    Util.JsonAbleClass.add(MediaDeviceError.class);
+    Util.JsonAbleClass.add(AudioPropertiesInfo.class);
+    initialized = true;
   }
 }

package/android/src/main/java/com/volcengine/reactnative/vertc/events/IRTCRoomEventHandlerImpl.java

@@ -3,12 +3,18 @@
 
 package com.volcengine.reactnative.vertc.events;
 
+import android.util.Log;
+
 import com.ss.bytertc.engine.RTCStream;
 import com.ss.bytertc.engine.SubscribeConfig;
 import com.ss.bytertc.engine.UserInfo;
 import com.ss.bytertc.engine.data.AVSyncState;
 import com.ss.bytertc.engine.data.ForwardStreamEventInfo;
 import com.ss.bytertc.engine.data.ForwardStreamStateInfo;
+import com.ss.bytertc.engine.data.PublishState;
+import com.ss.bytertc.engine.data.PublishStateChangeReason;
+import com.ss.bytertc.engine.data.SubscribeState;
+import com.ss.bytertc.engine.data.SubscribeStateChangeReason;
 import com.ss.bytertc.engine.handler.IRTCRoomEventHandler;
 import com.ss.bytertc.engine.type.LocalStreamStats;
 import com.ss.bytertc.engine.type.MediaStreamType;
@@ -19,11 +25,17 @@ import com.ss.bytertc.engine.type.SetRoomExtraInfoResult;
 import com.ss.bytertc.engine.type.StreamRemoveReason;
 import com.ss.bytertc.engine.type.SubtitleErrorCode;
 import com.ss.bytertc.engine.type.SubtitleMessage;
+import com.ss.bytertc.engine.type.SubtitleMode;
 import com.ss.bytertc.engine.type.SubtitleState;
 import com.ss.bytertc.engine.type.UserVisibilityChangeError;
 import com.volcengine.VolcApiEngine.BeanFactory;
 
+import java.lang.reflect.Array;
 import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
 
 public class IRTCRoomEventHandlerImpl extends IRTCRoomEventHandler implements BeanFactory.EventReceiver  {
    public BeanFactory.EventEmitter ee;
@@ -93,23 +105,64 @@ public class IRTCRoomEventHandlerImpl extends IRTCRoomEventHandler implements Be
   }
 
   @Override
-  public void onUserPublishStream(String uid, MediaStreamType type) {
-    this.ee.sendEvent("onUserPublishStream", uid, type);
+  public void onUserPublishStreamVideo(String roomId, String uid, boolean isPublish) {
+    this.ee.sendEvent("onUserPublishStreamVideo", roomId, uid, isPublish);
+  }
+
+  @Override
+  public void onUserPublishStreamAudio(String roomId, String uid, boolean isPublish) {
+    this.ee.sendEvent("onUserPublishStreamAudio", roomId, uid, isPublish);
+  }
+
+  @Override
+  public void onUserPublishScreenVideo(String roomId, String uid, boolean isPublish) {
+    this.ee.sendEvent("onUserPublishScreenVideo", roomId, uid, isPublish);
+  }
+
+  @Override
+  public void onUserPublishScreenAudio(String roomId, String uid, boolean isPublish) {
+    this.ee.sendEvent("onUserPublishScreenAudio", roomId, uid, isPublish);
+  }
+
+  @Override
+  public void onVideoPublishStateChanged(String roomId, String uid, PublishState state, PublishStateChangeReason reason) {
+    this.ee.sendEvent("onVideoPublishStateChanged", roomId, uid, state, reason);
+  }
+
+  @Override
+  public void onAudioPublishStateChanged(String roomId, String uid, PublishState state, PublishStateChangeReason reason) {
+    this.ee.sendEvent("onAudioPublishStateChanged", roomId, uid, state, reason);
+  }
+
+  @Override
+  public void onScreenVideoPublishStateChanged(String roomId, String uid, PublishState state, PublishStateChangeReason reason) {
+    this.ee.sendEvent("onScreenVideoPublishStateChanged", roomId, uid, state, reason);
+  }
+
+  @Override
+  public void onScreenAudioPublishStateChanged(String roomId, String uid, PublishState state, PublishStateChangeReason reason) {
+    this.ee.sendEvent("onScreenAudioPublishStateChanged", roomId, uid, state, reason);
+  }
+
+
+  @Override
+  public void onVideoSubscribeStateChanged(String roomId, String uid, SubscribeState state, SubscribeStateChangeReason reason) {
+    this.ee.sendEvent("onVideoSubscribeStateChanged", roomId, uid, state, reason);
   }
 
   @Override
-  public void onUserUnpublishStream(String uid, MediaStreamType type, StreamRemoveReason reason) {
-    this.ee.sendEvent("onUserUnpublishStream", uid, type, reason);
+  public void onAudioSubscribeStateChanged(String roomId, String uid, SubscribeState state, SubscribeStateChangeReason reason) {
+    this.ee.sendEvent("onAudioSubscribeStateChanged", roomId, uid, state, reason);
   }
 
   @Override
-  public void onUserPublishScreen(String uid, MediaStreamType type) {
-    this.ee.sendEvent("onUserPublishScreen", uid, type);
+  public void onScreenVideoSubscribeStateChanged(String roomId, String uid, SubscribeState state, SubscribeStateChangeReason reason) {
+    this.ee.sendEvent("onScreenVideoSubscribeStateChanged", roomId, uid, state, reason);
   }
 
   @Override
-  public void onUserUnpublishScreen(String uid, MediaStreamType type, StreamRemoveReason reason) {
-    this.ee.sendEvent("onUserUnpublishScreen", uid, type, reason);
+  public void onScreenAudioSubscribeStateChanged(String roomId, String uid, SubscribeState state, SubscribeStateChangeReason reason) {
+    this.ee.sendEvent("onScreenAudioSubscribeStateChanged", roomId, uid, state, reason);
   }
 
   @Override
@@ -184,12 +237,27 @@ public class IRTCRoomEventHandlerImpl extends IRTCRoomEventHandler implements Be
 
   @Override
   public void onForwardStreamStateChanged(ForwardStreamStateInfo[] stateInfos) {
-    this.ee.sendEvent("onForwardStreamStateChanged", new Object[]{ stateInfos });
+    ArrayList<Object> res = new ArrayList<>();
+    for (ForwardStreamStateInfo info : stateInfos) {
+      Map<String, Object> data = new HashMap<>();
+      data.put("roomId", info.roomId);
+      data.put("state", info.state);
+      data.put("error", info.error);
+      res.add(data);
+    }
+    this.ee.sendEvent("onForwardStreamStateChanged", res);
   }
 
   @Override
   public void onForwardStreamEvent(ForwardStreamEventInfo[] eventInfos) {
-    this.ee.sendEvent("onForwardStreamEvent", new Object[]{ eventInfos });
+    ArrayList<Object> res = new ArrayList<>();
+    for (ForwardStreamEventInfo info : eventInfos) {
+      Map<String, Object> data = new HashMap<>();
+      data.put("roomId", info.roomId);
+      data.put("event", info.event);
+      res.add(data);
+    }
+    this.ee.sendEvent("onForwardStreamEvent", res);
   }
 
   @Override
@@ -219,6 +287,17 @@ public class IRTCRoomEventHandlerImpl extends IRTCRoomEventHandler implements Be
 
   @Override
   public void onSubtitleMessageReceived(SubtitleMessage[] subtitles) {
-    this.ee.sendEvent("onSubtitleMessageReceived", new Object[]{ subtitles });
+    ArrayList<Object> res = new ArrayList<>();
+    for (SubtitleMessage subtitle : subtitles) {
+      Map<String, Object> data = new HashMap<>();
+      data.put("userId", subtitle.userId);
+      data.put("mode", subtitle.mode);
+      data.put("text", subtitle.text);
+      data.put("language", subtitle.language);
+      data.put("sequence", subtitle.sequence);
+      data.put("definite", subtitle.definite);
+      res.add(data);
+    }
+    this.ee.sendEvent("onSubtitleMessageReceived", res);
   }
 }

package/android/src/main/java/com/volcengine/reactnative/vertc/events/IRTCVideoEventHandlerImpl.java

@@ -64,6 +64,9 @@ import com.volcengine.VolcApiEngine.BeanFactory;
 import org.json.JSONObject;
 
 import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Map;
 
 public class IRTCVideoEventHandlerImpl extends IRTCVideoEventHandler implements BeanFactory.EventReceiver {
   public BeanFactory.EventEmitter ee;
@@ -274,12 +277,14 @@ public class IRTCVideoEventHandlerImpl extends IRTCVideoEventHandler implements
 
   @Override
   public void onAudioDeviceStateChanged(String deviceID, AudioDeviceType deviceType, int deviceState, int deviceError) {
-    this.ee.sendEvent("onAudioDeviceStateChanged", deviceID, deviceType, deviceState, deviceError);
+    int deviceTypeInt = deviceType.value();
+    this.ee.sendEvent("onAudioDeviceStateChanged", deviceID, deviceTypeInt, deviceState, deviceError);
   }
 
   @Override
   public void onVideoDeviceStateChanged(String deviceID, VideoDeviceType deviceType, int deviceState, int deviceError) {
-    this.ee.sendEvent("onVideoDeviceStateChanged", deviceID, deviceType, deviceState, deviceError);
+    int deviceTypeInt = deviceType.value();
+    this.ee.sendEvent("onVideoDeviceStateChanged", deviceID, deviceTypeInt, deviceState, deviceError);
   }
 
   @Override
@@ -339,7 +344,33 @@ public class IRTCVideoEventHandlerImpl extends IRTCVideoEventHandler implements
 
   @Override
   public void onLocalAudioPropertiesReport(LocalAudioPropertiesInfo[] audioPropertiesInfos) {
-    this.ee.sendEvent("onLocalAudioPropertiesReport", new Object[]{ audioPropertiesInfos });
+    android.os.Handler mainHandler =
+      new android.os.Handler(android.os.Looper.getMainLooper());
+    mainHandler.post(() -> {
+      try {
+        ArrayList<Object> res = new ArrayList<>();
+        for (LocalAudioPropertiesInfo info : audioPropertiesInfos) {
+          Map<String, Object> data = new HashMap<>();
+          Map<String, Object> props = new HashMap<>();
+          ArrayList<Number> spectrum = new ArrayList<>(info.audioPropertiesInfo.spectrum.length);
+          for (int i = 0; i < info.audioPropertiesInfo.spectrum.length; i++) {
+            spectrum.add(info.audioPropertiesInfo.spectrum[i]);
+          }
+          data.put("streamIndex", info.streamIndex);
+          props.put("linearVolume", info.audioPropertiesInfo.linearVolume);
+          props.put("nonlinearVolume", info.audioPropertiesInfo.nonlinearVolume);
+          props.put("spectrum", spectrum);
+          props.put("vad", info.audioPropertiesInfo.vad);
+          props.put("voicePitch", info.audioPropertiesInfo.voicePitch);
+          props.put("deviceLoopDelay", info.audioPropertiesInfo.deviceLoopDelay);
+          data.put("audioPropertiesInfo", props);
+          res.add(data);
+        }
+        this.ee.sendEvent("onLocalAudioPropertiesReport", res);
+      } catch (Exception e) {
+        e.printStackTrace();
+      }
+    });
   }
 
   @Override
@@ -349,7 +380,37 @@ public class IRTCVideoEventHandlerImpl extends IRTCVideoEventHandler implements
 
   @Override
   public void onRemoteAudioPropertiesReport(RemoteAudioPropertiesInfo[] audioPropertiesInfos, int totalRemoteVolume) {
-    this.ee.sendEvent("onRemoteAudioPropertiesReport", audioPropertiesInfos, totalRemoteVolume);
+    android.os.Handler mainHandler =
+      new android.os.Handler(android.os.Looper.getMainLooper());
+    mainHandler.post(() -> {
+      try {
+        ArrayList<Object> res = new ArrayList<>();
+        for (RemoteAudioPropertiesInfo info : audioPropertiesInfos) {
+          Map<String, Object> data = new HashMap<>();
+          Map<String, Object> streamKey = new HashMap<>();
+          Map<String, Object> props = new HashMap<>();
+          ArrayList<Number> spectrum = new ArrayList<>(info.audioPropertiesInfo.spectrum.length);
+          for (int i = 0; i < info.audioPropertiesInfo.spectrum.length; i++) {
+            spectrum.add(info.audioPropertiesInfo.spectrum[i]);
+          }
+          streamKey.put("roomId", info.streamKey.roomId);
+          streamKey.put("userId", info.streamKey.userId);
+          streamKey.put("streamIndex", info.streamKey.streamIndex);
+          data.put("streamKey", streamKey);
+          props.put("linearVolume", info.audioPropertiesInfo.linearVolume);
+          props.put("nonlinearVolume", info.audioPropertiesInfo.nonlinearVolume);
+          props.put("spectrum", spectrum);
+          props.put("vad", info.audioPropertiesInfo.vad);
+          props.put("voicePitch", info.audioPropertiesInfo.voicePitch);
+          props.put("deviceLoopDelay", info.audioPropertiesInfo.deviceLoopDelay);
+          data.put("audioPropertiesInfo", props);
+          res.add(data);
+        }
+        this.ee.sendEvent("onRemoteAudioPropertiesReport", res, totalRemoteVolume);
+      } catch (Exception e) {
+        e.printStackTrace();
+      }
+    });
   }
 
   @Override

package/android/src/newarch/com/volcengine/reactnative/vertc/VertcModule.java

@@ -0,0 +1,86 @@
+// Copyright © 2022 BytePlusRTC All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package com.volcengine.reactnative.vertc;
+
+import android.util.Log;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.Callback;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+import com.volcengine.VolcApiEngine.IEventReceiver;
+
+public class VertcModule extends NativeVertcSpec implements IEventReceiver {
+
+  public static final String TAG = "VertcModule";
+  private VertcImpl impl;
+  // unused yet.
+  private int listenerCount = 0;
+  public static ReactApplicationContext reactApplicationContext = null;
+
+  public VertcModule(ReactApplicationContext reactContext) {
+    super(reactContext);
+    ScreenCaptureHelper.registerReactApplicationContext(reactContext);
+    this.impl = new VertcImpl(reactContext, this);
+    reactApplicationContext = reactContext;
+    VertcApiEngineManager.instance.init(this.impl);
+    Log.d(TAG, "VertcModule init");
+  }
+  
+  @Override
+  public boolean newApiEngine() {
+    boolean res = this.impl.newApiEngine();
+    NativeVariableManager.init(this.impl.apiEngine.msgClient, reactApplicationContext);
+    Log.d(TAG, "ApiEngine init");
+    return res;
+  }
+
+  @Override
+  public void OnEvent(String event, String data) {
+    final WritableMap map = Arguments.createMap();
+    map.putString("event", event);
+    map.putString("data", data);
+    super.getReactApplicationContext()
+      .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+      .emit(VertcImpl.EVENT_NAME, map);
+  }
+
+  private void sendEvent(ReactContext reactContext, String eventName,
+                         @Nullable WritableMap params) {
+    reactContext
+      .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+      .emit(eventName, params);
+  }
+
+  @Override
+  public String callSync(String params) {
+    return impl.callApiSync(params);
+  }
+
+  @Override
+  public void call(String params, Callback callback) {
+    impl.callApi(params, callback);
+  }
+
+  @Override
+  public void addListener(String eventType) {
+    listenerCount += 1;
+  }
+
+  @Override
+  public void removeListeners(double count) {
+    listenerCount -= (int) count;
+  }
+
+  @Override
+  @NonNull
+  public String getName() {
+    return VertcImpl.NAME;
+  }
+}

package/android/src/{main/java → oldarch}/com/volcengine/reactnative/vertc/VertcModule.java

@@ -20,43 +20,38 @@ import com.ss.bytertc.engine.RTCVideo;
 import com.ss.bytertc.engine.engineimpl.RTCVideoImpl;
 import com.volcengine.VolcApiEngine.IEventReceiver;
 import com.volcengine.VolcApiEngine.VolcApiEngine;
-import com.volcengine.reactnative.vertc.events.ClassHelper;
 
 @ReactModule(name = VertcModuleSpec.NAME)
 public class VertcModule extends VertcModuleSpec implements IEventReceiver {
   public static ReactApplicationContext reactApplicationContext = null;
   
-  public VolcApiEngine apiEngine = null;
+  private VertcImpl impl;
 
   VertcModule(ReactApplicationContext context) {
     super(context);
-    VertcApiEngineManager.instance.init(this);
     reactApplicationContext = context;
+    ScreenCaptureHelper.registerReactApplicationContext(context);
+    this.impl = new VertcImpl(context, this);
+    VertcApiEngineManager.instance.init(this.impl);
   }
   
   @Override
   public String getName() {
-    return VertcModuleSpec.NAME;
+    return VertcImpl.NAME + "Module";
   }
 
   @ReactMethod(isBlockingSynchronousMethod = true)
   public boolean newApiEngine() {
-    if (apiEngine == null) {
-      apiEngine = new VolcApiEngine(super.context, this);
-      NativeVariableManager.init(this.apiEngine.msgClient, super.context);
-      ClassHelper.init();
-      return true;
-    }
-    
-    return false;
+    boolean res = this.impl.newApiEngine();
+    NativeVariableManager.init(this.impl.apiEngine.msgClient, context);
+    return res;
   }
 
   @ReactMethod(isBlockingSynchronousMethod = true)
   public String callApiSync(ReadableMap arg)  {
     try {
-      newApiEngine();
       String params = arg.getString("params");
-      return this.apiEngine.callApi(params);
+      return this.impl.callApiSync(params);
     } catch (Exception e) {
       e.printStackTrace();
       throw new RuntimeException(e);
@@ -66,10 +61,9 @@ public class VertcModule extends VertcModuleSpec implements IEventReceiver {
   @ReactMethod(isBlockingSynchronousMethod = false)
   public void callApi(ReadableMap arg, Callback callback)  {
     try {
-      newApiEngine();
       String params = arg.getString("params");
-      this.apiEngine.callApi(params, (res) -> {
-        callback.invoke(res.toJsonString());
+      this.impl.callApi(params, args -> {
+        callback.invoke(args);
       });
     } catch (Exception e) {
       e.printStackTrace();

package/ios/core/RTCHeader.h

@@ -10,6 +10,7 @@
 
 
 #import <BytePlusRTC/BytePlusRTC.h>
+#import <VolcEngineRTC/VolcEngineRTC.h>
 //#import <BytePlusRTC/objc/rtc/ByteRTCEngineKit.h>
 
 @interface RTCHandler : NSObject

package/ios/core/VertcHelper.h

@@ -7,7 +7,7 @@
 
 #import "RTCHeader.h"
 
-
+NS_ASSUME_NONNULL_BEGIN
 @interface VertcHelper : NSObject
 
 + (instancetype) getInstance;
@@ -19,5 +19,11 @@
                     error:(NSInteger)errorCode;
 
 - (int) invokeStartPushSingleStreamToCDN:(ByteRTCVideo *)rtc taskId:(NSString *_Nonnull)taskID singleStream:(ByteRTCPushSingleStreamParam *_Nonnull)singleStream;
-
-@end
+- (void)schedualTimerWithIdentifier:(NSString *)name
+                           interval:(NSTimeInterval)interval
+                              queue:(dispatch_queue_t)queue
+                            repeats:(BOOL)repeats
+                             action:(dispatch_block_t)action;
+- (void)cancelTimerWithName:(NSString *)name;
+@end
+NS_ASSUME_NONNULL_END

package/ios/core/VertcHelper.m

@@ -9,7 +9,10 @@
 #import "RTCHeader.h"
 #import <VertcHelper.h>
 
-
+@interface VertcHelper ()
+@property (nonatomic, strong) NSMutableDictionary *timerList;
+@property (nonatomic, strong) NSRecursiveLock *lock;
+@end
 #pragma mark - Helper
 @implementation VertcHelper
 
@@ -22,6 +25,14 @@
     return instance;
 }
 
+- (instancetype)init {
+    if (self = [super init]) {
+        self.timerList = [NSMutableDictionary dictionary];
+        self.lock = [[NSRecursiveLock alloc] init];
+    }
+    return self;
+}
+
 + (bool)isUnionLiveModeEnable {
     #ifdef ENABLE_UNION_FOR_RTC_WITH_LIVE
     return true;
@@ -46,4 +57,64 @@
     return res;
 }
 
+- (int)invokeSetAudioScene:(ByteRTCVideo *)rtc scene:(ByteRTCAudioSceneType)scene {
+    int res = [rtc setAudioScene:scene];
+    return res;
+}
+
+- (void)schedualTimerWithIdentifier:(NSString *)name
+                           interval:(NSTimeInterval)interval
+                              queue:(dispatch_queue_t)queue
+                            repeats:(BOOL)repeats
+                             action:(dispatch_block_t)action {
+    if (!name || name.length == 0 || !action) {
+        return;
+    }
+    [_lock lock];
+    if (!queue) {
+        queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
+    }
+    
+    dispatch_source_t timer = [self.timerList objectForKey:name];
+    if (!timer) {
+        timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, queue);
+        dispatch_resume(timer);
+        [self.timerList setValue:timer forKey:name];
+    }
+    
+    dispatch_source_set_timer(timer, dispatch_time(DISPATCH_TIME_NOW, interval * NSEC_PER_SEC), interval * NSEC_PER_SEC, 0.01 * NSEC_PER_SEC);
+    __weak __typeof(self)weakSelf = self;
+    dispatch_source_set_event_handler(timer, ^{
+        action();
+        __strong __typeof(weakSelf)self = weakSelf;
+        if (!repeats) {
+            [self cancelTimerWithName:name];
+        }
+    });
+    [_lock unlock];
+}
+
+- (void)cancelTimerWithName:(NSString *)name {
+    [_lock lock];
+    if (name == nil) {
+        [_lock unlock];
+        return;
+    }
+    dispatch_source_t timer = [self.timerList objectForKey:name];
+    if (timer) {
+        [self.timerList removeObjectForKey:name];
+        dispatch_source_cancel(timer);
+    }
+    [_lock unlock];
+}
+
+- (void)cancelAllTimers {
+    [_lock lock];
+    for (dispatch_source_t timer in self.timerList) {
+        dispatch_source_cancel(timer);
+    }
+    [self.timerList removeAllObjects];
+    [_lock unlock];
+}
 @end
+