WebRTC for Android and Kotlin Developers

            // Add the dependency below to your app level `build.gradle` file:
dependencies {
  implementation "io.getstream:stream-webrtc-android:1.1.1"
}
        

            // Copyright 2023 Stream.IO, Inc. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0

class StreamPeerConnection(
  private val coroutineScope: CoroutineScope,
  private val type: StreamPeerType,
  private val mediaConstraints: MediaConstraints,
  private val onStreamAdded: ((MediaStream) -> Unit)?,
  private val onNegotiationNeeded: ((StreamPeerConnection, StreamPeerType) -> Unit)?,
  private val onIceCandidate: ((IceCandidate, StreamPeerType) -> Unit)?,
  private val onVideoTrack: ((RtpTransceiver?) -> Unit)?
) : PeerConnection.Observer {

  suspend fun createOffer(): Result<SessionDescription> {
    logger.d { "[createOffer] #sfu; #$typeTag; no args" }
    return createValue { connection.createOffer(it, mediaConstraints) }
  }

  suspend fun createAnswer(): Result<SessionDescription> {
    logger.d { "[createAnswer] #sfu; #$typeTag; no args" }
    return createValue { connection.createAnswer(it, mediaConstraints) }
  }

  suspend fun setRemoteDescription(sessionDescription: SessionDescription): Result<Unit> {
    logger.d { "[setRemoteDescription] #sfu; #$typeTag; answerSdp: ${sessionDescription.stringify()}" }
    return setValue {
      connection.setRemoteDescription(
        it,
        SessionDescription(
          sessionDescription.type,
          sessionDescription.description.mungeCodecs()
        )
      )
    }.also {
      pendingIceMutex.withLock {
        pendingIceCandidates.forEach { iceCandidate ->
          logger.i { "[setRemoteDescription] #sfu; #subscriber; pendingRtcIceCandidate: $iceCandidate" }
          connection.addRtcIceCandidate(iceCandidate)
        }
        pendingIceCandidates.clear()
      }
    }
  }

  suspend fun setLocalDescription(sessionDescription: SessionDescription): Result<Unit> {
    val sdp = SessionDescription(
      sessionDescription.type,
      sessionDescription.description.mungeCodecs()
    )
    logger.d { "[setLocalDescription] #sfu; #$typeTag; offerSdp: ${sessionDescription.stringify()}" }
    return setValue { connection.setLocalDescription(it, sdp) }
  }

  suspend fun addIceCandidate(iceCandidate: IceCandidate): Result<Unit> {
    if (connection.remoteDescription == null) {
      logger.w { "[addIceCandidate] #sfu; #$typeTag; postponed (no remoteDescription): $iceCandidate" }
      pendingIceMutex.withLock {
        pendingIceCandidates.add(iceCandidate)
      }
      return Result.failure(RuntimeException("RemoteDescription is not set"))
    }
    logger.d { "[addIceCandidate] #sfu; #$typeTag; rtcIceCandidate: $iceCandidate" }
    return connection.addRtcIceCandidate(iceCandidate).also {
      logger.v { "[addIceCandidate] #sfu; #$typeTag; completed: $it" }
    }
  }

  ..
}
        

            // Copyright 2023 Stream.IO, Inc. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0

class StreamPeerConnectionFactory constructor(
  private val context: Context
) {

  // rtcConfig contains STUN and TURN servers list
  val rtcConfig = PeerConnection.RTCConfiguration(
    arrayListOf(
      // adding google's standard server
      PeerConnection.IceServer.builder("stun:stun.l.google.com:19302").createIceServer()
    )
  ).apply {
    // it's very important to use new unified sdp semantics PLAN_B is deprecated
    sdpSemantics = PeerConnection.SdpSemantics.UNIFIED_PLAN
  }

  ..
 }
        

            // Copyright 2023 Stream.IO, Inc. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0

private val factory by lazy {
  PeerConnectionFactory.initialize(
    PeerConnectionFactory.InitializationOptions.builder(context).createInitializationOptions()
  )

  PeerConnectionFactory.builder()
    .setVideoDecoderFactory(videoDecoderFactory)
    .setVideoEncoderFactory(videoEncoderFactory)
    .setAudioDeviceModule(
      JavaAudioDeviceModule
        .builder(context)
        .setUseHardwareAcousticEchoCanceler(Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q)
        .setUseHardwareNoiseSuppressor(Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q)
        .setAudioRecordErrorCallback(..)
        .setAudioTrackErrorCallback(..)
        .setAudioRecordStateCallback(..)
        .setAudioTrackStateCallback(..)
        .createAudioDeviceModule().also {
          it.setMicrophoneMute(false)
          it.setSpeakerMute(false)
        }
    )
    .createPeerConnectionFactory()
}
        

            // Copyright 2023 Stream.IO, Inc. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0

class SignalingClient {
  private val logger by taggedLogger("Call:SignalingClient")
  private val signalingScope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
  private val client = OkHttpClient()
  private val request = Request
    .Builder()
    .url(BuildConfig.SIGNALING_SERVER_IP_ADDRESS)
    .build()

  // opening web socket with signaling server
  private val ws = client.newWebSocket(request, SignalingWebSocketListener())

  // session flow to send information about the session state to the subscribers
  private val _sessionStateFlow = MutableStateFlow(WebRTCSessionState.Offline)
  val sessionStateFlow: StateFlow<WebRTCSessionState> = _sessionStateFlow

  // signaling commands to send commands to value pairs to the subscribers
  private val _signalingCommandFlow = MutableSharedFlow<Pair<SignalingCommand, String>>()
  val signalingCommandFlow: SharedFlow<Pair<SignalingCommand, String>> = _signalingCommandFlow

  fun sendCommand(signalingCommand: SignalingCommand, message: String) {
    logger.d { "[sendCommand] $signalingCommand $message" }
    ws.send("$signalingCommand $message")
  }

  private inner class SignalingWebSocketListener : WebSocketListener() {
    override fun onMessage(webSocket: WebSocket, text: String) {
      when {
        text.startsWith(SignalingCommand.STATE.toString(), true) ->
          handleStateMessage(text)
        text.startsWith(SignalingCommand.OFFER.toString(), true) ->
          handleSignalingCommand(SignalingCommand.OFFER, text)
        text.startsWith(SignalingCommand.ANSWER.toString(), true) ->
          handleSignalingCommand(SignalingCommand.ANSWER, text)
        text.startsWith(SignalingCommand.ICE.toString(), true) ->
          handleSignalingCommand(SignalingCommand.ICE, text)
      }
    }
  }

  private fun handleStateMessage(message: String) {
    val state = getSeparatedMessage(message)
    _sessionStateFlow.value = WebRTCSessionState.valueOf(state)
  }

  private fun handleSignalingCommand(command: SignalingCommand, text: String) {
    val value = getSeparatedMessage(text)
    logger.d { "received signaling: $command $value" }
    signalingScope.launch {
      _signalingCommandFlow.emit(command to value)
    }
  }

  private fun getSeparatedMessage(text: String) = text.substringAfter(' ')

  fun dispose() {
    _sessionStateFlow.value = WebRTCSessionState.Offline
    signalingScope.cancel()
    ws.cancel()
  }
}

enum class WebRTCSessionState {
  Active, // Offer and Answer messages has been sent
  Creating, // Creating session, offer has been sent
  Ready, // Both clients available and ready to initiate session
  Impossible, // We have less than two clients connected to the server
  Offline // unable to connect signaling server
}

enum class SignalingCommand {
  STATE, // Command for WebRTCSessionState
  OFFER, // to send or receive offer
  ANSWER, // to send or receive answer
  ICE // to send and receive ice candidates
}
        

            // Copyright 2023 Stream.IO, Inc. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0

class WebRtcSessionManagerImpl(
  private val context: Context,
  override val signalingClient: SignalingClient,
  override val peerConnectionFactory: StreamPeerConnectionFactory
) : WebRtcSessionManager {
  private val logger by taggedLogger("Call:LocalWebRtcSessionManager")

  private val sessionManagerScope = CoroutineScope(SupervisorJob() + Dispatchers.Default)

  // used to send remote video track to the sender
  private val _remoteVideoSinkFlow = MutableSharedFlow<VideoTrack>()
  override val remoteVideoSinkFlow: SharedFlow<VideoTrack> = _remoteVideoSinkFlow

  // declaring video constraints and setting OfferToReceiveVideo to true
  // this step is mandatory to create valid offer and answer
  private val mediaConstraints = MediaConstraints().apply {
    mandatory.addAll(
      listOf(
        MediaConstraints.KeyValuePair("OfferToReceiveAudio", "true"),
        MediaConstraints.KeyValuePair("OfferToReceiveVideo", "true")
      )
    )
  }

  private val peerConnection: StreamPeerConnection by lazy {
    peerConnectionFactory.makePeerConnection(
      coroutineScope = sessionManagerScope,
      configuration = peerConnectionFactory.rtcConfig,
      type = StreamPeerType.SUBSCRIBER,
      mediaConstraints = mediaConstraints,
      onIceCandidateRequest = { iceCandidate, _ ->
        signalingClient.sendCommand(
          SignalingCommand.ICE,
          "${iceCandidate.sdpMid}$ICE_SEPARATOR${iceCandidate.sdpMLineIndex}$ICE_SEPARATOR${iceCandidate.sdp}"
        )
      },
      onVideoTrack = { rtpTransceiver ->
        val track = rtpTransceiver?.receiver?.track() ?: return@makePeerConnection
        if (track.kind() == MediaStreamTrack.VIDEO_TRACK_KIND) {
          val videoTrack = track as VideoTrack
          sessionManagerScope.launch {
            _remoteVideoSinkFlow.emit(videoTrack)
          }
        }
      }
    )
  }

 ..
}
        

            // Copyright 2023 Stream.IO, Inc. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0

// getting front camera
private val videoCapturer: VideoCapturer by lazy { buildCameraCapturer() }

// we need it to initialize video capturer
private val surfaceTextureHelper = SurfaceTextureHelper.create(
  "SurfaceTextureHelperThread",
  peerConnectionFactory.eglBaseContext
)

private val videoSource by lazy {
  peerConnectionFactory.makeVideoSource(videoCapturer.isScreencast).apply {
    videoCapturer.initialize(surfaceTextureHelper, context, this.capturerObserver)
    videoCapturer.startCapture(480, 720, 30)
  }
}

private val localVideoTrack: VideoTrack by lazy {
  peerConnectionFactory.makeVideoTrack(
    source = videoSource,
    trackId = "Video${UUID.randomUUID()}"
  )
}

private fun buildCameraCapturer(): VideoCapturer {
  val manager = cameraManager ?: throw RuntimeException("CameraManager was not initialized!")

  val ids = manager.cameraIdList
  var foundCamera = false
  var cameraId = ""

  for (id in ids) {
    val characteristics = manager.getCameraCharacteristics(id)
    val cameraLensFacing = characteristics.get(CameraCharacteristics.LENS_FACING)

    if (cameraLensFacing == CameraMetadata.LENS_FACING_FRONT) {
      foundCamera = true
      cameraId = id
    }
  }

  if (!foundCamera && ids.isNotEmpty()) {
    cameraId = ids.first()
  }

  val camera2Capturer = Camera2Capturer(context, cameraId, null)
  return camera2Capturer
}
        

            // Copyright 2023 Stream.IO, Inc. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0

init {
  sessionManagerScope.launch {
    signalingClient.signalingCommandFlow
      .collect { commandToValue ->
        when (commandToValue.first) {
          SignalingCommand.OFFER -> handleOffer(commandToValue.second)
          SignalingCommand.ANSWER -> handleAnswer(commandToValue.second)
          SignalingCommand.ICE -> handleIce(commandToValue.second)
          else -> Unit
        }
      }
  }
}

private fun handleOffer(sdp: String) {
  logger.d { "[SDP] handle offer: $sdp" }
  offer = sdp
}

private suspend fun handleAnswer(sdp: String) {
  logger.d { "[SDP] handle answer: $sdp" }
  peerConnection.setRemoteDescription(
    SessionDescription(SessionDescription.Type.ANSWER, sdp)
  )
}

private suspend fun handleIce(iceMessage: String) {
  val iceArray = iceMessage.split(ICE_SEPARATOR)
  peerConnection.addIceCandidate(
    IceCandidate(
      iceArray[0],
      iceArray[1].toInt(),
      iceArray[2]
    )
  )
}
        

            // Copyright 2023 Stream.IO, Inc. All Rights Reserved.
// SPDX-License-Identifier: Apache-2.0

override fun onSessionScreenReady() {
  peerConnection.connection.addTrack(localVideoTrack)
  peerConnection.connection.addTrack(localAudioTrack)
  sessionManagerScope.launch {
    // sending local video track to show local video from start
    _localVideoSinkFlow.emit(localVideoTrack)

    if (offer != null) {
      sendAnswer()
    } else {
      sendOffer()
    }
  }
}

private suspend fun sendOffer() {
  val offer = peerConnection.createOffer().getOrThrow()
  val result = peerConnection.setLocalDescription(offer)
  result.onSuccess {
    signalingClient.sendCommand(SignalingCommand.OFFER, offer.description)
  }
  logger.d { "[SDP] send offer: ${offer.stringify()}" }
}

private suspend fun sendAnswer() {
  peerConnection.setRemoteDescription(
    SessionDescription(SessionDescription.Type.OFFER, offer)
  )
  val answer = peerConnection.createAnswer().getOrThrow()
  val result = peerConnection.setLocalDescription(answer)
  result.onSuccess {
    signalingClient.sendCommand(SignalingCommand.ANSWER, answer.description)
  }
  logger.d { "[SDP] send answer: ${answer.stringify()}" }
}
        

            // You should change 192.168.1.123 to your local IP address, which is running the WebRTC backend server. 
SIGNALING_SERVER_IP_ADDRESS=ws://192.168.1.123:8080/rtc