Реализация Google Webrtc SDK с Android и SRS Server ⇐ Android

[Anonymous]

У меня есть некоторая проблема, когда у меня есть SetRemoteScription, и сообщение, показывающее следующее:
«не удалось установить удаленный ответ SDP: Порядок M-линий в ответе не совпадает с заказом в предложении. Отказ от ответа. "< /p>
и вот мой полный код: < /p>

• my initializepeerconnectionFactory на mainActivity < /p>
  Private Fun Инициализоперконконфактор () {
  // Создание параметров инициализации для peerconnectionFactory
  val eglbasecontext = eglbase.create (). = PeerConnectionFactory.options () < /p>

  Код: Выделить всё

    // 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()
  }
  < /code>
  } < /p>
  < /li>
    my GeneratesDpoffer на initiorizepeerconnectionFactory < /p>
  private FUN GENATESDPOFFER () {
  if (peerconnectionFactory == null) {
  return
  }
  val mediaConstraints = MediaConstraints ().  Применить {
  mandatory.add(mediaconstraints.keyvalueepair("offfertoreceiveaudio "," true "))
  mandatory.add(mediaiaconts.keyvaluepair("offertoreceivevideo", "true"))
  } < /p>
    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?) {}
  
  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")
  < /code>
  } < /p>
  < /li>
    my sendoffertoserver < /p>
  private fun sendoffertoserverver (IT: SessionDescription) {
  println ("Информация FinalsDP: $ finalsdp")
  log.e("socket= -= -= -= ", "$ {it.description}")
  val client = okhttpclient ()
  val request = request.builder ().  )
  .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}")
  }
  })
  < /code>
  } < /p>
  < /li>
    my setRemotedescription < /p>
  private fun setRemotedescription (SessionDescription: SessionDescription) {
  println ("Полученный SDP setRemoteScription: $ {sessionDescription.description}")
  val SignalingState = PeerConnection? .SignalingState ()
  println ("SignalingState: $ {SignalingState? Состояние: $ {it.signalingstate ()} ")
  it.setRemotedescription(sessionDescription.description.Let {
  объект: sdpobserver {
  переопределить веселье onsetStuccess () {
  л. )
  } < /p>
                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!")
  

  }

Подробнее здесь: https://stackoverflow.com/questions/794 ... srs-server