Webrtc 无法设置本地应答sdp:在错误状态下调用：kStable

几天来，我一直在努力让我的webRTC客户端正常工作，我不知道自己做错了什么。 我正在尝试创建多点webrtc客户端，并使用Chrome对双方进行测试。 当被叫方收到呼叫并创建应答时，我得到以下错误：

Failed to set local answer sdp: Called in wrong state: kStable

接收端正确建立两个视频连接，并显示本地和远程流。但是打电话的人似乎没有收到被叫人的答复。有人能告诉我我做错了什么吗

下面是我正在使用的代码（这是一个精简版本，仅用于显示相关部分并使其更具可读性）

class WebRTC\u客户端
{
私有peerConns={}；
私有sendAudioByDefault=true；
private sendVideoByDefault=true；
私人要约={
offerToReceiveAudio：正确，
offerToReceiveVideo：正确
};
私有约束={
“音频”：正确，
“视频”：{
帧率：5，
宽度：256，
身高：194
}
};
专用服务器SCFG={
ICEServer：[{
网址：[“stun:stun.l.google.com:19302”]
}]
};
专用信号通道；
公共建造商（信号通道）{
this.SignalingChannel=SignalingChannel；
这个。bindingHandlers（）；
}
/*...*/
私有数据流（数据流）{
（窗口）.localStream=stream；
此.videoAssets[0].srcObject=stream；
}
私有stopLocalTracks（）{}
私人启动（）{
var self=这个；
如果（！this.isReady（））{
错误（'无法启动WebRTC，因为尚未分配WebSocket用户连接ID'）；
}
this.buttonStart.disabled=true；
this.stopLocalTracks（）；
navigator.mediaDevices.getUserMedia（this.GetConstraints（））
。然后（（流）=>{
self.gotStream（stream）；
self.SignalingChannel.send（JSON.stringify（{type:'onreadyfortaemspeak'}））；
})
.catch（函数（错误）{trace（'getUserMedia错误：'，错误）；}）；
}
公共addPeerId（peerId）{
this.availablepeerinds[peerId]=peerId；
此.preparePeerConnection（peerId）；
}
专用preparePeerConnection（peerId）{
var self=这个；
if（this.peerConns[peerId]）{
返回；
}
this.peerConns[peerId]=新的RTCPeerConnection（this.serversCfg）；
this.peerConns[peerId].ontrack=function（evt）{self.gotmotestream（evt，peerId）；}；
this.peerConns[peerId].onicecandidate=function（evt）{self.iceCallback（evt，peerId）；}；
this.peerConns[peerId].onnegotiationneeded=function（evt）{if（self.isCallingTo（peerId））{self.createOffer（peerId）；}；
这个.addLocalTracks（peerId）；
}
专用addLocalTracks（peerId）{
var self=这个；
var localtrackscont=0；
（window.localStream.getTracks（）.forEach(
功能（轨道）{
self.peerConns[peerId].addTrack(
轨道，
（窗口）.localStream
);
LocalTrackScont++；
}
);
跟踪（“将“+LocalTrackScont+”本地跟踪添加到远程对等方”#“+peerId）；
}
私人电话（）{
var self=这个；
跟踪（“开始调用所有可用的新对等方（如果有））；
//只有在有人打电话时才打电话
if（！Object.keys（this.availablepejerids.length）{
trace（“据我所知，没有可调用的对等方”）；
返回；
}
for（让peerId在这个.availablepecids中）{
如果（！this.availablepecids.hasOwnProperty（peerId））{
继续；
}
此.preparePeerConnection（peerId）；
}
}
私人createOffer（peerId）{
var self=这个；
this.peerConns[peerId].createOffer（this.offerOptions）
.then（函数（提供）{返回self.peerConns[peerId].setLocalDescription（提供）；}）
.然后（函数（）{
trace（‘向对等方发送报价#’+peerId）；
self.SignalingChannel.send（JSON.stringify（{“sdp”：self.peerConns[peerrid].localDescription，“remotePeerId”：peerrid，type:“onwebrtpeerconn”}））；
})
.catch（函数（错误）{self.onCreateSessionDescriptionError（错误）；}）；
}
私人应答电话（peerId）{
var self=这个；
trace（‘接听同伴的电话#’+peerId）；
this.peerConns[peerId].createAnswer（）
.then（函数（答案）{返回self.peerConns[peerId].setLocalDescription（答案）；}）
.然后（函数（）{
trace（‘将答案发送给对等方#’+peerId）；
self.SignalingChannel.send（JSON.stringify（{“sdp”：self.peerConns[peerrid].localDescription，“remotePeerId”：peerrid，type:“onwebrtpeerconn”}））；
})
.catch（函数（错误）{self.onCreateSessionDescriptionError（错误）；}）；
}
private onCreateSessionDescriptionError（错误）{
console.warn（'未能创建会话描述：'+error.toString（））；
}
私有gotmotestream（e，peerId）{
if（this.audioAssets[peerId].srcObject！==e.streams[0]）{
this.videoAssets[peerId].srcObject=e.streams[0]；
跟踪（“向DOM添加了远程对等方的流源”#“+peerId+”）；
}
}
私有iceCallback（事件，peerId）{
this.SignalingChannel.send（JSON.stringify（{“candidate”：event.candidate，“remotePeerId”：peerId，“type”：“onwebrtpeerconn”}）；
}
私人handleCandidate（候选人，peerId）{
this.peerConns[peerId].addIceCandidate（候选）
.那么(
这是一次成功，
此.onAddIceCandidateError
);
trace（'Peer#'+peerId+'：新的ICE候选：'+（候选？候选.c）
class WebRTC_Client
{
    private peerConns = {};
    private sendAudioByDefault = true;
    private sendVideoByDefault = true;
    private offerOptions = {
        offerToReceiveAudio: true,
        offerToReceiveVideo: true
    };
    private constraints = {
        "audio": true,
        "video": {
            frameRate: 5,
            width: 256,
            height: 194
        }
    };
    private serversCfg = {
        iceServers: [{
            urls: ["stun:stun.l.google.com:19302"]
        }]
    };
    private SignalingChannel;

    public constructor(SignalingChannel){
        this.SignalingChannel = SignalingChannel;
        this.bindSignalingHandlers();
    }

    /*...*/

    private gotStream(stream) {
        (<any>window).localStream = stream;
        this.videoAssets[0].srcObject = stream;
     }

    private stopLocalTracks(){}

    private start() {
        var self = this;

        if( !this.isReady() ){
            console.error('Could not start WebRTC because no WebSocket user connectionId had been assigned yet');
        }

        this.buttonStart.disabled = true;

        this.stopLocalTracks();

        navigator.mediaDevices.getUserMedia(this.getConstrains())
            .then((stream) => {
                self.gotStream(stream);
                self.SignalingChannel.send(JSON.stringify({type: 'onReadyForTeamspeak'}));
            })
            .catch(function(error) { trace('getUserMedia error: ', error); });
    }

    public addPeerId(peerId){
        this.availablePeerIds[peerId] = peerId;
        this.preparePeerConnection(peerId);
    }

    private preparePeerConnection(peerId){
        var self = this;

        if( this.peerConns[peerId] ){
            return;
        }

        this.peerConns[peerId] = new RTCPeerConnection(this.serversCfg);
        this.peerConns[peerId].ontrack = function (evt) { self.gotRemoteStream(evt, peerId); };
        this.peerConns[peerId].onicecandidate = function (evt) { self.iceCallback(evt, peerId); };
        this.peerConns[peerId].onnegotiationneeded = function (evt) { if( self.isCallingTo(peerId) ) { self.createOffer(peerId); } };

        this.addLocalTracks(peerId);
    }

    private addLocalTracks(peerId){
        var self = this;

        var localTracksCount = 0;
        (<any>window).localStream.getTracks().forEach(
            function (track) {
                self.peerConns[peerId].addTrack(
                    track,
                    (<any>window).localStream
            );
                localTracksCount++;
            }
        );
        trace('Added ' + localTracksCount + ' local tracks to remote peer #' + peerId);
    }

    private call() {
        var self = this;

        trace('Start calling all available new peers if any available');

        // only call if there is anyone to call
        if( !Object.keys(this.availablePeerIds).length ){
            trace('There are no callable peers available that I know of');
            return;
        }

        for( let peerId in this.availablePeerIds ){
            if( !this.availablePeerIds.hasOwnProperty(peerId) ){
                continue;
            }
            this.preparePeerConnection(peerId);
        }
    }

    private createOffer(peerId){
        var self = this;

        this.peerConns[peerId].createOffer( this.offerOptions )
            .then( function (offer) { return self.peerConns[peerId].setLocalDescription(offer); } )
            .then( function () {
                trace('Send offer to peer #' + peerId);
                self.SignalingChannel.send(JSON.stringify({ "sdp": self.peerConns[peerId].localDescription, "remotePeerId": peerId, "type": "onWebRTCPeerConn" }));
            })
            .catch(function(error) { self.onCreateSessionDescriptionError(error); });
    }

    private answerCall(peerId){
        var self = this;

        trace('Answering call from peer #' + peerId);

        this.peerConns[peerId].createAnswer()
            .then( function (answer) { return self.peerConns[peerId].setLocalDescription(answer); } )
            .then( function () {
                trace('Send answer to peer #' + peerId);
                self.SignalingChannel.send(JSON.stringify({ "sdp": self.peerConns[peerId].localDescription, "remotePeerId": peerId, "type": "onWebRTCPeerConn" }));
            })
            .catch(function(error) { self.onCreateSessionDescriptionError(error); });
    }

    private onCreateSessionDescriptionError(error) {
        console.warn('Failed to create session description: ' + error.toString());
    }

    private gotRemoteStream(e, peerId) {
        if (this.audioAssets[peerId].srcObject !== e.streams[0]) {
            this.videoAssets[peerId].srcObject = e.streams[0];
            trace('Added stream source of remote peer #' + peerId + ' to DOM');
        }
    }

    private iceCallback(event, peerId) {
        this.SignalingChannel.send(JSON.stringify({ "candidate": event.candidate, "remotePeerId": peerId, "type": "onWebRTCPeerConn" }));
    }

    private handleCandidate(candidate, peerId) {
        this.peerConns[peerId].addIceCandidate(candidate)
            .then(
                this.onAddIceCandidateSuccess,
                this.onAddIceCandidateError
            );
        trace('Peer #' + peerId + ': New ICE candidate: ' + (candidate ? candidate.candidate : '(null)'));
    }

    private onAddIceCandidateSuccess() {
        trace('AddIceCandidate success.');
    }

    private onAddIceCandidateError(error) {
        console.warn('Failed to add ICE candidate: ' + error.toString());
    }

    private hangup() {}

    private bindSignalingHandlers(){
        this.SignalingChannel.registerHandler('onWebRTCPeerConn', (signal) => this.handleSignals(signal));
    }

    private handleSignals(signal){
        var self = this,
            peerId = signal.connectionId;

        if( signal.sdp ) {
            trace('Received sdp from peer #' + peerId);

            this.peerConns[peerId].setRemoteDescription(new RTCSessionDescription(signal.sdp))
                .then( function () {
                    if( self.peerConns[peerId].remoteDescription.type === 'answer' ){
                        trace('Received sdp answer from peer #' + peerId);
                    } else if( self.peerConns[peerId].remoteDescription.type === 'offer' ){
                        trace('Received sdp offer from peer #' + peerId);
                        self.answerCall(peerId);
                    } else {
                        trace('Received sdp ' + self.peerConns[peerId].remoteDescription.type + ' from peer #' + peerId);
                    }
                })
                .catch(function(error) { trace('Unable to set remote description for peer #' + peerId + ': ' + error); });
        } else if( signal.candidate ){
            this.handleCandidate(new RTCIceCandidate(signal.candidate), peerId);
        } else if( signal.closeConn ){
            trace('Closing signal received from peer #' + peerId);
            this.endCall(peerId,true);
        }
    }
}

.then( function (answer) { return self.peerConns[peerId].setLocalDescription(answer); } )

     var callback = function (answer) {
         createdDescription(answer, fromId);
     };
     peerConnection[fromId].createAnswer().then(callback).catch(errorHandler);


    function createdDescription(description, fromId) {
        console.log('Got description');

        peerConnection[fromId].setLocalDescription(description).then(function() {
            console.log("Sending SDP:", fromId, description);
            serverConnection.emit('signal', fromId, {'sdp': description});
        }).catch(errorHandler);
    }

let pc1 = new RTCPeerConnection(), pc2 = new RTCPeerConnection(), stream, videoTrack, videoSender;

(async () => {
  try {
    stream = await navigator.mediaDevices.getUserMedia({video: true, audio: true});
    videoTrack = stream.getVideoTracks()[0];
    pc1.addTrack(stream.getAudioTracks()[0], stream);
  } catch (e) {
    console.log(e);  
  }
})();

checkbox.onclick = () => {
  if (checkbox.checked) {
    videoSender = pc1.addTrack(videoTrack, stream);
  } else {
    pc1.removeTrack(videoSender);
  }
}

pc2.ontrack = e => {
  video.srcObject = e.streams[0];
  e.track.onended = e => video.srcObject = video.srcObject; // Chrome/Firefox bug
}

pc1.onicecandidate = e => pc2.addIceCandidate(e.candidate);
pc2.onicecandidate = e => pc1.addIceCandidate(e.candidate);
pc1.onnegotiationneeded = async e => {
  try {
    await pc1.setLocalDescription(await pc1.createOffer());
    await pc2.setRemoteDescription(pc1.localDescription);
    await pc2.setLocalDescription(await pc2.createAnswer());
    await pc1.setRemoteDescription(pc2.localDescription);
  } catch (e) {
    console.log(e);  
  }
}

pc1.onicecandidate = e => pc2.addIceCandidate(e.candidate);
pc2.onicecandidate = e => pc1.addIceCandidate(e.candidate);

var isNegotiating = false;  // Workaround for Chrome: skip nested negotiations
pc1.onnegotiationneeded = async e => {
  if (isNegotiating) {
    console.log("SKIP nested negotiations");
    return;
  }
  isNegotiating = true;
  try {
    await pc1.setLocalDescription(await pc1.createOffer());
    await pc2.setRemoteDescription(pc1.localDescription);
    await pc2.setLocalDescription(await pc2.createAnswer());
    await pc1.setRemoteDescription(pc2.localDescription);
  } catch (e) {
    console.log(e);  
  }
}

pc1.onsignalingstatechange = (e) => {  // Workaround for Chrome: skip nested negotiations
  isNegotiating = (pc1.signalingState != "stable");
}