@byteplus/react-native-rtc 1.0.3 → 1.0.5

package/README.md

@@ -21,7 +21,7 @@ yarn add @byteplus/react-native-rtc
 
 ## Basic Example
 
-### Core Call Definition
+### RTC Core Definition
 `@/core/index.ts`
 
 ```typescript
@@ -83,15 +83,14 @@ class RTCClient {
 export default new RTCClient();
 ```
 
-### Base JoinRoom Page
+### JoinRoom Page
 `@/page/login.tsx`
 
-
 Mainly focus on the usage of `NativeViewComponent`. Note that after the component is registered, call `setLocalVideoCanvas` in `onLoad` to set the local rendering view. The same applies to remote users.
 ```typescript
 import { Platform } from 'react-native';
-import { NativeViewComponent, StreamIndex, RenderMode } from '@byteplus/react-native-rtc';
 import { request, PERMISSIONS } from 'react-native-permissions';
+import { NativeViewComponent, StreamIndex, RenderMode } from '@byteplus/react-native-rtc';
 import RTCClient from '@/core';
 
 const viewId = 'my-view';
@@ -173,6 +172,314 @@ const Login = () => {
 export default Login;
 ```
 
+## On-Demand Video with Real-Time Guest Interaction Example
+
+**We recommend using the latest RTC React Native SDK version in combination with react-native-vod-player SDK v1.2.4.**
+
+
+### RTC Core Definition
+`@/core/index.ts`
+
+Based on the rtc core definition in `Basic Example`, add some apis:
+```typescript
+...
+import type { TTVideoEngine } from '@byteplus/react-native-vod-player';
+
+class RTCClient {
+
+    ...
+
+    /**
+     * @brief Start to observe vod player, capture frames from vod player and set stream for external screen stream.
+     */
+    startVodPlayerCapture(player: TTVideoEngine) {
+        return this.engine?.startVodPlayerCapture(player);
+    }
+
+    /**
+     * @brief Stop all vod player observer in rtc.
+     * @note Once you invoke this api, you should invoke `startVodPlayerCapture` to observe vod player.
+     */
+    stopVodPlayerCapture(player: TTVideoEngine) {
+        return this.engine?.stopVodPlayerCapture(player);
+    }
+}
+```
+### Main logic page in react-native
+`@/page/vodRtc.ts`
+
+```typescript
+import React, {useEffect, useRef, useState} from 'react';
+import fs from 'react-native-fs';
+import {Platform, SafeAreaView, ScrollView} from 'react-native';
+import {Button, Input, Text, Toast, View} from '@ant-design/react-native';
+import {
+  NativeViewComponent,
+  StreamIndex,
+  RenderMode,
+  MediaStreamType,
+  LocalLogLevel,
+} from '@byteplus/react-native-rtc';
+import {
+  createDirectUrlSource,
+  type TTVideoEngine,
+} from '@byteplus/react-native-vod-player';
+import {
+  launchImageLibrary,
+  type ImagePickerResponse,
+} from 'react-native-image-picker';
+import RTCClient from '@/core';
+import { createVeplayer } from '@/core/veplayer';
+import RowItem from '@/components/RowItem';
+import {GlobalStyles} from '@/style';
+
+const viewId = 'my-view';
+
+const auth = {
+  appId: 'Your RTC AppID',
+  roomId: 'Your Room ID',
+  userId: 'Your User ID',
+  token: 'Your RTC Token',
+};
+
+const Page = () => {
+  const [isViewLoaded, setViewLoaded] = useState<boolean>(false);
+  const [filepath, setFilepath] = useState('');
+  const hasCaptureRef = useRef(false);
+  const playerRef = useRef<TTVideoEngine>();
+
+  const handleViewLoad = () => {
+    setViewLoaded(true);
+  };
+
+  const handleSelectVideoFile = async () => {
+    try {
+      const callback = (response: ImagePickerResponse) => {
+        if (!response.didCancel && !response.errorCode) {
+          const filePath = response.assets?.[0]?.uri;
+          if (filePath) {
+            setFilepath(filePath);
+          }
+        }
+      };
+      launchImageLibrary(
+        {
+          mediaType: 'video',
+        },
+        callback,
+      );
+    } catch {
+      Toast.fail('Select media file failed.');
+    }
+  };
+
+  const handlePublish = () => {
+    RTCClient.publishScreen(MediaStreamType.RTC_MEDIA_STREAM_TYPE_BOTH);
+  };
+
+  const setVideoSource = () => {
+    const source = filepath
+      ? createDirectUrlSource({
+          url: filepath,
+          cacheKey: filepath,
+        })
+      : createDirectUrlSource({
+          url: 'Your media url, like https://xxxx.mp4',
+          cacheKey: 'remote',
+          vid: 'remote',
+        });
+    playerRef.current!.setVideoSource(source);
+  };
+
+  const handlePlay = async () => {
+    if (hasCaptureRef.current) {
+      playerRef.current!.play();
+      return;
+    }
+    if (!playerRef.current) {
+      return;
+    }
+    setVideoSource();
+    await RTCClient.startVodPlayerCapture(playerRef.current);
+    await playerRef.current!.play();
+
+    RTCClient.publishScreen(MediaStreamType.RTC_MEDIA_STREAM_TYPE_BOTH);
+    
+    hasCaptureRef.current = true;
+  };
+
+  const handleStop = async () => {
+    if (hasCaptureRef.current) {
+      playerRef.current!.pause();
+    }
+  }
+
+  const handleDestroy = async () => {
+    if (!playerRef.current) {
+      return;
+    }
+    await RTCClient.stopVodPlayerCapture(playerRef.current);
+    hasCaptureRef.current = false;
+  }
+
+  const initializePlayer = async () => {
+    /**
+     * @brief It's not necessary to set viewId for vod player.
+     * @note You should realize veplayer for youself, refer to @byteplus/react-native-vod-player SDK.
+     */
+    playerRef.current = await createVeplayer({ viewId: '' });
+    playerRef.current.setListener({
+      onLoadStateChanged(engine, loadState) {
+        console.log('onLoadStateChanged: ', loadState);
+      },
+      onError(message, code) {
+        console.error('onError: ', message, code);
+      },
+      onPlaybackStateChanged(engine, playbackState) {
+        console.log('onPlaybackStateChanged: ', playbackState);
+      },
+    });
+  };
+
+  const initializeRTC = async () => {
+    /** Init your engine */
+    let DefaultPath = fs.ExternalDirectoryPath;
+    if (Platform.OS === 'ios') {
+      DefaultPath = fs.DocumentDirectoryPath;
+    }
+
+    /** Set log */
+    RTCClient.setLogConfig({
+      logLevel: LocalLogLevel.INFO,
+      logPath: DefaultPath,
+      logFileSize: 10,
+      logFilenamePrefix: '',
+    });
+
+    /** Create RTC Engine */
+    await RTCClient.createEngine({
+      appID: auth.appId,
+      parameters: {},
+    });
+
+    /** Set Local video canvas for player */
+    RTCClient.setLocalVideoCanvas(StreamIndex.STREAM_INDEX_SCREEN, {
+      viewId,
+      renderMode: RenderMode.ByteRTCRenderModeFit,
+    });
+
+    /** Join room */
+    RTCClient.createRoom(auth.roomId);
+    RTCClient.setRTCRoomEventHandler({
+      onUserJoined(userInfo, elapsed) {
+        console.log('onUserJoined: ', userInfo, elapsed);
+      },
+    });
+    RTCClient.joinRoom({
+      token: auth.token,
+      userId: auth.userId,
+      roomConfigs: {
+        profile: 0,
+        isAutoPublish: true,
+        isAutoSubscribeAudio: false,
+        isAutoSubscribeVideo: false,
+      },
+    });
+  };
+
+  useEffect(() => {
+    if (isViewLoaded) {
+      initializeRTC();
+      initializePlayer();
+      console.log('init success');
+    }
+  }, [isViewLoaded]);
+
+  useEffect(() => {
+    return () => {
+      RTCClient.engine?.stopVodPlayerCapture(playerRef.current);
+    }
+  }, []);
+
+  return (
+    <SafeAreaView>
+      <ScrollView
+        style={{
+          display: 'flex',
+          flexDirection: 'column',
+          width: '100%',
+          height: '100%',
+          backgroundColor: 'gray',
+        }}>
+        <RowItem
+          theme="dark"
+          leftItem="File path"
+          leftItemStyle={{width: '25%'}}
+          rightItem={
+            <Input disabled placeholder="Select media file" value={filepath} />
+          }
+        />
+        <Button
+          style={{...GlobalStyles.rowBtn, marginBottom: 6}}
+          onPress={handleSelectVideoFile}>
+          <Text style={{color: 'gray'}}>Select media file</Text>
+        </Button>
+        <Button
+          style={{...GlobalStyles.rowBtn, marginBottom: 6}}
+          onPress={() => setFilepath('')}>
+          <Text style={{color: 'gray'}}>Clear media file</Text>
+        </Button>
+        <Button
+          style={{...GlobalStyles.rowBtn, marginBottom: 6}}
+          onPress={handlePublish}>
+          <Text style={{color: 'gray'}}>Push Stream</Text>
+        </Button>
+        <Button
+          style={{...GlobalStyles.rowBtn, marginBottom: 6}}
+          onPress={handlePlay}>
+          <Text style={{color: 'gray'}}>Play</Text>
+        </Button>
+        <Button
+          style={{...GlobalStyles.rowBtn, marginBottom: 6}}
+          onPress={handleStop}>
+          <Text style={{color: 'gray'}}>Pause</Text>
+        </Button>
+        <Button
+          style={{...GlobalStyles.rowBtn, marginBottom: 6}}
+          onPress={handleDestroy}>
+          <Text style={{color: 'gray'}}>Destroy</Text>
+        </Button>
+        <View
+          style={{
+            flex: 1,
+            width: '100%',
+            minHeight: 300,
+            backgroundColor: '#000',
+          }}>
+          <Text>{`${viewId}`}</Text>
+          <NativeViewComponent
+            viewId={viewId}
+            style={{
+              width: '100%',
+              height: '100%',
+            }}
+            onLoad={handleViewLoad}
+            kind={
+              Platform.select({
+                android: 'SurfaceView',
+                ios: 'UIView',
+              })!
+            }
+          />
+        </View>
+      </ScrollView>
+    </SafeAreaView>
+  );
+};
+
+export default Page;
+```
+
 
 ## Attention
 - In Android/iOS scenarios, the screen sharing method is slightly different. For details, please refer to [Android screen sharing](https://docs.byteplus.com/en/docs/byteplus-rtc/docs-124176) and [iOS screen sharing](https://docs.byteplus.com/en/docs/byteplus-rtc/docs-124177).

package/android/build.gradle

@@ -14,7 +14,6 @@ def isNewArchitectureEnabled() {
 }
 
 apply plugin: "com.android.library"
-apply from: "https://ve-vos.volccdn.com/script/vevos-repo-base.gradle"
 
 if (isNewArchitectureEnabled()) {
   apply plugin: "com.facebook.react"
@@ -52,11 +51,16 @@ def getNativeDep() {
   def parsedJson = new groovy.json.JsonSlurper().parseText(packageJson.text)
   def isBp = parsedJson.name.startsWith("@byteplus")
 
+  def enableUnionForRTCWithLive = rootProject.ext.has('enableUnionForRTCWithLive') ? rootProject.ext.get('enableUnionForRTCWithLive') : false
+  def rtcVersionToUse
   if (isBp) {
-    return "com.byteplus:BytePlusRTC:3.58.1.15100"
+    rtcVersionToUse = enableUnionForRTCWithLive ? "3.58.1.20600" : "3.58.1.15100"
+    println "Using BytePlusRTC SDK version : $rtcVersionToUse (union build enabled: $enableUnionForRTCWithLive)"
+    return "com.byteplus:BytePlusRTC:$rtcVersionToUse"
   }
-
-  return "com.volcengine:VolcEngineRTC:3.58.1.2700"
+  rtcVersionToUse = enableUnionForRTCWithLive ? "3.58.1.20700" : "3.58.1.2700"
+  println "Using VolcEngineRTC SDK version : $rtcVersionToUse (union build enabled: $enableUnionForRTCWithLive)"
+  return "com.volcengine:VolcEngineRTC:$rtcVersionToUse"
 }
 
 android {
@@ -95,46 +99,23 @@ android {
   }
 }
 
-// repositories {
-//   mavenCentral()
-//   google()
-//   maven {
-//     // url "https://artifact.bytedance.com/repository/Volcengine/" // volc public maven repo
-//   }
-// }
-
-
-allprojects {
-  repositories {
-    maven { 
-      url 'https://artifact.byteplus.com/repository/public/' // byteplus public maven repo 
-    }
-    google()
-    mavenCentral()
-    maven {
-      url "https://artifact.bytedance.com/repository/Volcengine/" // volc public maven repo
-    }
-  }
-}
-
 dependencies {
   // For < 0.71, this will be from the local maven repo
   // For > 0.71, this will be replaced by `com.facebook.react:react-android:$version` by react gradle plugin
   // noinspection GradleDynamicVersion
   implementation "com.facebook.react:react-native:+"
 
-  implementation "com.volcengine:VolcApiEngine:1.5.0"
+  implementation "com.volcengine:VolcApiEngine:1.6.2"
 //   implementation project(":hybrid-runtime");
 
-//  def dep = getNativeDep()
-//  implementation "$dep"
-  // implementation "com.volcengine:VolcEngineRTC:3.58.1.2700"
-  implementation "com.byteplus:BytePlusRTC:3.58.1.15100"
+  // Use the RTC SDK dependency determined by getNativeDep() which can be overridden by customer's app build.gradle.
+  def rtcDep = getNativeDep()
+  implementation rtcDep
 
   // TTVideoEngine
   // byteplus and volcengine use different name, different version
   // volcengine     com.bytedanceapi:ttsdk-player_premium:1.43.1.5      com.bytedanceapi:ttsdk-player_standard:1.43.1.5
-  // byteplus       com.bytedanceapi:ttsdk-player_premium:1.42.300.101  com.bytedanceapi:ttsdk-player_standard:1.42.300.101 
+  // byteplus       com.bytedanceapi:ttsdk-player_premium:1.42.300.101  com.bytedanceapi:ttsdk-player_standard:1.42.300.101
   def license_type = getLicenseType()
   implementation "com.bytedanceapi:ttsdk-player_$license_type:1.+"
-}
+}

package/android/src/main/java/com/volcengine/reactnative/vertc/VertcHelper.java

@@ -0,0 +1,24 @@
+// Copyright © 2022 BytePlusRTC All rights reserved.
+// SPDX-License-Identifier: MIT
+
+package com.volcengine.reactnative.vertc;
+
+import android.util.Log;
+
+import com.ss.bytertc.engine.RTCVideo;
+import com.ss.bytertc.engine.VideoEncoderConfig;
+
+public class VertcHelper {
+
+  static public VertcHelper sInstance = new VertcHelper();
+
+  public static VertcHelper getInstance() {
+    Log.d("VertcHelper", "channelSolutions" + sInstance);
+    return sInstance;
+  }
+  
+  public int invokeSetVideoEncoderConfig(RTCVideo engine, VideoEncoderConfig[] channelSolutions) {
+    Log.d("VertcHelper", "channelSolutions");
+    return engine.setVideoEncoderConfig(channelSolutions);
+  }
+}

package/android/src/main/java/com/volcengine/reactnative/vertc/vod/VertcVod.java

@@ -21,9 +21,11 @@ public class VertcVod {
   private String TAG = "VertcVod";
 
   private TTVideoEngine mVideoEngine;
+  private org.json.JSONObject mOptions;
   
   private int mVideoWidth = 1080;
   private int mVideoHeight = 1920;
+  private VodVideoEngineCallbackProxy mVodVideoEngineCallbackProxy;
   private OESTextureProcessor mOESTextureProcessor;
   private VideoAudioProcessor mVAProcessor;
   private final OESTextureProcessor.IProcessorCallback mProcessorCallback = new OESTextureProcessor.IProcessorCallback() {
@@ -45,25 +47,28 @@ public class VertcVod {
 
     @Override
     public void onFrameAvailable(EGLContext eglContext, int oesTextureId, float[] transformMatrix, int width, int height, long timestamp) {
-      mVAProcessor.onFrameAvailable(eglContext, oesTextureId, transformMatrix, width, height);
+      mVAProcessor.onFrameAvailable(eglContext, oesTextureId, transformMatrix, width, height, timestamp);
     }
   };
 
-  public int startVodPlayerCapture(RTCVideo engine, Object arg, StreamIndex streamIndex) {
+  public int startVodPlayerCapture(RTCVideo engine, Object ttplayer, org.json.JSONObject options) {
     try {
-      mVideoEngine = getTTVideoEngine(arg);
+      stopVodPlayerCapture(engine);
+
+      mVideoEngine = getTTVideoEngine(ttplayer);
       if (mVideoEngine == null) {
         throw new RuntimeException("unknown VideoEngine");
       }
-      stopVodPlayerCapture(engine);
+      
+      mOptions = options;
+      mVAProcessor = new VideoAudioProcessor(engine, options);
 
-      mVAProcessor = new VideoAudioProcessor(engine);
-      var mVideoEngineCallback = new VideoEngineCallback() {
+      // process TTVideoEngine video
+      VideoEngineCallback mVideoEngineCallback = new VideoEngineCallback() {
         @Override
         public void onRenderStart(TTVideoEngine engine) {
           final int videoWidth = engine.getVideoWidth();
           final int videoHeight = engine.getVideoHeight();
-          Log.d(TAG, "onRenderStart: " + videoWidth + "x" + videoHeight);
           mVideoWidth = videoWidth;
           mVideoHeight = videoHeight;
 
@@ -75,35 +80,46 @@ public class VertcVod {
           mOESTextureProcessor.initSurfaceTexture(videoWidth, videoHeight, mProcessorCallback);
         }
       };
-      mVideoEngine.configResolution(Resolution.High);
-      mVideoEngine.setVideoEngineCallback(mVideoEngineCallback);
+      mVodVideoEngineCallbackProxy = new VodVideoEngineCallbackProxy(mVideoEngine, mVideoEngineCallback);
+      mVideoEngine.setVideoEngineCallback(mVodVideoEngineCallbackProxy.listen());
+      // process TTVideoEngine audio
       mVideoEngine.setAudioProcessor(mVAProcessor);
       mVideoEngine.setIntOption(TTVideoEngine.PLAYER_OPTION_SET_VOICE, TTVideoEngine.VOICE_DUMMY);
       mVideoEngine.setIntOption(TTVideoEngine.PLAYER_OPTION_DUMMY_AUDIO_SLEEP, 0);
 
+      // set sourceType to External
       engine.setScreenAudioSourceType(AudioSourceType.AUDIO_SOURCE_TYPE_EXTERNAL);
       engine.setVideoSourceType(StreamIndex.STREAM_INDEX_SCREEN, VideoSourceType.VIDEO_SOURCE_TYPE_EXTERNAL);
-//
+
       OESTextureProcessor textureProcessor = mOESTextureProcessor;
       if (textureProcessor != null) {
         textureProcessor.destroy();
       }
       mOESTextureProcessor = new OESTextureProcessor();
-      mOESTextureProcessor.initSurfaceTexture(1080, 1920, mProcessorCallback);
+      mOESTextureProcessor.initSurfaceTexture(mVideoWidth, mVideoHeight, mProcessorCallback);
       
       return 0;
     } catch (Exception err) {
-      Log.d(TAG, "error:" + err.getMessage());
+      Log.d(TAG, "startVodPlayerCapture fail:" + err.getMessage());
       throw new RuntimeException(err);
     }
   }
 
   public int stopVodPlayerCapture(RTCVideo engine) {
+    // reset sourceType to Internal
     engine.setVideoSourceType(StreamIndex.STREAM_INDEX_SCREEN, VideoSourceType.VIDEO_SOURCE_TYPE_INTERNAL);
+    engine.setScreenAudioSourceType(AudioSourceType.AUDIO_SOURCE_TYPE_INTERNAL);
+    mOptions = null;
+    if (mVodVideoEngineCallbackProxy != null) {
+      mVodVideoEngineCallbackProxy.reset(mVideoEngine);
+      mVodVideoEngineCallbackProxy = null;
+    }
     if (mVideoEngine != null) {
-      mVideoEngine.setSurfaceHolder(null);
+      mVideoEngine.setSurface(null);
       mVideoEngine.setAudioProcessor(null);
       mVideoEngine.setVideoEngineCallback(null);
+      mVideoEngine.stop();
+      mVideoEngine = null;
     }
     if (mOESTextureProcessor != null) {
       mOESTextureProcessor.destroy();

package/android/src/main/java/com/volcengine/reactnative/vertc/vod/VideoAudioProcessor.java

@@ -20,14 +20,16 @@ import java.nio.ByteBuffer;
 import java.util.concurrent.TimeUnit;
 
 public class VideoAudioProcessor extends AudioProcessor {
-  public String TAG = "VideoAudioProcessor";
-  
-  private final VodAudioProcessor processor;
-    private final RTCVideo mRTCEngine;
+    public String TAG = "VideoAudioProcessor";
 
-    public VideoAudioProcessor(RTCVideo engine) {
+    private org.json.JSONObject mOptions;
+    private final VodAudioProcessor processor;
+    private final RTCVideo mRTCEngine;
+    
+    public VideoAudioProcessor(RTCVideo engine, org.json.JSONObject options) {
         processor = new VodAudioProcessor(engine);
         mRTCEngine = engine;  
+        mOptions = options;
     }
    
     public void updateScreenConfig(int width, int height) {
@@ -38,7 +40,6 @@ public class VideoAudioProcessor extends AudioProcessor {
         videoEncoderConfig.height = height;
         videoEncoderConfig.encodePreference = ScreenVideoEncoderConfig.EncoderPreference.MaintainFramerate;
         mRTCEngine.setScreenVideoEncoderConfig(videoEncoderConfig);
-//        mRTCEngine.publishScreen(RTCEngine.MediaStreamType.RTC_MEDIA_STREAM_TYPE_BOTH);
     }
 
     @Override
@@ -53,7 +54,6 @@ public class VideoAudioProcessor extends AudioProcessor {
 
     @Override
     public void audioClose() {
-
     }
 
     @Override
@@ -61,16 +61,14 @@ public class VideoAudioProcessor extends AudioProcessor {
 
     }
 
-    public void onFrameAvailable(EGLContext eglContext, int oesTextureId, float[] transformMatrix, int width, int height) {
-     long nanoTime = System.currentTimeMillis() * TimeUnit.MILLISECONDS.toNanos(1);
+    public void onFrameAvailable(EGLContext eglContext, int oesTextureId, float[] transformMatrix, int width, int height, long timestamp) {
      GLTextureVideoFrameBuilder builder = new GLTextureVideoFrameBuilder(VideoPixelFormat.TEXTURE_OES)
        .setTextureID(oesTextureId)
        .setWidth(width)
        .setHeight(height)
        .setRotation(VideoRotation.VIDEO_ROTATION_0)
        .setTextureMatrix(transformMatrix)
-       .setTimeStampUs(nanoTime)
-       .setColorSpace(ColorSpace.UNKNOWN)
+       .setTimeStampUs(timestamp)
        .setEGLContext(eglContext);
      int ret_status = mRTCEngine.pushScreenVideoFrame(builder.build());
      boolean result = ret_status == ReturnStatus.RETURN_STATUS_SUCCESS.value()

package/android/src/main/java/com/volcengine/reactnative/vertc/vod/VodMock.java

@@ -5,36 +5,47 @@ package com.volcengine.reactnative.vertc.vod;
 
 import android.os.Handler;
 import android.os.Looper;
-import android.util.Log;
 
 import com.ss.bytertc.engine.RTCVideo;
+import com.ss.bytertc.engine.data.AudioSourceType;
+import com.ss.bytertc.engine.data.StreamIndex;
 import com.ss.bytertc.engine.data.VideoPixelFormat;
 import com.ss.bytertc.engine.data.VideoRotation;
+import com.ss.bytertc.engine.data.VideoSourceType;
 import com.ss.bytertc.engine.video.VideoFrame;
 import com.ss.bytertc.engine.video.builder.CpuBufferVideoFrameBuilder;
 
 import java.nio.ByteBuffer;
 import java.util.concurrent.TimeUnit;
 
+// For Test pushScreenVideoFrame
 public class VodMock {
-  public String TAG = "VideoAudioProcessor";
+  public String TAG = "VodMockTest";
 
   private final RTCVideo mRTCEngine;
+  private final int mFps;
 
   public VodMock(RTCVideo engine) {
     mRTCEngine = engine;
+    mFps = 30;
   }
   
-  public void useFakeVideoFrame() {
+  public void start() {
+    mRTCEngine.setScreenAudioSourceType(AudioSourceType.AUDIO_SOURCE_TYPE_EXTERNAL);
+    mRTCEngine.setVideoSourceType(StreamIndex.STREAM_INDEX_SCREEN, VideoSourceType.VIDEO_SOURCE_TYPE_EXTERNAL);
+    useFakeVideoFrame();
+  }
+  
+  private void useFakeVideoFrame() {
     final Handler handler = new Handler(Looper.getMainLooper());
     var width = 998;
     var height = 554;
     Runnable runnable = new Runnable() {
       @Override
       public void run() {
-        handler.postDelayed(this, 30);  // Repeats every 5 seconds
+        handler.postDelayed(this, 1000 / mFps); 
 
-        var frame = useInternalVideoFrame(width, height);
+        var frame = buildInternalVideoFrame(width, height);
         mRTCEngine.pushScreenVideoFrame(frame);
 //        Log.d(TAG, "pushScreenVideoFrame");
       }
@@ -42,7 +53,7 @@ public class VodMock {
     handler.post(runnable);
   }
 
-  public VideoFrame useInternalVideoFrame(int width, int height){
+  private VideoFrame buildInternalVideoFrame(int width, int height){
     int chromaWidth = (width + 1) / 2;
     int chromaHeight = (height + 1) /2;
     int uvSize = chromaWidth * chromaHeight;