Better video toggle with black frame sender

webrtc-android-framework/src/main/java/io/antmedia/webrtcandroidframework/api/IWebRTCClient.java

@@ -103,14 +103,15 @@ void publish(String streamId, String token, boolean videoCallEnabled, boolean au
 
     /**
      * This is used to join a conference room
-     * @param roomId: id for the conference room
-     * @param streamId: id for the participant
+     *
+     * @param roomId:           id for the conference room
+     * @param streamId:         id for the participant
      * @param videoCallEnabled: true if it's a video call
      * @param audioCallEnabled: true if it's an audio call
-     * @param token: token to authenticate
-     * @param subscriberId: id of the subscriber
-     * @param subscriberCode: code of the subscriber
-     * @param streamName: name of the stream
+     * @param token:            token to authenticate
+     * @param subscriberId:     id of the subscriber
+     * @param subscriberCode:   code of the subscriber
+     * @param streamName:       name of the stream
      */
     void joinToConferenceRoom(String roomId, String streamId, boolean videoCallEnabled, boolean audioCallEnabled, String token, String subscriberId, String subscriberCode, String streamName);
 
@@ -161,21 +162,26 @@ void publish(String streamId, String token, boolean videoCallEnabled, boolean au
 
     /**
      * Sets quality of a stream/subtrack to certain resolution.
+     *
      * @param mainTrackStreamId : If its a single stream pass its streamId as mainTrackId. If you want to change resolution of a subtrack, pass mainTrack stream Id and subtrack stream Id.
-     * @param subTrackStreamId : If you want to change resolution of sub track, pass its subTrack stream Id. If you dont want to change subtrack resolution pass null or empty str.
+     * @param subTrackStreamId  : If you want to change resolution of sub track, pass its subTrack stream Id. If you dont want to change subtrack resolution pass null or empty str.
      * @param resolutionHeight: The height to be forced. If you set the height to zero, it will become auto. example: For 720p pass 720 as resolution.
      */
     void forceStreamQuality(String mainTrackStreamId, String subTrackStreamId, int resolutionHeight);
 
     /**
-     * enable/disable video stream
+     * enable/disable video stream of call. Use this before call start.
+     * Eg if you call this method before call start with false, you wont be able to turn on video stream during call.
+     * For in call video sending toggle use toggleSendVideo
      *
      * @param enabled true for enable, false for disable
      */
     void setVideoEnabled(boolean enabled);
 
     /**
-     * enable/disable audio stream
+     * enable/disable audio stream of call.
+     * Use this before call start.
+     * For in call audio sending(for example muting microphone) toggle use toggleSendAudio
      *
      * @param enabled true for enable, false for disable
      */
@@ -184,11 +190,11 @@ void publish(String streamId, String token, boolean videoCallEnabled, boolean au
     /**
      * enable/disable played track stream from the server
      *
-     * @param streamId       id for the main track
-     * @param selecetedTrack id for the subtrack
-     * @param enabled        true for enable, false for disable
+     * @param streamId      id for the main track
+     * @param selectedTrack id for the subtrack
+     * @param enabled       true for enable, false for disable
      */
-    void enableTrack(String streamId, String selecetedTrack, boolean enabled);
+    void enableTrack(String streamId, String selectedTrack, boolean enabled);
 
     /**
      * Called to set the renderer for a video track
@@ -331,4 +337,35 @@ void publish(String streamId, String token, boolean videoCallEnabled, boolean au
      * Returns true if SDK resources are released and its shutdown, false otherwise.
      */
     boolean isShutdown();
+
+    /**
+     * Use this to get the local audio track status.
+     * E.g., if the microphone is off, it will return false. If the microphone is on, it will return true.
+     */
+    boolean isLocalAudioTrackEnabled();
+
+    /**
+     * Use this to toggle sending video during a call.
+     * E.g., turn the camera on or off during a call.
+     */
+    void toggleSendVideo(boolean enableVideo);
+
+    /**
+     * Use this to toggle sending audio during a call.
+     * E.g., call this with false to mute the microphone during a call.
+     */
+    void toggleSendAudio(boolean enableAudio);
+
+    /**
+     * Get the audio sending status.
+     * E.g., if the microphone is muted, it will return false; otherwise, it will return true.
+     */
+    boolean isSendAudioEnabled();
+
+    /**
+     * Get the video sending status.
+     * E.g., if the camera is turned off, it will return false; otherwise, it will return true.
+     */
+    boolean isSendVideoEnabled();
+
 }

webrtc-android-framework/src/main/java/io/antmedia/webrtcandroidframework/core/BlackFrameSender.java

@@ -0,0 +1,111 @@
+package io.antmedia.webrtcandroidframework.core;
+
+import android.os.SystemClock;
+
+import org.webrtc.*;
+
+import java.nio.ByteBuffer;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+
+
+public class BlackFrameSender {
+    public static int BLACK_FRAME_SENDING_FREQUENCY_MS = 3000;
+    private CustomVideoCapturer videoCapturer;
+    private ScheduledExecutorService executorService;
+    private boolean running;
+    private int frameWidth = 240;
+    private int frameHeight = 426;
+    private ByteBuffer yBuffer;
+    private ByteBuffer uBuffer;
+    private ByteBuffer vBuffer;
+
+    public BlackFrameSender(CustomVideoCapturer videoCapturer) {
+        this.videoCapturer = videoCapturer;
+        allocateBlackFrameBuffers();
+    }
+
+    public void start(){
+        if(executorService == null){
+            executorService = Executors.newScheduledThreadPool(1);
+            executorService.scheduleWithFixedDelay(() -> {
+
+                try{
+                    videoCapturer.writeFrame(createBlackFrame());
+                }catch (Exception e){
+                    e.printStackTrace();
+                }
+
+            }, 0, BLACK_FRAME_SENDING_FREQUENCY_MS, TimeUnit.MILLISECONDS);
+            running = true;
+        }
+
+
+    }
+    public void stop(){
+        if(executorService != null){
+            executorService.shutdown();
+            executorService = null;
+            running = false;
+            releaseByteBuffers();
+        }
+    }
+
+    public void releaseByteBuffers(){
+        if (yBuffer != null) {
+            yBuffer.clear();
+            yBuffer = null;
+        }
+        if (uBuffer != null) {
+            uBuffer.clear();
+            uBuffer = null;
+        }
+        if (vBuffer != null) {
+            vBuffer.clear();
+            vBuffer = null;
+        }
+    }
+
+    public boolean isRunning(){
+        return running;
+    }
+
+    //capture time needs to be incremented. Otherwise server does not ingest the stream.
+    public VideoFrame createBlackFrame() {
+        long captureTimeNs = TimeUnit.MILLISECONDS.toNanos(SystemClock.elapsedRealtime());
+        return new VideoFrame(createBlackFrameBuffer(), 0, captureTimeNs);
+    }
+
+    public void allocateBlackFrameBuffers(){
+
+        int ySize = frameWidth * frameHeight;
+        int uvWidth = frameWidth / 2;
+        int uvHeight = frameHeight / 2;
+        int uvSize = uvWidth * uvHeight;
+
+         yBuffer = ByteBuffer.allocateDirect(ySize);
+         uBuffer = ByteBuffer.allocateDirect(uvSize);
+         vBuffer = ByteBuffer.allocateDirect(uvSize);
+
+        for (int i = 0; i < ySize; i++) {
+            yBuffer.put((byte) 0);
+        }
+
+        for (int i = 0; i < uvSize; i++) {
+            uBuffer.put((byte) 128);
+            vBuffer.put((byte) 128);
+        }
+
+        yBuffer.flip();
+        uBuffer.flip();
+        vBuffer.flip();
+
+    }
+
+    public JavaI420Buffer createBlackFrameBuffer(){
+        int uvWidth = frameWidth / 2;
+        return JavaI420Buffer.wrap(frameWidth, frameHeight, yBuffer, frameWidth, uBuffer, uvWidth, vBuffer, uvWidth, null);
+    }
+
+}

webrtc-android-framework/src/main/java/io/antmedia/webrtcandroidframework/core/WebRTCClient.java

@@ -245,6 +245,13 @@ public void setQueuedRemoteCandidates(List<IceCandidate> queuedRemoteCandidates)
 
     private String roomId;
 
+    private BlackFrameSender blackFrameSender;
+
+    private boolean sendVideoEnabled = true;
+
+    private boolean sendAudioEnabled = true;
+
+
     public void createReconnectorRunnables() {
         //only used in conference.
         publishReconnectorRunnable = () -> {
@@ -387,6 +394,8 @@ public WebRTCClient(WebRTCClientConfig config) {
         mainHandler = new Handler(config.activity.getMainLooper());
         iceServers.add(PeerConnection.IceServer.builder(config.stunServerUri)
                 .createIceServer());
+        sendAudioEnabled = config.audioCallEnabled;
+        sendVideoEnabled = config.videoCallEnabled;
 
         if(config.turnServerUri != null) {
             iceServers.add(PeerConnection.IceServer.builder(config.turnServerUri)
@@ -974,7 +983,7 @@ private void publishPlayIfRequested() {
 
     public void publish(String streamId) {
         publish(streamId, null, true, true,
-                null, null, streamId, "qdadsas");
+                null, null, streamId, null);
     }
 
 
@@ -2175,13 +2184,16 @@ public void closeInternal() {
             eglBase.release();
             eglBase = null;
         }
+        if(blackFrameSender != null){
+            blackFrameSender.stop();
+            blackFrameSender = null;
+        }
 
         localVideoSink.setTarget(null);
 
         Log.d(TAG, "Closing peer connection done.");
         onPeerConnectionClosed();
 
-
         clearStatsCollector();
         reconnectionInProgress = false;
         peerReconnectionHandler.removeCallbacksAndMessages(null);
@@ -2248,6 +2260,36 @@ public void setVideoEnabled(final boolean enable) {
         });
     }
 
+    public void toggleSendAudio(boolean enableAudio) {
+        executor.execute(() -> {
+            sendAudioEnabled = enableAudio;
+            if (localAudioTrack != null) {
+                localAudioTrack.setEnabled(enableAudio);
+            }
+        });
+    }
+
+    public void toggleSendVideo(boolean enableVideo) {
+        if(!config.videoCallEnabled){
+            Log.i(TAG, "Cannot change send video because video call is disabled.");
+            return;
+        }
+        executor.execute(() -> {
+            sendVideoEnabled = enableVideo;
+            if (enableVideo) {
+                if(blackFrameSender != null && blackFrameSender.isRunning()){
+                    blackFrameSender.stop();
+                    blackFrameSender = null;
+                }
+                changeVideoSource(StreamSource.FRONT_CAMERA);
+            } else {
+                changeVideoSource(StreamSource.CUSTOM);
+                blackFrameSender = new BlackFrameSender((CustomVideoCapturer) getVideoCapturer());
+                blackFrameSender.start();
+            }
+        });
+    }
+
     public void createOffer(String streamId) {
 
         executor.execute(() -> {
@@ -2719,6 +2761,20 @@ public void toggleAudioOfAllParticipants(boolean enabled) {
         }
     }
 
+    public boolean isLocalVideoTrackEnabled(){
+        if(localVideoTrack == null){
+            return false;
+        }
+        return localVideoTrack.enabled();
+    }
+
+    public boolean isLocalAudioTrackEnabled(){
+        if(localAudioTrack == null){
+            return false;
+        }
+        return localAudioTrack.enabled();
+    }
+
     public void setHandler(Handler handler) {
         this.handler = handler;
     }
@@ -2742,6 +2798,10 @@ public VideoCapturer getVideoCapturer() {
         return videoCapturer;
     }
 
+    public void setVideoCapturer(VideoCapturer videoCapturer){
+        this.videoCapturer = videoCapturer;
+    }
+
     public void setRemoveVideoRotationExtension(boolean removeVideoRotationExtension) {
         this.removeVideoRotationExtension = removeVideoRotationExtension;
     }
@@ -2778,4 +2838,27 @@ public boolean isShutdown() {
         return released;
     }
 
+    @Override
+    public boolean isSendVideoEnabled() {
+        return sendVideoEnabled;
+    }
+
+    @Override
+    public boolean isSendAudioEnabled() {
+        return sendAudioEnabled;
+    }
+
+    public BlackFrameSender getBlackFrameSender() {
+        return blackFrameSender;
+    }
+
+    @androidx.annotation.Nullable
+    public AudioTrack getLocalAudioTrack() {
+        return localAudioTrack;
+    }
+
+    public void setLocalAudioTrack(@androidx.annotation.Nullable AudioTrack localAudioTrack) {
+        this.localAudioTrack = localAudioTrack;
+    }
+
 }