如何获取有关 WebRTC PeerConnection 连接类型的信息？

Question

有没有办法以编程方式获取有关 WebRTC 中使用的连接类型的信息？

例如，在我的应用中，我使用本地连接以及 STUN 和 TURN。如果候选人的类型是主机或中继，我可以从 ICE 候选人中收集，并且在服务器上我可以查看是否通过 STUN（连接启动）或 TURN（连接期间的稳定流）尝试连接。

到目前为止，我无法找到一种方法来访问有关浏览器中最终使用的连接类型的信息。有候选人，浏览器停止收集，然后有一个工作连接。浏览事件，但我找不到任何信息。

我知道 Chrome 在 peerconnection 上支持 getStats()，这使我可以访问 chrome://webrtc-internals 中的大部分信息，但我也没有在其中找到这些信息。

有没有办法从 javascript 访问这些信息？

非常感谢。

Answer 1

根据the specification（目前在 Firefox 中实现，但在 Chrome 中没有实现），您确实可以从候选对的可用统计数据中找出活跃的候选对象，它们是：

dictionary RTCIceCandidatePairStats : RTCStats {
    DOMString                     transportId;
    DOMString                     localCandidateId;
    DOMString                     remoteCandidateId;
    RTCStatsIceCandidatePairState state;
    unsigned long long            priority;
    boolean                       nominated;
    boolean                       writable;
    boolean                       readable;
    unsigned long long            bytesSent;
    unsigned long long            bytesReceived;
    double                        roundTripTime;
    double                        availableOutgoingBitrate;
    double                        availableIncomingBitrate;
};

结合个人候选人的统计数据：

dictionary RTCIceCandidateAttributes : RTCStats {
    DOMString                ipAddress;
    long                     portNumber;
    DOMString                transport;
    RTCStatsIceCandidateType candidateType;
    long                     priority;
    DOMString                addressSourceUrl;
};

使用peerConnection.getStats() 查找既已获得提名又已成功的ice 候选对：

pc.getStats(null))
.then(function(stats) {
  return Object.keys(stats).forEach(function(key) {
    if (stats[key].type == "candidatepair" &&
        stats[key].nominated && stats[key].state == "succeeded") {
      var remote = stats[stats[key].remoteCandidateId];
      console.log("Connected to: " + remote.ipAddress +":"+
                  remote.portNumber +" "+ remote.transport +
                  " "+ remote.candidateType);
    }
  });
})
.catch(function(e) { console.log(e.name); });

这可能会输出如下内容：

Connected to: 192.168.1.2:49190 udp host

您可以针对LAN range 进行测试。如果相反，它返回如下内容：

Connected to: 24.57.143.7:61102 udp relayed

那么你就会有一个 TURN 连接。

这里有一个 jsfiddle 显示了这一点（出于其他原因需要 Firefox 开发者版）。

Answer 2

jib 2015 年 3 月的回答非常有帮助，但不适用于 2019 年 3 月的 Firefox v65 或 Chrome v72（在 Windows 上）。需要两个更新：

1) “stats”值现在在两个浏览器中都具有 RTCStatsReport 类型，并且它是一个没有键的可迭代对象。因此，使用 forEach(report => {...}) 对其进行迭代，“report”将是一个对象，其键类似于 jib 为“stats”显示的键。

2) "candidatepair" 不是 report.type 的有效值，但 "candidate-pair" 是。

Answer 3

我花了很长时间才做到这一点，所以希望这对某人有所帮助。

新方式

您现在可以从 RTCPeerConnection 中获取选定的候选对，而无需 stats api：

const pair = rtcConnection.sctp.transport.iceTransport.getSelectedCandidatePair();
console.log(pair.remote.type);

在撰写本文时（2020 年 10 月 2 日），这仅适用于 Chromium。 您仍然可以将 stats api 用于其他浏览器。 另请注意jib 下面的评论，这仅在您有 DataChannel 时才有效。

对于不支持 getSelectedCandidatePair() 的浏览器

根据https://developer.mozilla.org/en-US/docs/Web/API/RTCIceCandidatePairStats （在页面底部的selected 属性。

确定所选候选对的符合规范的方法是查找传输类型的统计对象，它是一个 RTCTransportStats 对象。该对象的 selectedCandidatePairId 属性指示指定的传输是否是正在使用的传输。

因此尝试使用stat.nominated && stats.state == "succeeded" 查找选定的对并不是正确的方法。

相反，您可以通过查看transport 统计数据中的选定对来获取它。 Firefox 不支持这一点，但幸运的是，Firefox 的候选对中有一个非标准的 selected 属性。

const stats = await rtcConnection.getStats();
if(stats){
    let selectedPairId = null;
    for(const [key, stat] of stats){
        if(stat.type == "transport"){
            selectedPairId = stat.selectedCandidatePairId;
            break;
        }
    }
    let candidatePair = stats.get(selectedPairId);
    if(!candidatePair){
        for(const [key, stat] of stats){
            if(stat.type == "candidate-pair" && stat.selected){
                candidatePair = stat;
                break;
            }
        }
    }

    if(candidatePair){
        for(const [key, stat] of stats){
            if(key == candidatePair.remoteCandidateId){
                return stat.candidateType;
            }
        }
    }
}

Answer 4

感谢@DavidP 和more in-depth answer，我编写了下面的代码来获取 ICE Candidates 类型。

更新代码： 使用 conncectionStats 获取 ICE 候选人

    function getCandidateIds(stats) {
        let ids = {}
        stats.forEach(report => {
            if (report.type == "candidate-pair" && report.nominated && report.state == "succeeded") {
                //console.log("Found IDs")
                ids = {
                    localId: report.localCandidateId,
                    remoteId: report.remoteCandidateId
                }
            }
        });
        return ids
    }

    function getCandidateInfo(stats, candidateId) {
        let info = null
        stats.forEach(report => {
            if (report.id == candidateId) {
                console.log("Found Candidate")
                info = report
            }
        })
        return info
    }

    async function conncectionStats() {
        const stats = await this.pc.getStats(null)
        const candidates = await this.getCandidateIds(stats)
        console.log("candidates: ", candidates)
        if (candidates !== {}) {
            const localCadidate = await this.getCandidateInfo(stats, candidates.localId)
            const remoteCadidate = await this.getCandidateInfo(stats, candidates.remoteId)
            if (localCadidate !== null && remoteCadidate !== null) {
                return [localCadidate, remoteCadidate]
            }
        }
        // we did not find the candidates for whatever reeason
        return [null, null]
    }

读取IP：

  let myAddress = ""
  let peerAddress = ""
  if (localCadidate.hasOwnProperty("ip")){
    myAddress = localCadidate.ip
    peerAddress = remoteCadidate.ip
  } else {
    myAddress = localCadidate.address
    peerAddress = remoteCadidate.address
  }

旧版本：

function getConnectionDetails(pc){
  pc.getStats(null)
  .then(function(stats) {
        stats.forEach(report => {
          if (report.type == "candidate-pair" 
              && report.nominated 
              && report.state == "succeeded")
          {
            console.log( "Local ICE:", report.localCandidateId)
            console.log( "Remote ICE:",report.remoteCandidateId)
            getCandidates(pc, report.localCandidateId, report.remoteCandidateId)
          }
      });
  })
  .catch(function(e) { console.log(e.name); });
};

function getCandidates(pc, localId, remoteId){
  //console.log("looking for candidates")
  pc.getStats(null)
  .then(function(stats) {
        stats.forEach(report => {
          if (report.id == localId) {
              console.log("Local: Type:", report.candidateType," IP:", report.ip)
          } else if (report.id == remoteId){
              console.log("Remote: Type:", report.candidateType," IP:", report.ip)
          }
      })
  })
  .catch(function(e) { console.log(e.name); });
}

根据应提取的信息，您可能不需要两个候选人。