此代码处理新用户连接。

用户类别

class User{
  
  constructor(friendID){
    this.friendID = friendID;
    this.userName = null;
    this.myPeer = new RTCPeerConnection(servers);
    this.videoManager = new VideoManager();
    this.setup_events();
  }

  get name(){
    return this.userName;
  }

  get id(){
    return this.friendID;
  }

  setup_events(){ 

    let this_instance = this;

    this.myPeer.onicecandidate = function(event){ 
      if (event.candidate !== null){
        LOG("ICE CANDIDATE SEND TO " + this_instance.friendID);
        LOG_obj(event.candidate);
        socket.emit("ice-candidate", event.candidate, this_instance.friendID);
      }else{
        LOG("EMPTY CANDIDATE");
      }
    }
    this.myPeer.addEventListener('track', async(event) => {
      const [remoteStream] = event.streams;
      this_instance.videoManager.createVideo();
      this_instance.videoManager.setStream(remoteStream);
      LOG("ADDED stream to VideoObject");
    });
  }

  add_candidate(candidate){
    this.myPeer.addIceCandidate( new RTCIceCandidate(candidate) );
    LOG("CANDIDATE ADDED TO PEER");
  } 

  accept_offer(userOffer){
    this.myPeer.setRemoteDescription(new RTCSessionDescription(userOffer));
    LOG("ACCEPTED OFFER");
  }

  async create_offer(){

    MediaRules.get_MediaRules()
      .then( (mediaRules) => {

        navigator.mediaDevices.getUserMedia(mediaRules).then( (mediaStream) =>{
          let tracks = mediaStream.getTracks();

          tracks.forEach( track => { this.myPeer.addTrack(track, mediaStream); });

          LOG("ADDED ALL TRACKS");
        }).then( () => {
            this.myPeer.createOffer(mediaRules).then( (offerObj) => {
              
              this.myPeer.setLocalDescription(offerObj);
              socket.emit("user-offer", offerObj, this.friendID);
        });
      });
  });
  }

  accept_answer(userAnswer){
    this.myPeer.setRemoteDescription(new RTCSessionDescription(userAnswer));
    LOG("ACCEPTED ANSWER");
  }

  async create_answer(){

    MediaRules.get_MediaRules().then( (mediaRules) => {
      
      navigator.mediaDevices.getUserMedia(mediaRules).then( (mediaStream) => {
        let tracks = mediaStream.getTracks();
        tracks.forEach( track => { this.myPeer.addTrack(track, mediaStream); });
        LOG("ADDED ALL TRACKS");
      }).then( () => {
          this.myPeer.createAnswer(mediaRules).then( (answerObj) => {
            this.myPeer.setLocalDescription(answerObj); 
            socket.emit("user-answer", answerObj, this.friendID);
          });
        });
    });
  }
}

用户池

class UsersPool{
  
  constructor(){
    this.UsersMap = {};
  }

  addUser(userObj){
    this.UsersMap[userObj.id] = userObj;
  }

  accept_IceCandidate(candidateObject, user_id){
    this.UsersMap[user_id].add_candidate(candidateObject);
  }

  accept_Offer(offerObject, user_id){
    LOG("ACCEPT OFFER FROM " + user_id);
    this.UsersMap[user_id].accept_offer(offerObject);
  }

  accept_Answer(answerObject, user_id){
    this.UsersMap[user_id].accept_answer(answerObject);
  }

  async CreateSendOffer(user_id){
    await this.UsersMap[user_id].create_offer();
  }

  async CreateSendAnswer(user_id){
    await this.UsersMap[user_id].create_answer();
  }
}

媒体限制

class MediaConstraints{

  async get_MediaRules(){
    let mediaRules = { video: false, audio: false };

    let devicesEnum = await navigator.mediaDevices.enumerateDevices();

    devicesEnum.forEach( device => {
      if ( device.kind == "audioinput" ){
        mediaRules["audio"] = true;
      }
      else if ( device.kind == "videoinput"){
        mediaRules["video"] = true;
      }
    });
    return mediaRules;
  }
}

视频管理器（按用户创建视频元素）

class VideoManager {

  constructor(){
    this.videoObject = null;
  }

  createVideo(){
    let videoObject = document.createElement("video");
    let divVideo = document.createElement("div");

    videoObject.setAttribute('width', "600");
    videoObject.setAttribute('height', "800");

    divVideo.appendChild(videoObject); 

    document.body.appendChild(divVideo);

    this.videoObject = videoObject;
  }

  setStream(stream){
    this.videoObject.srcObject = stream; 
    this.videoObject.play();
  }
}

好吧，问题就在这里。icecandidate工作得很好，信令服务器也工作得很好。TURN/STUN服务器工作得很好。
我的主要问题是如何创建约束和设置正确提供和回答，如果用户A没有网络摄像头，但用户B有。此刻我得到的错误，STUN服务器坏了，但这是因为对等体无法完成彼此之间的连接建立。
如何使它，如果我只有麦克风在我的笔记本电脑上，但在其他笔记本电脑上我有视频和麦克风。
编辑0：看起来WebRTC不喜欢约束条件不同，如果用户A使用{video：假，音频：true}，并发送给用户B，用户B使用{video：真，音频：true}，则由于约束不同而连接失败。
我还是不明白为什么这是个问题。
编辑1：看起来唯一的方法是使用addTransceiver和手动控制媒体。