WebRTC

流

1 两个设备使用关于STUN服务器，TURN服务器，输入源（例如输入音频，输入视频）的配置来创建对等连接。
2 设备A和设备B向STUN服务器发送请求以获取其公共IP地址。
3 设备A通过信令服务器向设备B发送要约SDP和ICE候选者。
4 设备B还通过信令服务器将答案SDP和ICE候选发送到设备A。此时，两个设备可以通过对等连接一起交谈。

创建和配置对等连接

创建对等连接，您需要传递一个包含STUN和TURN服务器以及一些其他信息的配置。

func createPeerConnection() {
    let config = RTCConfiguration()
    config.iceServers = [RTCIceServer(urlStrings: iceServers)]
    
    // Unified plan is more superior than planB
    config.sdpSemantics = .unifiedPlan
    
    // gatherContinually will let WebRTC to listen to any network changes and send any new candidates to the other client
    config.continualGatheringPolicy = .gatherContinually
    
    let constraints = RTCMediaConstraints(
      mandatoryConstraints: nil,
      optionalConstraints: ["DtlsSrtpKeyAgreement": kRTCMediaConstraintsValueTrue])
    self.peerConnection = WebRTCClient.factory.peerConnection(with: config, constraints: constraints, delegate: self)
    
    self.createMediaSenders()
    self.configureAudioSession()
  }

创建音频轨道，视频轨道，并将它们添加到对等连接中，如下所示：

private func createMediaSenders() {
    let streamId = "stream"
    
    // Audio
    let audioTrack = self.createAudioTrack()
    self.peerConnection!.add(audioTrack, streamIds: [streamId])
    
    // Video
    let videoTrack = self.createVideoTrack()
    self.localVideoTrack = videoTrack
    self.peerConnection!.add(videoTrack, streamIds: [streamId])
    self.remoteVideoTrack = self.peerConnection!.transceivers.first { $0.mediaType == .video }?.receiver.track as? RTCVideoTrack
    
    // Data
    if let dataChannel = createDataChannel() {
      dataChannel.delegate = self
      self.localDataChannel = dataChannel
    }
  }
  
  private func createAudioTrack() -> RTCAudioTrack {
    let audioConstrains = RTCMediaConstraints(mandatoryConstraints: nil, optionalConstraints: nil)
    let audioSource = WebRTCClient.factory.audioSource(with: audioConstrains)
    let audioTrack = WebRTCClient.factory.audioTrack(with: audioSource, trackId: "audio0")
    return audioTrack
  }
  
  private func createVideoTrack() -> RTCVideoTrack {
    let videoSource = WebRTCClient.factory.videoSource()
    
    #if TARGET_OS_SIMULATOR
    self.videoCapturer = RTCFileVideoCapturer(delegate: videoSource)
    #else
    self.videoCapturer = RTCCameraVideoCapturer(delegate: videoSource)
    #endif
    
    let videoTrack = WebRTCClient.factory.videoTrack(with: videoSource, trackId: "video0")
    return videoTrack
  }
  
  // MARK: Data Channels
  private func createDataChannel() -> RTCDataChannel? {
    let config = RTCDataChannelConfiguration()
    guard let dataChannel = self.peerConnection!.dataChannel(forLabel: "WebRTCData", configuration: config) else {
      debugPrint("Warning: Couldn't create data channel.")
      return nil
    }
    return dataChannel
  }

创建本地的SDP并将发送给其他人

func offer(completion: @escaping (_ sdp: RTCSessionDescription) -> Void) {
    let constrains = RTCMediaConstraints(
      mandatoryConstraints: self.mediaConstrains,
      optionalConstraints: nil)
    self.peerConnection!.offer(for: constrains) { (sdp, error) in
      guard let sdp = sdp else {
        return
      }
      
      self.peerConnection!.setLocalDescription(sdp, completionHandler: { (error) in
        completion(sdp)
      })
    }
  }
  
  func send(sdp rtcSdp: RTCSessionDescription, to person: String) {
    do {
      let dataMessage = try self.encoder.encode(SessionDescription(from: rtcSdp))
      let dict = try JSONSerialization.jsonObject(with: dataMessage, options: .allowFragments) as! [String: Any]
      Firestore.firestore().collection(person).document("sdp").setData(dict) { (err) in
        if let err = err {
          print("Error send sdp: \(err)")
        } else {
          print("Sdp sent!")
        }
      }
    }
    catch {
      debugPrint("Warning: Could not encode sdp: \(error)")
    }
  }

将本地候选人发送给其他人

func send(candidate rtcIceCandidate: RTCIceCandidate, to person: String) {
    do {
      let dataMessage = try self.encoder.encode(IceCandidate(from: rtcIceCandidate))
      let dict = try JSONSerialization.jsonObject(with: dataMessage, options: .allowFragments) as! [String: Any]
      Firestore.firestore()
        .collection(person)
        .document("candidate")
        .collection("candidates")
        .addDocument(data: dict) { (err) in
          if let err = err {
            print("Error send candidate: \(err)")
          } else {
            print("Candidate sent!")
          }
      }
    }
    catch {
      debugPrint("Warning: Could not encode candidate: \(error)")
    }
  }

收听远程SDP和候选人

func listenSdp(from person: String) {
    Firestore.firestore().collection(person).document("sdp")
      .addSnapshotListener { documentSnapshot, error in
        guard let document = documentSnapshot else {
          print("Error fetching sdp: \(error!)")
          return
        }
        guard let data = document.data() else {
          print("Firestore sdp data was empty.")
          return
        }
        print("Firestore sdp data: \(data)")
        do {
          let jsonData = try JSONSerialization.data(withJSONObject: data, options: .prettyPrinted)
          let sessionDescription = try self.decoder.decode(SessionDescription.self, from: jsonData)
          self.delegate?.signalClient(self, didReceiveRemoteSdp: sessionDescription.rtcSessionDescription)
        }
        catch {
          debugPrint("Warning: Could not decode sdp data: \(error)")
          return
        }
    }
  }
  
  func listenCandidate(from person: String) {
    Firestore.firestore()
      .collection(person)
      .document("candidate")
      .collection("candidates")
      .addSnapshotListener { (querySnapshot, err) in
        guard let documents = querySnapshot?.documents else {
          print("Error fetching documents: \(err!)")
          return
        }

        querySnapshot!.documentChanges.forEach { diff in
          if (diff.type == .added) {
            do {
              let jsonData = try JSONSerialization.data(withJSONObject: documents.first!.data(), options: .prettyPrinted)
              let iceCandidate = try self.decoder.decode(IceCandidate.self, from: jsonData)
              self.delegate?.signalClient(self, didReceiveCandidate: iceCandidate.rtcIceCandidate)
            }
            catch {
              debugPrint("Warning: Could not decode candidate data: \(error)")
              return
            }
          }
        }
    }
  }

将 ans SDP发送到设备A

func answer(completion: @escaping (_ sdp: RTCSessionDescription) -> Void)  {
    let constrains = RTCMediaConstraints(mandatoryConstraints: self.mediaConstrains,
                                         optionalConstraints: nil)
    self.peerConnection!.answer(for: constrains) { (sdp, error) in
      guard let sdp = sdp else {
        return
      }
      
      self.peerConnection!.setLocalDescription(sdp, completionHandler: { (error) in
        completion(sdp)
      })
    }
  }

关闭对等连接

关闭对等连接，清除Firestore，重置变量并重新创建新的对等连接，以便为新会话做好准备

@IBAction func endCall(_ sender: Any) {
    self.signalClient.deleteSdpAndCandidate(for: self.currentPerson)
    self.webRTCClient.closePeerConnection()
    
    self.webRTCClient.createPeerConnection()
    self.hasLocalSdp = false
    self.localCandidateCount = 0
    self.hasRemoteSdp = false
    self.remoteCandidateCount = 0
  }
  
  func deleteSdpAndCandidate(for person: String) {
    Firestore.firestore().collection(person).document("sdp").delete() { err in
      if let err = err {
        print("Error removing firestore sdp: \(err)")
      } else {
        print("Firestore sdp successfully removed!")
      }
    }
    
    Firestore.firestore().collection(person).document("candidate").delete() { err in
      if let err = err {
        print("Error removing firestore candidate: \(err)")
      } else {
        print("Firestore candidate successfully removed!")
      }
    }
  }

func closePeerConnection() {
    self.peerConnection!.close()
    self.peerConnection = nil
  }