Skip to main content

​
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.
  • Java
  • Kotlin
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();

​
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.
  • Java
  • Kotlin
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();

​
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.
  • Java
  • Kotlin
try {
    currentSession.getMediaStreamManager().setVideoCapturer(new QBRTCCameraVideoCapturer(context, null));
} catch (QBRTCCameraVideoCapturer.QBRTCCameraCapturerException exception) {
    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)
  • Java
  • Kotlin
QBRTCCameraVideoCapturer videoCapturer = (QBRTCCameraVideoCapturer) currentSession.getMediaStreamManager().getVideoCapturer();
videoCapturer.switchCamera(cameraSwitchHandler);
You should use CameraSwitchHandler to handle the camera switching process.
  • Java
  • Kotlin
CameraVideoCapturer.CameraSwitchHandler cameraSwitchHandler = new CameraVideoCapturer.CameraSwitchHandler() {
    @Override
    public void onCameraSwitchDone(boolean switched) {

    }

    @Override
    public void onCameraSwitchError(String message) {

    }
};

​
Change capture format

You can change framerate and frame size during an active call session using videoCapturer.
  • Java
  • Kotlin
QBRTCCameraVideoCapturer videoCapturer = (QBRTCCameraVideoCapturer) currentSession.getMediaStreamManager().getVideoCapturer();
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.
  • Java
  • Kotlin
if (Build.VERSION.SDK_INT > Build.VERSION_CODES.LOLLIPOP) {
    QBRTCScreenCapturer.requestPermissions(CallActivity.this);
}
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.
  • Java
  • Kotlin
@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);
        }
    }
}
You should pass the Intent (data) to startScreenSharing() method to use it for setVideoCapturer().
  1. Set QBRTCScreenCapturer as Video Capturer.
  • Java
  • Kotlin
QBRTCSession currentSession = getCurrentSession(); // simply use your current session variable
currentSession.getMediaStreamManager().setVideoCapturer(new 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.
  • Java
  • Kotlin
QBRTCConfig.setStatsReportInterval(60);
Then you should use the QBRTCStatsReportCallback and add them.
  • Java
  • Kotlin
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();
    }
});
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.
  • Java
  • Kotlin
// 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.
  • Java
  • Kotlin
// 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.
  • Java
  • Kotlin
// 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.
  • Java
  • Kotlin
// 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.
  • Java
  • Kotlin
QBRTCMediaConfig.VideoCodec 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.
  • Java
  • Kotlin
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);

​
Audio codecs

Set an audio codec using the snippet below. You can choose from the following values: ISAC and OPUS. Default: ISAC.
  • Java
  • Kotlin
QBRTCMediaConfig.AudioCodec 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.
  • Java
  • Kotlin
int startBitrate = 0;
//startBitrate = 2000;
QBRTCMediaConfig.setVideoStartBitrate(startBitrate);

​
Hardware acceleration

Enable hardware acceleration if the device supports it. Default: false.
  • Java
  • Kotlin
boolean 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.
  • Java
  • Kotlin
int fps = 30;
//fps = 30;
QBRTCMediaConfig.setVideoFps(fps);

​
Acoustic echo cancellation

Enable a built-in acoustic echo cancellation if the device supports it. Default: true.
  • Java
  • Kotlin
boolean 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.
  • Java
  • Kotlin
boolean useOpenSLES = true;
QBRTCMediaConfig.setUseOpenSLES(useOpenSLES);

​
Audio processing

Enable audio processing if the device supports it. Default: true.
  • Java
  • Kotlin
boolean useAudioProcessing = true;
QBRTCMediaConfig.setAudioProcessingEnabled(useAudioProcessing);
⌘I