DocumentationServer APICode SamplesSDK Downloads ↗Discord ↗
quickblox.com ↗Support ↗Log In ↗

Advanced

Learn how to mute audio, disable video, switch camera, share your screen, configure media settings, etc.

Suggest Edits

Media management

To manage audio & video streams QBRTCSession provides QBMediaStreamManager class.
QBMediaStreamManager holds a user's local audio & video tracks and provides a way to change the video capturer.

🚧

QBMediaStreamManager is attached to QBRTCSession lifecycle. According to QBRTCSession lifecycle, you should use QBMediaStreamManager only when QBRTCSession is active or has been started.

Mute audio

Mute the audio by calling setEnabled() or setAudioEnabled() method. Using these methods, we can tell SDK to send/not send audio data either from a local or remote peer in the specified call session.

QBMediaStreamManager mediaStreamManager = currentSession.getMediaStreamManager();
        
QBRTCAudioTrack localAudioTrack = mediaStreamManager.getLocalAudioTrack();
        
// mute
localAudioTrack.setEnabled(false);
// or
mediaStreamManager.setAudioEnabled(false);

// unmute
localAudioTrack.setEnabled(true);
// or
mediaStreamManager.setAudioEnabled(true);

// is muted?
boolean isEnabled = localAudioTrack.enabled();
// or 
mediaStreamManager.isAudioEnabled();

val mediaStreamManager = currentSession.mediaStreamManager

val localAudioTrack = mediaStreamManager.localAudioTrack

// mute
localAudioTrack.setEnabled(false)
// or
mediaStreamManager.isAudioEnabled = false

// unmute
localAudioTrack.setEnabled(true)
// or
mediaStreamManager.isAudioEnabled = true

// is muted?
val isEnabled = localAudioTrack.enabled()
// or
mediaStreamManager.isAudioEnabled

Disable video

Turn off the video by calling setEnabled() or setVideoEnabled() method. Using these methods, we can tell SDK not to send video data either from a local or remote peer in the specified call session.

QBMediaStreamManager mediaStreamManager = currentSession.getMediaStreamManager();

QBRTCVideoTrack localVideoTrack = mediaStreamManager.getLocalVideoTrack();

// enable
localVideoTrack.setEnabled(false);
// or
mediaStreamManager.setVideoEnabled(false);

// disable
localVideoTrack.setEnabled(true);
// or
mediaStreamManager.setVideoEnabled(true);

// is enabled?
boolean isEnabled = localVideoTrack.enabled();
// or
mediaStreamManager.isVideoEnabled();

val mediaStreamManager = currentSession.mediaStreamManager

val localVideoTrack = mediaStreamManager.localVideoTrack

// enable
localVideoTrack.setEnabled(false)
// or
mediaStreamManager.isVideoEnabled = false

// disable
localVideoTrack.setEnabled(true)
// or
mediaStreamManager.isVideoEnabled = true

// is Enabled?
val isEnabled = localVideoTrack.enabled()
// or 
mediaStreamManager.isVideoEnabled

Capture video from camera

When a call session is started, the Camera Capturer is used by default. If you want to use it manually, you should set QBRTCCameraVideoCapturer as Video Capturer.

try {
    currentSession.getMediaStreamManager().setVideoCapturer(new QBRTCCameraVideoCapturer(context, null));
} catch (QBRTCCameraVideoCapturer.QBRTCCameraCapturerException exception) {
    exception.printStackTrace();
}

try {
    currentSession.mediaStreamManager.videoCapturer = QBRTCCameraVideoCapturer(context, null)
} catch (exception: QBRTCCameraVideoCapturer.QBRTCCameraCapturerException) {
    exception.printStackTrace()
}

🚧

Creating a new instance of QBRTCCameraVideoCapturer throws the QBRTCCameraCapturerException so you should handle this exception.

Switch camera

You can switch the video camera during a call. (Default: front camera)

QBRTCCameraVideoCapturer videoCapturer = (QBRTCCameraVideoCapturer) currentSession.getMediaStreamManager().getVideoCapturer();
videoCapturer.switchCamera(cameraSwitchHandler);

val videoCapturer = currentSession.mediaStreamManager.videoCapturer as QBRTCCameraVideoCapturer
videoCapturer.switchCamera(cameraSwitchHandler)

You should use CameraSwitchHandler to handle the camera switching process.

CameraVideoCapturer.CameraSwitchHandler cameraSwitchHandler = new CameraVideoCapturer.CameraSwitchHandler() {
    @Override
    public void onCameraSwitchDone(boolean switched) {

    }

    @Override
    public void onCameraSwitchError(String message) {

    }
};

val cameraSwitchHandler = object : CameraVideoCapturer.CameraSwitchHandler {
    override fun onCameraSwitchDone(switched: Boolean?) {

    }

    override fun onCameraSwitchError(message: String?) {

    }
}

Change capture format

You can change framerate and frame size during an active call session using videoCapturer.

QBRTCCameraVideoCapturer videoCapturer = (QBRTCCameraVideoCapturer) currentSession.getMediaStreamManager().getVideoCapturer();
videoCapturer.changeCaptureFormat(width, height, framerate);

val videoCapturer = currentSession.mediaStreamManager.videoCapturer as QBRTCCameraVideoCapturer
videoCapturer.changeCaptureFormat(width, height, framerate)

Screen sharing

To share the screen of your device with the opponents, follow the steps below:

  1. Ask appropriate permission.
if (Build.VERSION.SDK_INT > Build.VERSION_CODES.LOLLIPOP) {
    QBRTCScreenCapturer.requestPermissions(CallActivity.this);
}

if (Build.VERSION.SDK_INT > Build.VERSION_CODES.LOLLIPOP) {
    QBRTCScreenCapturer.requestPermissions(this@CallActivity)
}

🚧

Instead of CallActivity.this, you can use the context of the activity where you are asking this permission.

  1. Handle results of asking the permission.
@Override
protected void onActivityResult(int requestCode, int resultCode, @Nullable Intent data) {
    if (requestCode == QBRTCScreenCapturer.REQUEST_MEDIA_PROJECTION) {
        if (resultCode == Activity.RESULT_OK) {
            // now you can start Screen Sharing
            startScreenSharing(data);
        }
    }
}

override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
    if (requestCode == QBRTCScreenCapturer.REQUEST_MEDIA_PROJECTION) {
        if (resultCode == Activity.RESULT_OK) {
            // now you can start Screen Sharing
            startScreenSharing(data)
        }
    }
}

🚧

You should pass the Intent (data) to startScreenSharing() method to use it for setVideoCapturer().

  1. Set QBRTCScreenCapturer as Video Capturer.
QBRTCSession currentSession = getCurrentSession(); // simply use your current session variable
currentSession.getMediaStreamManager().setVideoCapturer(new QBRTCScreenCapturer(data, null)); // data - it's Intent from onActivityResult

val currentSession = getCurrentSession() // Simply use your current session variable
currentSession.getMediaStreamManager().setVideoCapturer(QBRTCScreenCapturer(data, null)) // data - it's Intent from onActivityResult

WebRTC stats reporting

You are able to receive an information report about the current connection, audio, video tracks, and other useful information. To set a receiving time interval, use the code snippet below.

QBRTCConfig.setStatsReportInterval(60);

QBRTCConfig.setStatsReportInterval(60)

Then you should use the QBRTCStatsReportCallback and add them.

currentSession.addStatsReportCallback(new QBRTCStatsReportCallback() {
    @Override
    public void onStatsReportUpdate(QBRTCStatsReport statsReport, Integer userId) {
        statsReport.getAudioReceivedCodec();
        statsReport.getAudioReceivedBitrate();

        statsReport.getVideoSendCodec();
        statsReport.getVideoSendBitrate();
        statsReport.getVideoReceivedBitrate();

        statsReport.getVideoReceivedFps();

        statsReport.getAudioSendInputLevel();

        statsReport.getVideoReceivedWidth();
        statsReport.getVideoReceivedHeight();
    }
});

currentSession.addStatsReportCallback { statsReport, userId ->
    statsReport.audioReceivedCodec
    statsReport.audioReceivedBitrate

    statsReport.videoSendCodec
    statsReport.videoSendBitrate
    statsReport.videoReceivedBitrate
  
    statsReport.videoReceivedFps

    statsReport.audioSendInputLevel

    statsReport.videoReceivedWidth
    statsReport.videoReceivedHeight
}

📘

The qbrtcStatsReport.audioReceivedCodec() and qbrtcStatsReport.videoReceivedFps() are not all you can get from the QBRTCStatsReport. This is just the example.

📘

Using QBRTCStatsReport, you can define when your opponent is speaking by using the qbrtcStatsReport.getAudioReceiveOutputLevel() parameter. This parameter is the microphone level from the participant’s audio track at the moment of collecting the statistics report.

General settings

You can change different settings for your calls using the QBRTCConfig class. All of them are listed below.

Answer time interval

If an opponent hasn't answered you within an answer time interval, then the onUserNotAnswer() callback will be returned. The answer time interval shows how much time an opponent has to answer your call. Set the answer time interval using the code snippet below.

// time interval to wait opponents answer
QBRTCConfig.setAnswerTimeInterval(answerTimeInterval);

// time interval to wait opponents answer
QBRTCConfig.setAnswerTimeInterval(answerTimeInterval)

📘

By default, the answer time interval is 60 seconds.

Disconnect time interval

Set maximum allowed time to repair a connection after it was lost. Set the disconnect time interval using the code snippet below.

// time to repair the connection after it was lost
QBRTCConfig.setDisconnectTime(disconnectTimeInterval);

// time to repair the connection after it was lost
QBRTCConfig.setDisconnectTime(disconnectTimeInterval)

📘

By default, the disconnect time interval is 10 seconds.

Dialing time interval

Dialing time interval indicates how often to notify your opponents about your call. Set the dialing time interval using the code snippet below.

// time interval for establishing connection with the opponent
QBRTCConfig.setDialingTimeInterval(dialingTimeInterval);

// time interval for establishing connection with the opponent
QBRTCConfig.setDialingTimeInterval(dialingTimeInterval)

📘

By default, the dialing time interval is 5 seconds.

Maximum number of opponents

Set the maximum number of opponents in a group call using the snippet below.

// max number of opponents in group call
QBRTCConfig.setMaxOpponentsCount(maxOpponentCount);

// max number of opponents in group call
QBRTCConfig.setMaxOpponentsCount(maxOpponentCount)

📘

By default, the maximum number of opponents is 10.

Custom ICE servers

You can customize a list of ICE servers. By default, WebRTC module will use internal ICE servers that are usually enough, but you can always set your own. WebRTC engine will choose the TURN relay with the lowest round-trip time. Thus, setting multiple TURN servers allows your application to scale-up in terms of bandwidth and number of users. Review our Setup guide to learn how to configure custom ICE servers.

Media settings

You can use the QBRTCMediaConfig class instance to configure a variety of media settings such as video/audio codecs, bitrate, fps, etc.

Video codecs

It's possible to set a video codec. You can choose from the following values: H264, VP8, and VP9.

QBRTCMediaConfig.VideoCodec videoCodec;
videoCodec = QBRTCMediaConfig.VideoCodec.H264;
videoCodec = QBRTCMediaConfig.VideoCodec.VP8;
videoCodec = QBRTCMediaConfig.VideoCodec.VP9;

QBRTCMediaConfig.setVideoCodec(videoCodec);

var videoCodec: QBRTCMediaConfig.VideoCodec
videoCodec = QBRTCMediaConfig.VideoCodec.H264
videoCodec = QBRTCMediaConfig.VideoCodec.VP8
videoCodec = QBRTCMediaConfig.VideoCodec.VP9

QBRTCMediaConfig.setVideoCodec(videoCodec)

Camera resolution

You can also set the custom video resolution to provide guarantees for the predictable behavior of the video stream.

int videoWidth = QBRTCMediaConfig.VideoQuality.QBGA_VIDEO.width;
int videoHeight = QBRTCMediaConfig.VideoQuality.QBGA_VIDEO.height;

// VGA Resolution
//videoWidth = QBRTCMediaConfig.VideoQuality.VGA_VIDEO.width;
//videoHeight = QBRTCMediaConfig.VideoQuality.VGA_VIDEO.height;

// HD Resolution
//videoWidth = QBRTCMediaConfig.VideoQuality.HD_VIDEO.width;
//videoHeight = QBRTCMediaConfig.VideoQuality.HD_VIDEO.height;

// custom Resolution (for example FullHD)
//videoWidth = 1920;
//videoHeight = 1080;
        
QBRTCMediaConfig.setVideoWidth(videoWidth);
QBRTCMediaConfig.setVideoHeight(videoHeight);

var videoWidth = QBRTCMediaConfig.VideoQuality.QBGA_VIDEO.width
var videoHeight = QBRTCMediaConfig.VideoQuality.QBGA_VIDEO.height

// VGA Resolution
//videoWidth = QBRTCMediaConfig.VideoQuality.VGA_VIDEO.width
//videoHeight = QBRTCMediaConfig.VideoQuality.VGA_VIDEO.height

// HD Resolution
//videoWidth = QBRTCMediaConfig.VideoQuality.HD_VIDEO.width
//videoHeight = QBRTCMediaConfig.VideoQuality.HD_VIDEO.height

// Custom Resolution (for example FullHD)
//videoWidth = 1920
//videoHeight = 1080

QBRTCMediaConfig.setVideoWidth(videoWidth)
QBRTCMediaConfig.setVideoHeight(videoHeight)

Audio codecs

Set an audio codec using the snippet below. You can choose from the following values: ISAC and OPUS. Default: ISAC.

QBRTCMediaConfig.AudioCodec audioCodec;
audioCodec = QBRTCMediaConfig.AudioCodec.OPUS;
audioCodec = QBRTCMediaConfig.AudioCodec.ISAC;

QBRTCMediaConfig.setAudioCodec(audioCodec)

var audioCodec: QBRTCMediaConfig.AudioCodec
audioCodec = QBRTCMediaConfig.AudioCodec.OPUS
audioCodec = QBRTCMediaConfig.AudioCodec.ISAC

QBRTCMediaConfig.setAudioCodec(audioCodec)

Bitrate

It's possible to set the custom bitrate to provide guarantees for the predictable behavior of the video stream.

int startBitrate = 0;
//startBitrate = 2000;
QBRTCMediaConfig.setVideoStartBitrate(startBitrate);

var startBitrate: Int = 0
//startBitrate = 2000
QBRTCMediaConfig.setVideoStartBitrate(startBitrate)

Hardware acceleration

Enable hardware acceleration if the device supports it. Default: false.

boolean useHWAcceleration = true;
QBRTCMediaConfig.setVideoHWAcceleration(useHWAcceleration);

val useHWAcceleration = true
QBRTCMediaConfig.setVideoHWAcceleration(useHWAcceleration)

Frames per second

It's possible to set the custom fps to provide guarantees for the predictable behavior of the video stream.

int fps = 30;
//fps = 30;
QBRTCMediaConfig.setVideoFps(fps);

val fps = 30
//fps = 30;
QBRTCMediaConfig.setVideoFps(fps)

Acoustic echo cancellation

Enable a built-in acoustic echo cancellation if the device supports it. Default: true.

boolean useAEC = true;
QBRTCMediaConfig.setUseBuildInAEC(useAEC);

val useAEC = true
QBRTCMediaConfig.setUseBuildInAEC(useAEC)

Open sound library for embedded systems

Enable open sound library for embedded systems (OpenSL ES audio) if the device supports it. Default: false.

boolean useOpenSLES = true;
QBRTCMediaConfig.setUseOpenSLES(useOpenSLES);

val useOpenSLES = true
QBRTCMediaConfig.setUseOpenSLES(useOpenSLES)

Audio processing

Enable audio processing if the device supports it. Default: true.

boolean useAudioProcessing = true;
QBRTCMediaConfig.setAudioProcessingEnabled(useAudioProcessing);

val useAudioProcessing = true
QBRTCMediaConfig.setAudioProcessingEnabled(useAudioProcessing)

Updated over 2 years ago

What’s Next