WebRTC Android by Stream

If you need to use the latest development snapshots, you must first add the Sonatype Maven snapshots repository to your repositories block, then add the specific SNAPSHOT dependency to your module's build.gradle file.

repositories {
   maven(url="https://central.sonatype.com/repository/maven-snapshots/")
}

dependencies {
    implementation("io.getstream:stream-webrtc-android:1.3.11-SNAPSHOT")
}

The simplest way to compile the source code for all supported CPU types (arm64-v8a, armeabi-v7a, x86, x86_64) into a single .aar file is to use the provided AAR build tool.

Steps:

1. Ensure your current working directory is webrtc_android/src/.
2. Run the build script:

tools_webrtc/android/build_aar.py

This will generate libwebrtc.aar in the webrtc_android/src/ directory.

To use custom UI components like VideoTextureViewRenderer for complex video layouts (e.g., overlaying video frames), add the following dependency to your module's build.gradle file:

dependencies {
    implementation "io.getstream:stream-webrtc-android-ui:$version"
}

To use the pre-compiled WebRTC core library in your Android project, add the dependency to your module's build.gradle file. This library provides the org.webrtc package, including essential classes for real-time video and audio communication.

dependencies {
    implementation("io.getstream:stream-webrtc-android:1.3.9")
}

To compile the WebRTC core library yourself, you must use a Linux OS (Ubuntu 14.04 LTS recommended) with at least 8GB RAM and 50GB storage. You must first set up depot_tools and fetch the Chromium WebRTC repository.

Manual Compilation Steps:

1. Set up depot_tools and fetch the repository.
2. Ensure you are on the origin/master branch to resolve compilation issues.
3. Generate projects using gn and compile using ninja.

Generate Projects (GN): Run these from webrtc_android/src/:

gn gen out/Debug --args='target_os="android" target_cpu="arm"'
gn gen out/Release --args='is_debug=false is_component_build=false rtc_include_tests=false target_os="android" target_cpu="arm"'

Note: Use target_cpu="arm64" for ARM64, target_cpu="x86" for 32-bit x86, and target_cpu="x64" for 64-bit x64.

Compile (Ninja):

ninja -C out/Debug
ninja -C out/Release

To use Kotlin Coroutine-style extensions for WebRTC, add the following dependency to your module's build.gradle file:

dependencies {
    implementation "io.getstream:stream-webrtc-android-ktx:$version"
}

To use Jetpack Compose components like VideoRenderer and FloatingVideoRenderer, add the following dependency to your module's build.gradle file:

dependencies {
    implementation "io.getstream:stream-webrtc-android-compose:$version"
}

The VideoTextureViewRenderer is a custom TextureView that implements VideoSink and SurfaceTextureListener. It is recommended over SurfaceViewRenderer when you need to design complex video call screens where one video layout must overlay another.

XML Usage:

<io.getstream.webrtc.android.ui.VideoTextureViewRenderer
    android:id="@+id/participantVideoRenderer"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
 />

Adding/Removing Video Tracks in Kotlin:

videoTrack.video.addSink(participantVideoRenderer)
videoTrack.video.removeSink(participantVideoRenderer)

The KTX library provides suspend functions to replace callback-style WebRTC operations with Coroutines.

addRtcIceCandidate: A suspend function to add an IceCandidate to a PeerConnection using Coroutines style.

pendingIceMutex.withLock {
    pendingIceCandidates.forEach { iceCandidate ->
        connection.addRtcIceCandidate(iceCandidate)
    }
    pendingIceCandidates.clear()
}

createSessionDescription: A way to create a SessionDescription that delegates SdpObserver using Coroutines style.

suspend fun createAnswer(): Result<SessionDescription> {
  return createSessionDescription { sdpObserver -> connection.createAnswer(sdpObserver, mediaConstraints) }
}

VideoRenderer is a composable function that renders a single video track. You can observe rendering state changes using the RendererEvents interface.

Usage Example:

VideoRenderer(
    videoTrack = remoteVideoTrack,
    modifier = Modifier.fillMaxSize(),
    eglBaseContext = eglBaseContext,
    rendererEvents = rendererEvents
)

Implementing RendererEvents:

val rendererEvents = object : RendererEvents {
      override fun onFirstFrameRendered() { .. }
      override fun onFrameResolutionChanged(videoWidth: Int, videoHeight: Int, rotation: Int) { .. }
}