Google WebRtc Sdk Implementation with Android and SRS Server

Question

I have some issue when I have setRemoteDescription, And the message showing like this: "Failed to set remote answer sdp: The order of m-lines in answer doesn't match order in offer. Rejecting answer."

And here is my full code:

• My initializePeerConnectionFactory on mainActivity

  private fun initializePeerConnectionFactory() { // Create initialization options for the PeerConnectionFactory val eglBaseContext = EglBase.create().eglBaseContext val options = PeerConnectionFactory.Options()

    // Initialize WebRTC PeerConnectionFactory
    PeerConnectionFactory.initialize(
        PeerConnectionFactory.InitializationOptions.builder(applicationContext)
            .setFieldTrials("WebRTC-H264HighProfile/Enabled/").createInitializationOptions()
    )
    // Create PeerConnectionFactory once initialization is done
  
    peerConnectionFactory = PeerConnectionFactory.builder()
        .setOptions(options)
        .createPeerConnectionFactory()
  
    if (peerConnectionFactory == null) {
        println("PeerConnectionFactory initialization failed.")
        return
    } else {
        println("PeerConnectionFactory initialized successfully.")
        generateSdpOffer()
    }
  

  }

• My generateSdpOffer on initializePeerConnectionFactory

  private fun generateSdpOffer() { if (peerConnectionFactory == null) { return } val mediaConstraints = MediaConstraints().apply { mandatory.add(MediaConstraints.KeyValuePair("OfferToReceiveAudio", "true")) mandatory.add(MediaConstraints.KeyValuePair("OfferToReceiveVideo", "true")) }

    val config = PeerConnection.RTCConfiguration(iceServers)
  
    // Initialize the PeerConnection
    peerConnection =
        peerConnectionFactory?.createPeerConnection(config, object : PeerConnection.Observer {
            override fun onIceCandidate(candidate: IceCandidate?) {}
            override fun onIceCandidatesRemoved(p0: Array<out IceCandidate>?) {}
  
            override fun onAddStream(stream: MediaStream?) {
                stream?.let { mediaStream ->
                    if (mediaStream.videoTracks.isEmpty().not()) {
                        mediaStream.videoTracks[0].addSink { remoteRenderer }
                    }
                }
            }
  
            override fun onRemoveStream(stream: MediaStream?) {}
            override fun onDataChannel(channel: DataChannel?) {}
            override fun onRenegotiationNeeded() {}
            override fun onIceConnectionChange(newState: PeerConnection.IceConnectionState?) {}
            override fun onIceConnectionReceivingChange(p0: Boolean) {}
  
            override fun onIceGatheringChange(newState: PeerConnection.IceGatheringState?) {}
            override fun onSignalingChange(newState: PeerConnection.SignalingState?) {
                Log.e("SignalState", "onSignalStateChange ${newState?.name}")
            }
        })
  
  
  
    // Create SDP offer
  
    peerConnection?.createOffer(object :
        SdpObserver {
        override fun onCreateSuccess(sdp: SessionDescription?) {
            val modifiedSdp = sdp?.description?.replace(
                "m=video 0 UDP/TLS/RTP/SAVPF 0", "m=video 9 UDP/TLS/RTP/SAVPF 125"
            )
            val codecLines = """
                 a=rtpmap:125 H264/90000
             """.trimIndent()
  
            // Append the codec lines to the SDP
            finalSdp = modifiedSdp + codecLines
            println("finaSdp-=-=-=-=$finalSdp")
            Log.e("TAG", "finaSdp-=-=-=-=${finalSdp}")
            var modifiedSessionDescription =
                SessionDescription(SessionDescription.Type.OFFER, finalSdp)
            //val resultSetLocalDescription = peerConnection?.setLocalDescription(this, modifiedSessionDescription)
  
            peerConnection?.setLocalDescription(modifiedSessionDescription.let {
                object : SdpObserver {
                    override fun onCreateSuccess(p0: SessionDescription?) {
                        println("resultSetLocalDescription onCreateSuccess: $p0")
                    }
  
                    override fun onSetSuccess() {
                        println("resultSetLocalDescription onSetSuccess000000:${modifiedSessionDescription.description}")
  
                    }
  
                    override fun onCreateFailure(p0: String?) {
                        println("resultSetLocalDescription onCreateFailure: $p0")
                    }
  
                    override fun onSetFailure(p0: String?) {
                        println("resultSetLocalDescription onSetFailure: $p0")
                    }
  
                }
            })
            println("modifiedSessionDescription=-=-=-=-: ${modifiedSessionDescription.description}")
            sendOfferToServer(modifiedSessionDescription)
        }
  
        override fun onCreateFailure(error: String?) {
            Log.e("SDP Offer", "Error creating SDP offer: $error")
        }
  
        override fun onSetSuccess() {
            println("modifiedSessionDescription=-=-=-=-: ${modifiedSessionDescription?.description}")
        }
  
        override fun onSetFailure(error: String?) {
            Log.e("SDP Offer", "Error setting SDP: $error")
        }
    }, mediaConstraints)
  
    println("mediaConstraints: $mediaConstraints")
  

  }

• My sendOfferToServer

  private fun sendOfferToServer(it: SessionDescription) { println("Information of finalSdp: $finalSdp") Log.e("SOCKET=-=-=-=", "${it.description}") val client = OkHttpClient() val request = Request.Builder().url(streamUrl).header("Content-Type", "application/sdp") .post(it.description.toString().toRequestBody()).build()

    client.newCall(request).enqueue(object : Callback {
        override fun onResponse(call: Call, response: Response) {
            Log.e("WebRTC", "fetchSDPFromWHEP-=-=: ${response.body?.toString()}")
            val sdpResponse = response.body.toString()
            response.body.use { responseBody ->
                val sdpResponse = responseBody?.string()
                Log.e("WebRTC", "Response Body: $sdpResponse")
                //val sessionDescription = SessionDescription(SessionDescription.Type.ANSWER, sdpResponse)
                val sessionDescription = SessionDescription(
                    SessionDescription.Type.ANSWER, BaseConvertAnswerSdp().convertAnswerSdp(
                        finalSdp!!, sdpResponse
                    )
                )
                println("Information on sessionDescription: ${sessionDescription.description}")
                setRemoteDescription(sessionDescription)
  
            }
            println("Information on Response: $sdpResponse")
            //  setRemoteDescription(SessionDescription(SessionDescription.Type.ANSWER, response.toString()))
            /*response.body?.string()?.let { sdpResponse ->
                Log.e("WebRTC 900909090", sdpResponse)
  
                // setRemoteDescription(SessionDescription(SessionDescription.Type.ANSWER, sdpResponse))
  
            } ?: {
                Log.e("WebRTC", "Empty SDP response")
            }*/
        }
  
        override fun onFailure(call: Call, e: IOException) {
            Log.e("WebRTC", "Failed to fetch SDP: ${e.message}")
        }
    })
  

  }

• My setRemoteDescription

  private fun setRemoteDescription(sessionDescription: SessionDescription) { println("Received SDP setRemoteDescription: ${sessionDescription.description}") val signalingState = peerConnection?.signalingState() println("signalingState: ${signalingState?.name}") peerConnection?.let { Log.e("SDP Answer", "PeerConnection State: ${it.signalingState()}") it.setRemoteDescription(sessionDescription.description.let { object : SdpObserver { override fun onSetSuccess() { Log.e("SDP Answer onSetSuccess", "Remote description set successfully") }

                override fun onSetFailure(error: String?) {
                    Log.e(
                        "SDP Answer onSetFailure",
                        "Failed to set remote description onSetFailure: $error"
                    )
                }
  
                override fun onCreateSuccess(sdp: SessionDescription?) {
                    Log.e(
                        "SDP Answer onCreateSuccess",
                        "Failed to set remote description onCreateSuccess: $sdp"
                    )
                }
  
                override fun onCreateFailure(error: String?) {
                    Log.e(
                        "SDP Answer onCreateFailure",
                        "Failed to set remote description onCreateFailure: $error"
                    )
                }
            }
        }, sessionDescription)
    } ?: Log.e("SDP Answer", "PeerConnection is null!")
  

  }