1. Einführung
WebRTC ist ein Open-Source-Projekt, das die Echtzeitkommunikation von Audio, Video und Daten in Web- und systemeigenen Apps ermöglicht.
WebRTC bietet mehrere JavaScript-APIs. Klicken Sie auf die Links, um sich Demos anzusehen.
getUserMedia(): Audio- und Videodaten erfassen.MediaRecorder: Audio- und Videoaufnahmen machen.RTCPeerConnection: Audio- und Videodaten zwischen Nutzern streamen.RTCDataChannel: Daten zwischen Nutzern streamen.
Wo kann ich WebRTC verwenden?
In Firefox, Opera und Chrome auf Computern und Android-Geräten. WebRTC ist auch für systemeigene Apps unter iOS und Android verfügbar.
Was ist Signalisierung?
WebRTC verwendet RTCPeerConnection, um Streamingdaten zwischen Browsern zu übertragen. Es ist jedoch auch ein Mechanismus erforderlich, um die Kommunikation zu koordinieren und Steuerungsnachrichten zu senden. Dieser Prozess wird als Signalisierung bezeichnet. Signalisierungsmethoden und -protokolle werden von WebRTC nicht angegeben. In diesem Codelab verwenden Sie Socket.IO für Nachrichten, es gibt aber viele Alternativen.
Was sind STUN und TURN?
WebRTC ist für die Peer-to-Peer-Kommunikation konzipiert, sodass Nutzer sich über den direktesten Weg verbinden können. WebRTC ist jedoch für die reale Netzwerkumgebung konzipiert: Clientanwendungen müssen NAT-Gateways und Firewalls passieren und Peer-to-Peer-Netzwerke benötigen Fallbacks, falls die direkte Verbindung fehlschlägt. Im Rahmen dieses Prozesses verwenden die WebRTC-APIs STUN-Server, um die IP-Adresse Ihres Computers abzurufen, und TURN-Server, die als Relay-Server fungieren, falls die Peer-to-Peer-Kommunikation fehlschlägt. (WebRTC in der Praxis enthält weitere Informationen.)
Ist WebRTC sicher?
Die Verschlüsselung ist für alle WebRTC-Komponenten obligatorisch und die JavaScript APIs können nur von sicheren Ursprüngen (HTTPS oder localhost) verwendet werden. Signalisierungsmechanismen sind nicht durch WebRTC-Standards definiert. Sie müssen also selbst dafür sorgen, dass sichere Protokolle verwendet werden.
2. Übersicht
Erstellen Sie eine App, um Videos und Schnappschüsse mit Ihrer Webcam aufzunehmen und sie über WebRTC mit anderen zu teilen. Dabei erfahren Sie, wie Sie die wichtigsten WebRTC APIs verwenden und einen Messaging-Server mit Node.js einrichten.
Lerninhalte
- Video von deiner Webcam abrufen
- Video mit RTCPeerConnection streamen
- Daten mit RTCDataChannel streamen
- Signalisierungsdienst zum Austausch von Nachrichten einrichten
- Peer-to-Peer-Verbindung und Signalisierung kombinieren
- Foto aufnehmen und über einen Datenkanal teilen
Voraussetzungen
- Chrome 47 oder höher
- Web Server for Chrome oder einen anderen Webserver Ihrer Wahl.
- Der Beispielcode
- Texteditor
- Grundkenntnisse in HTML, CSS und JavaScript
3. Beispielcode abrufen
Code herunterladen
Wenn Sie mit Git vertraut sind, können Sie den Code für dieses Codelab von GitHub herunterladen, indem Sie ihn klonen:
git clone https://github.com/googlecodelabs/webrtc-web
Alternativ können Sie auf den folgenden Button klicken, um eine ZIP-Datei des Codes herunterzuladen:
Öffnen Sie die heruntergeladene ZIP-Datei. Dadurch wird ein Projektordner (adaptive-web-media) entpackt, der für jeden Schritt dieses Codelabs einen Ordner sowie alle erforderlichen Ressourcen enthält.
Sie erledigen alle Programmierarbeiten im Verzeichnis work.
Die Ordner step-nn enthalten eine fertige Version für jeden Schritt dieses Codelabs. Sie sind als Referenz verfügbar.
Webserver installieren und prüfen
Sie können zwar Ihren eigenen Webserver verwenden, dieses Codelab ist jedoch für die Verwendung mit dem Chrome-Webserver konzipiert. Wenn Sie diese App noch nicht installiert haben, können Sie sie aus dem Chrome Web Store installieren.

Nachdem Sie die App Web Server for Chrome installiert haben, klicken Sie in der Lesezeichenleiste, auf der Seite „Neuer Tab“ oder im App Launcher auf die Verknüpfung „Chrome-Apps“:

Klicken Sie auf das Webserver-Symbol:

Als Nächstes wird dieses Dialogfeld angezeigt, in dem Sie Ihren lokalen Webserver konfigurieren können:

Klicken Sie auf ORDNER AUSWÄHLEN und wählen Sie den Ordner work aus, den Sie gerade erstellt haben. So können Sie Ihre Arbeit in Chrome über die URL aufrufen, die im Dialogfeld „Web Server“ im Bereich Web Server URL(s) hervorgehoben ist.
Klicken Sie unter Optionen das Kästchen neben „index.html“ automatisch anzeigen an, wie hier zu sehen:

Beenden Sie den Server und starten Sie ihn neu, indem Sie den Schieberegler Web Server: STARTED nach links und dann wieder nach rechts schieben.

Rufen Sie jetzt die Website für Ihre Arbeit im Webbrowser auf, indem Sie auf die hervorgehobene Webserver-URL klicken. Sie sollten eine Seite sehen, die so aussieht und work/index.html entspricht:

Diese Anwendung ist natürlich noch nicht besonders interessant. Bisher ist sie nur ein minimales Gerüst, mit dem wir prüfen, ob Ihr Webserver ordnungsgemäß funktioniert. In den folgenden Schritten fügen Sie Funktionen und Layout-Features hinzu.
4. Video von der Webcam streamen
Lerninhalte
In diesem Schritt erfahren Sie, wie Sie:
- Videostream von deiner Webcam abrufen
- Streamwiedergabe bearbeiten.
- CSS und SVG verwenden, um Videos zu bearbeiten
Eine vollständige Version dieses Schritts finden Sie im Ordner step-01.
Ein bisschen HTML…
Fügen Sie der Datei index.html im Verzeichnis work ein video-Element und ein script-Element hinzu:
<!DOCTYPE html>
<html>
<head>
<title>Realtime communication with WebRTC</title>
<link rel="stylesheet" href="css/main.css">
</head>
<body>
<h1>Realtime communication with WebRTC</h1>
<video autoplay playsinline></video>
<script src="js/main.js"></script>
</body>
</html>
…und ein wenig JavaScript
Fügen Sie der Datei main.js im Ordner js Folgendes hinzu:
'use strict';
// On this codelab, you will be streaming only video (video: true).
const mediaStreamConstraints = {
video: true,
};
// Video element where stream will be placed.
const localVideo = document.querySelector('video');
// Local stream that will be reproduced on the video.
let localStream;
// Handles success by adding the MediaStream to the video element.
function gotLocalMediaStream(mediaStream) {
localStream = mediaStream;
localVideo.srcObject = mediaStream;
}
// Handles error by logging a message to the console with the error message.
function handleLocalMediaStreamError(error) {
console.log('navigator.getUserMedia error: ', error);
}
// Initializes media stream.
navigator.mediaDevices.getUserMedia(mediaStreamConstraints)
.then(gotLocalMediaStream).catch(handleLocalMediaStreamError);
Jetzt ausprobieren
Öffnen Sie index.html in Ihrem Browser. Sie sollten dann etwas Ähnliches wie das hier sehen (natürlich mit dem Bild Ihrer Webcam):

Funktionsweise
Nach dem Aufruf von getUserMedia() fordert der Browser den Nutzer auf, den Zugriff auf die Kamera zu erlauben (wenn dies das erste Mal ist, dass der Zugriff auf die Kamera für den aktuellen Ursprung angefordert wurde). Bei Erfolg wird ein MediaStream zurückgegeben, der von einem Medienelement mit dem Attribut srcObject verwendet werden kann:
navigator.mediaDevices.getUserMedia(mediaStreamConstraints)
.then(gotLocalMediaStream).catch(handleLocalMediaStreamError);
}
function gotLocalMediaStream(mediaStream) {
localVideo.srcObject = mediaStream;
}
Mit dem Argument constraints können Sie angeben, welche Medien abgerufen werden sollen. In diesem Beispiel wird nur Video übertragen, da Audio standardmäßig deaktiviert ist:
const mediaStreamConstraints = {
video: true,
};
Sie können Einschränkungen für zusätzliche Anforderungen wie die Videoauflösung verwenden:
const hdConstraints = {
video: {
width: {
min: 1280
},
height: {
min: 720
}
}
}
In der MediaTrackConstraints-Spezifikation sind alle potenziellen Einschränkungstypen aufgeführt. Es werden jedoch nicht alle Optionen von allen Browsern unterstützt. Wenn die angeforderte Auflösung von der ausgewählten Kamera nicht unterstützt wird, wird getUserMedia() mit einem OverconstrainedError abgelehnt und der Nutzer wird nicht aufgefordert, die Berechtigung für den Zugriff auf seine Kamera zu erteilen.
Wenn getUserMedia() erfolgreich ist, wird der Videostream von der Webcam als Quelle des Videoelements festgelegt:
function gotLocalMediaStream(mediaStream) {
localVideo.srcObject = mediaStream;
}
Bonuspunkte
- Das an
getUserMedia()übergebenelocalStream-Objekt befindet sich im globalen Bereich, sodass Sie es über die Browserkonsole prüfen können: Öffnen Sie die Konsole, geben Sie stream ein und drücken Sie die Eingabetaste. (Wenn Sie die Konsole in Chrome aufrufen möchten, drücken Sie „Strg + Umschalttaste + J“ oder „Befehlstaste + Wahltaste + J“ auf einem Mac.) - Was gibt
localStream.getVideoTracks()zurück? - Versuche,
localStream.getVideoTracks()[0].stop()anzurufen. - Sehen Sie sich das Einschränkungsobjekt an: Was passiert, wenn Sie es in
{audio: true, video: true}ändern? - Wie groß ist das Videoelement? Wie können Sie die natürliche Größe des Videos im Gegensatz zur Anzeigegröße über JavaScript abrufen? Verwenden Sie die Chrome-Entwicklertools, um das zu prüfen.
- Fügen Sie dem Videoelement CSS-Filter hinzu. Beispiel:
video {
filter: blur(4px) invert(1) opacity(0.5);
}
- Versuchen Sie, SVG-Filter hinzuzufügen. Beispiel:
video {
filter: hue-rotate(180deg) saturate(200%);
}
Das haben Sie gelernt
In diesem Schritt haben Sie Folgendes gelernt:
- Video von deiner Webcam abrufen.
- Legen Sie Medienbeschränkungen fest.
- Das Videoelement verändern.
Eine vollständige Version dieses Schritts finden Sie im Ordner step-01.
Tipps
- Vergiss nicht, das Attribut
autoplayim Elementvideoanzugeben. Andernfalls wird nur ein einzelner Frame angezeigt. - Es gibt noch viele weitere Optionen für
getUserMedia()-Einschränkungen. Sehen Sie sich die Demo unter webrtc.github.io/samples/src/content/peerconnection/constraints an. Wie Sie sehen werden, gibt es auf dieser Website viele interessante WebRTC-Beispiele.
Best Practice
- Achten Sie darauf, dass das Videoelement nicht über den Container hinausgeht. Wir haben
widthundmax-widthhinzugefügt, um eine bevorzugte und eine maximale Größe für das Video festzulegen. Der Browser berechnet die Höhe automatisch:
video {
max-width: 100%;
width: 320px;
}
Als Nächstes
Du hast ein Video, aber wie streamst du es? Das erfährst du im nächsten Schritt.
5. Video mit RTCPeerConnection streamen
Lerninhalte
In diesem Schritt erfahren Sie, wie Sie:
- Browserunterschiede mit dem WebRTC-Shim adapter.js abstrahieren
- Verwenden Sie die RTCPeerConnection API, um Videos zu streamen.
- Medienaufnahme und -streaming steuern
Eine vollständige Version dieses Schritts finden Sie im Ordner step-2.
Was ist RTCPeerConnection?
RTCPeerConnection ist eine API für WebRTC-Anrufe, um Video- und Audioinhalte zu streamen und Daten auszutauschen.
In diesem Beispiel wird eine Verbindung zwischen zwei RTCPeerConnection-Objekten (Peers) auf derselben Seite eingerichtet.
Nicht sehr praktisch, aber gut, um zu verstehen, wie RTCPeerConnection funktioniert.
Videoelemente und Steuerungstasten hinzufügen
Ersetzen Sie in index.html das einzelne Videoelement durch zwei Videoelemente und drei Schaltflächen:
<video id="localVideo" autoplay playsinline></video>
<video id="remoteVideo" autoplay playsinline></video>
<div>
<button id="startButton">Start</button>
<button id="callButton">Call</button>
<button id="hangupButton">Hang Up</button>
</div>
In einem Videoelement wird der Stream von getUserMedia() angezeigt, im anderen dasselbe Video, das über RTCPeerConnection gestreamt wird. (In einer realen Anwendung würde ein Videoelement den lokalen Stream und das andere den Remote-Stream anzeigen.)
Adapter.js-Shim hinzufügen
Fügen Sie über dem Link zu main.js einen Link zur aktuellen Version von adapter.js hinzu:
<script src="https://webrtc.github.io/adapter/adapter-latest.js"></script>
Index.html sollte jetzt so aussehen:
<!DOCTYPE html>
<html>
<head>
<title>Realtime communication with WebRTC</title>
<link rel="stylesheet" href="css/main.css">
</head>
<body>
<h1>Realtime communication with WebRTC</h1>
<video id="localVideo" autoplay playsinline></video>
<video id="remoteVideo" autoplay playsinline></video>
<div>
<button id="startButton">Start</button>
<button id="callButton">Call</button>
<button id="hangupButton">Hang Up</button>
</div>
<script src="https://webrtc.github.io/adapter/adapter-latest.js"></script>
<script src="js/main.js"></script>
</body>
</html>
RTCPeerConnection-Code installieren
Ersetzen Sie main.js durch die Version im Ordner step-02.
Anruf starten
Öffnen Sie index.html, klicken Sie auf Start, um das Video von Ihrer Webcam abzurufen, und klicken Sie auf Call, um die Peer-Verbindung herzustellen. In beiden Videoelementen sollte dasselbe Video (von Ihrer Webcam) zu sehen sein. Rufen Sie die Browserkonsole auf, um das WebRTC-Logging zu sehen.
Funktionsweise
Dieser Schritt ist sehr wichtig…
WebRTC verwendet die RTCPeerConnection API, um eine Verbindung für das Streamen von Videos zwischen WebRTC-Clients (Peers) herzustellen.
In diesem Beispiel befinden sich die beiden RTCPeerConnection-Objekte auf derselben Seite: pc1 und pc2. Nicht sehr praktisch, aber gut, um die Funktionsweise der APIs zu demonstrieren.
Das Einrichten eines Anrufs zwischen WebRTC-Peers umfasst drei Aufgaben:
- Erstellen Sie für jedes Ende des Anrufs eine RTCPeerConnection und fügen Sie an jedem Ende den lokalen Stream aus
getUserMedia()hinzu. - Netzwerkinformationen abrufen und freigeben: Potenzielle Verbindungsendpunkte werden als ICE-Kandidaten bezeichnet.
- Lokale und Remote-Beschreibungen abrufen und freigeben: Metadaten zu lokalen Medien im SDP-Format.
Angenommen, Alice und Bob möchten RTCPeerConnection verwenden, um einen Videoanruf einzurichten.
Zuerst tauschen Alice und Bob Netzwerkinformationen aus. Der Ausdruck „Kandidaten finden“ bezieht sich auf den Prozess, bei dem Netzwerkschnittstellen und Ports mithilfe des ICE-Frameworks gefunden werden.
- Alice erstellt ein RTCPeerConnection-Objekt mit einem
onicecandidate (addEventListener('icecandidate'))-Handler. Dies entspricht dem folgenden Code aus main.js:
let localPeerConnection;
localPeerConnection = new RTCPeerConnection(servers);
localPeerConnection.addEventListener('icecandidate', handleConnection);
localPeerConnection.addEventListener(
'iceconnectionstatechange', handleConnectionChange);
- Alice ruft
getUserMedia()auf und fügt den Stream hinzu, der an diese Methode übergeben wurde:
navigator.mediaDevices.getUserMedia(mediaStreamConstraints).
then(gotLocalMediaStream).
catch(handleLocalMediaStreamError);
function gotLocalMediaStream(mediaStream) {
localVideo.srcObject = mediaStream;
localStream = mediaStream;
trace('Received local stream.');
callButton.disabled = false; // Enable call button.
}
localPeerConnection.addStream(localStream);
trace('Added local stream to localPeerConnection.');
- Der
onicecandidate-Handler aus Schritt 1 wird aufgerufen, wenn Netzwerkkandidaten verfügbar sind. - Alice sendet serialisierte Kandidatendaten an Bob. In einer echten Anwendung erfolgt dieser Prozess (auch als Signalisierung bezeichnet) über einen Messaging-Dienst. Wie das funktioniert, erfahren Sie in einem späteren Schritt. In diesem Schritt befinden sich die beiden RTCPeerConnection-Objekte natürlich auf derselben Seite und können direkt miteinander kommunizieren, ohne dass externe Nachrichten erforderlich sind.
- Wenn Bob eine Kandidatennachricht von Alice erhält, ruft er
addIceCandidate()auf, um den Kandidaten der Remote-Peer-Beschreibung hinzuzufügen:
function handleConnection(event) {
const peerConnection = event.target;
const iceCandidate = event.candidate;
if (iceCandidate) {
const newIceCandidate = new RTCIceCandidate(iceCandidate);
const otherPeer = getOtherPeer(peerConnection);
otherPeer.addIceCandidate(newIceCandidate)
.then(() => {
handleConnectionSuccess(peerConnection);
}).catch((error) => {
handleConnectionFailure(peerConnection, error);
});
trace(`${getPeerName(peerConnection)} ICE candidate:\n` +
`${event.candidate.candidate}.`);
}
}
WebRTC-Peers müssen auch lokale und Remote-Audio- und -Videomedieninformationen wie Auflösung und Codec-Funktionen ermitteln und austauschen. Die Signalisierung zum Austausch von Medienkonfigurationsinformationen erfolgt durch den Austausch von Metadaten-Blobs, die als Angebot und Antwort bezeichnet werden. Dabei wird das Session Description Protocol-Format (SDP) verwendet:
- Alice führt die RTCPeerConnection-Methode
createOffer()aus. Das zurückgegebene Promise liefert eine RTCSessionDescription: Alices lokale Sitzungsbeschreibung:
trace('localPeerConnection createOffer start.');
localPeerConnection.createOffer(offerOptions)
.then(createdOffer).catch(setSessionDescriptionError);
- Wenn der Vorgang erfolgreich ist, legt Alice die lokale Beschreibung mit
setLocalDescription()fest und sendet diese Sitzungsbeschreibung dann über ihren Signalisierungskanal an Bob. - Bob legt die Beschreibung, die Alice ihm gesendet hat, mit
setRemoteDescription()als Remote-Beschreibung fest. - Bob führt die RTCPeerConnection-Methode
createAnswer()aus und übergibt ihr die Remote-Beschreibung, die er von Alice erhalten hat. So kann eine lokale Sitzung generiert werden, die mit der von Alice kompatibel ist. DascreateAnswer()-Promise gibt eine RTCSessionDescription weiter: Bob legt diese als lokale Beschreibung fest und sendet sie an Alice. - Wenn Alice die Sitzungsbeschreibung von Bob erhält, legt sie diese mit
setRemoteDescription()als Remote-Beschreibung fest.
// Logs offer creation and sets peer connection session descriptions.
function createdOffer(description) {
trace(`Offer from localPeerConnection:\n${description.sdp}`);
trace('localPeerConnection setLocalDescription start.');
localPeerConnection.setLocalDescription(description)
.then(() => {
setLocalDescriptionSuccess(localPeerConnection);
}).catch(setSessionDescriptionError);
trace('remotePeerConnection setRemoteDescription start.');
remotePeerConnection.setRemoteDescription(description)
.then(() => {
setRemoteDescriptionSuccess(remotePeerConnection);
}).catch(setSessionDescriptionError);
trace('remotePeerConnection createAnswer start.');
remotePeerConnection.createAnswer()
.then(createdAnswer)
.catch(setSessionDescriptionError);
}
// Logs answer to offer creation and sets peer connection session descriptions.
function createdAnswer(description) {
trace(`Answer from remotePeerConnection:\n${description.sdp}.`);
trace('remotePeerConnection setLocalDescription start.');
remotePeerConnection.setLocalDescription(description)
.then(() => {
setLocalDescriptionSuccess(remotePeerConnection);
}).catch(setSessionDescriptionError);
trace('localPeerConnection setRemoteDescription start.');
localPeerConnection.setRemoteDescription(description)
.then(() => {
setRemoteDescriptionSuccess(localPeerConnection);
}).catch(setSessionDescriptionError);
}
- Ping!
Bonuspunkte
- Rufen Sie chrome://webrtc-internals auf. Hier finden Sie WebRTC-Statistiken und Debugging-Daten. Eine vollständige Liste der Chrome-URLs finden Sie unter chrome://about.
- Seite mit CSS gestalten:
- Platziere die Videos nebeneinander.
- Die Buttons sollten dieselbe Breite haben und der Text sollte größer sein.
- Achten Sie darauf, dass das Layout auf Mobilgeräten funktioniert.
- Sehen Sie sich in der Konsole der Chrome-Entwicklertools
localStream,localPeerConnectionundremotePeerConnectionan. - Sehen Sie sich in der Console
localPeerConnectionpc1.localDescriptionan. Wie sieht das SDP-Format aus?
Das haben Sie gelernt
In diesem Schritt haben Sie Folgendes gelernt:
- Browserunterschiede mit dem WebRTC-Shim adapter.js abstrahieren
- Verwenden Sie die RTCPeerConnection API, um Videos zu streamen.
- Medienaufnahme und -streaming steuern
- Medien- und Netzwerkinformationen zwischen Peers teilen, um einen WebRTC-Anruf zu ermöglichen.
Eine vollständige Version dieses Schritts finden Sie im Ordner step-2.
Tipps
- In diesem Schritt gibt es viel zu lernen. Weitere Ressourcen, in denen RTCPeerConnection ausführlicher erläutert wird, finden Sie auf webrtc.org. Diese Seite enthält Vorschläge für JavaScript-Frameworks, wenn Sie WebRTC verwenden möchten, aber die APIs nicht selbst verwalten möchten.
- Weitere Informationen zum adapter.js-Shim finden Sie im adapter.js-GitHub-Repository.
- Möchten Sie sehen, wie die beste Videoanruf-App der Welt aussieht? Sehen Sie sich AppRTC an, die kanonische App des WebRTC-Projekts für WebRTC-Anrufe: App, Code. Die Verbindungsaufbauzeit beträgt weniger als 500 ms.
Best Practice
- Wenn Sie Ihren Code zukunftssicher machen möchten, verwenden Sie die neuen Promise-basierten APIs und aktivieren Sie die Kompatibilität mit Browsern, die diese nicht unterstützen, indem Sie adapter.js verwenden.
Als Nächstes
In diesem Schritt wird gezeigt, wie Sie mit WebRTC Videos zwischen Peers streamen. In diesem Codelab geht es aber auch um Daten.
Im nächsten Schritt erfahren Sie, wie Sie beliebige Daten mit RTCDataChannel streamen.
6. RTCDataChannel zum Datenaustausch verwenden
Lerninhalte
- Daten zwischen WebRTC-Endpunkten (Peers) austauschen
Eine vollständige Version dieses Schritts finden Sie im Ordner step-03.
HTML aktualisieren
In diesem Schritt verwenden Sie WebRTC-Datenkanäle, um Text zwischen zwei textarea-Elementen auf derselben Seite zu senden. Das ist nicht sehr nützlich, zeigt aber, wie WebRTC sowohl zum Teilen von Daten als auch zum Streamen von Videos verwendet werden kann.
Entfernen Sie die Video- und Schaltflächenelemente aus index.html und ersetzen Sie sie durch den folgenden HTML-Code:
<textarea id="dataChannelSend" disabled
placeholder="Press Start, enter some text, then press Send."></textarea>
<textarea id="dataChannelReceive" disabled></textarea>
<div id="buttons">
<button id="startButton">Start</button>
<button id="sendButton">Send</button>
<button id="closeButton">Stop</button>
</div>
In einem Textbereich wird Text eingegeben, im anderen wird der Text so angezeigt, wie er zwischen den Peers gestreamt wird.
index.html sollte jetzt so aussehen:
<!DOCTYPE html>
<html>
<head>
<title>Realtime communication with WebRTC</title>
<link rel="stylesheet" href="css/main.css">
</head>
<body>
<h1>Realtime communication with WebRTC</h1>
<textarea id="dataChannelSend" disabled
placeholder="Press Start, enter some text, then press Send."></textarea>
<textarea id="dataChannelReceive" disabled></textarea>
<div id="buttons">
<button id="startButton">Start</button>
<button id="sendButton">Send</button>
<button id="closeButton">Stop</button>
</div>
<script src="https://webrtc.github.io/adapter/adapter-latest.js"></script>
<script src="js/main.js"></script>
</body>
</html>
JavaScript aktualisieren
Ersetzen Sie main.js durch den Inhalt von step-03/js/main.js.
Probieren Sie das Streamen von Daten zwischen Peers aus: Öffnen Sie index.html, klicken Sie auf Start, um die Peer-Verbindung einzurichten, geben Sie Text in das textarea links ein und klicken Sie dann auf Senden, um den Text über WebRTC-Datenkanäle zu übertragen.
Funktionsweise
In diesem Code werden RTCPeerConnection und RTCDataChannel verwendet, um den Austausch von Textnachrichten zu ermöglichen.
Ein Großteil des Codes in diesem Schritt ist mit dem RTCPeerConnection-Beispiel identisch.
Die Funktionen sendData() und createConnection() enthalten den Großteil des neuen Codes:
function createConnection() {
dataChannelSend.placeholder = '';
var servers = null;
pcConstraint = null;
dataConstraint = null;
trace('Using SCTP based data channels');
// For SCTP, reliable and ordered delivery is true by default.
// Add localConnection to global scope to make it visible
// from the browser console.
window.localConnection = localConnection =
new RTCPeerConnection(servers, pcConstraint);
trace('Created local peer connection object localConnection');
sendChannel = localConnection.createDataChannel('sendDataChannel',
dataConstraint);
trace('Created send data channel');
localConnection.onicecandidate = iceCallback1;
sendChannel.onopen = onSendChannelStateChange;
sendChannel.onclose = onSendChannelStateChange;
// Add remoteConnection to global scope to make it visible
// from the browser console.
window.remoteConnection = remoteConnection =
new RTCPeerConnection(servers, pcConstraint);
trace('Created remote peer connection object remoteConnection');
remoteConnection.onicecandidate = iceCallback2;
remoteConnection.ondatachannel = receiveChannelCallback;
localConnection.createOffer().then(
gotDescription1,
onCreateSessionDescriptionError
);
startButton.disabled = true;
closeButton.disabled = false;
}
function sendData() {
var data = dataChannelSend.value;
sendChannel.send(data);
trace('Sent Data: ' + data);
}
Die Syntax von RTCDataChannel ähnelt absichtlich der von WebSocket, mit einer send()-Methode und einem message-Ereignis.
Beachten Sie die Verwendung von dataConstraint. Datenkanäle können so konfiguriert werden, dass verschiedene Arten der Datenweitergabe möglich sind. Beispielsweise kann die zuverlässige Übermittlung gegenüber der Leistung priorisiert werden. Weitere Informationen zu Optionen finden Sie im Mozilla Developer Network.
Bonuspunkte
- Bei SCTP, dem von WebRTC-Datenkanälen verwendeten Protokoll, ist die zuverlässige und geordnete Datenübermittlung standardmäßig aktiviert. Wann muss RTCDataChannel Daten zuverlässig bereitstellen und wann ist die Leistung wichtiger – auch wenn das bedeutet, dass einige Daten verloren gehen?
- Verwenden Sie CSS, um das Seitenlayout zu verbessern, und fügen Sie dem Textbereich „dataChannelReceive“ ein Platzhalterattribut hinzu.
- Testen Sie die Seite auf einem Mobilgerät.
Das haben Sie gelernt
In diesem Schritt haben Sie Folgendes gelernt:
- Stellen Sie eine Verbindung zwischen zwei WebRTC-Peers her.
- Textdaten zwischen den Peers austauschen.
Eine vollständige Version dieses Schritts finden Sie im Ordner step-03.
Weitere Informationen
- WebRTC-Datenkanäle (ein paar Jahre alt, aber immer noch lesenswert)
- Warum wurde SCTP für den Datenkanal von WebRTC ausgewählt?
Als Nächstes
Sie haben gelernt, wie Sie Daten zwischen Peers auf derselben Seite austauschen. Aber wie funktioniert das zwischen verschiedenen Geräten? Zuerst müssen Sie einen Signalisierungskanal einrichten, um Metadaten-Nachrichten auszutauschen. Im nächsten Schritt erfährst du, wie das geht.
7. Signalisierungsdienst zum Austausch von Nachrichten einrichten
Lerninhalte
In diesem Schritt erfahren Sie, wie Sie:
- Verwenden Sie
npm, um Projektabhängigkeiten wie in package.json angegeben zu installieren. - Führen Sie einen Node.js-Server aus und verwenden Sie node-static, um statische Dateien bereitzustellen.
- Messaging-Dienst in Node.js mit Socket.IO einrichten
- Damit können Sie „Räume“ erstellen und Nachrichten austauschen.
Eine vollständige Version dieses Schritts finden Sie im Ordner step-04.
Konzepte
Um einen WebRTC-Anruf einzurichten und aufrechtzuerhalten, müssen WebRTC-Clients (Peers) Metadaten austauschen:
- Informationen zu Kandidaten (Netzwerk).
- Offer- und Answer-Nachrichten mit Informationen zu Medien, z. B. Auflösung und Codecs.
Mit anderen Worten: Bevor ein Peer-to-Peer-Streaming von Audio, Video oder Daten stattfinden kann, ist ein Austausch von Metadaten erforderlich. Dieser Vorgang wird als Signalisierung bezeichnet.
In den vorherigen Schritten befinden sich die RTCPeerConnection-Objekte des Senders und des Empfängers auf derselben Seite. Die „Signalisierung“ besteht also darin, Metadaten zwischen Objekten zu übertragen.
In einer realen Anwendung werden die RTCPeerConnection-Objekte des Senders und des Empfängers auf Webseiten auf verschiedenen Geräten ausgeführt. Sie benötigen eine Möglichkeit, Metadaten zwischen ihnen zu übertragen.
Dazu verwenden Sie einen Signalisierungsserver, der Nachrichten zwischen WebRTC-Clients (Peers) weiterleiten kann. Die eigentlichen Nachrichten sind Nur-Text: stringifizierte JavaScript-Objekte.
Voraussetzung: Node.js installieren
Für die nächsten Schritte dieses Codelabs (Ordner step-04 bis step-06) müssen Sie einen Server auf localhost mit Node.js ausführen.
Sie können Node.js direkt von der Node.js-Website herunterladen und installieren oder Ihren bevorzugten Paketmanager verwenden.
Nach der Installation können Sie die für die nächsten Schritte erforderlichen Abhängigkeiten importieren (npm install ausführen) und einen kleinen Localhost-Server ausführen, um das Codelab auszuführen (node index.js ausführen). Diese Befehle werden später angegeben, wenn sie erforderlich sind.
Die App
WebRTC verwendet eine clientseitige JavaScript API, erfordert für die reale Nutzung aber auch einen Signalisierungsserver (Messaging-Server) sowie STUN- und TURN-Server. Weitere Informationen zur WebRTC-Infrastruktur
In diesem Schritt erstellen Sie einen einfachen Node.js-Signalisierungsserver mit dem Socket.IO-Node.js-Modul und der JavaScript-Bibliothek für Messaging. Erfahrung mit Node.js und Socket.IO ist hilfreich, aber nicht zwingend erforderlich. Die Messaging-Komponenten sind unkompliziert.
In diesem Beispiel wird der Server (die Node.js-Anwendung) in index.js und der darauf ausgeführte Client (die Webanwendung) in index.html implementiert.
Die Node.js-Anwendung in diesem Schritt hat zwei Aufgaben.
Erstens fungiert er als Nachrichtenweiterleitung:
socket.on('message', function (message) {
log('Got message: ', message);
socket.broadcast.emit('message', message);
});
Zweitens werden WebRTC-Videochaträume verwaltet:
if (numClients === 0) {
socket.join(room);
socket.emit('created', room, socket.id);
} else if (numClients === 1) {
socket.join(room);
socket.emit('joined', room, socket.id);
io.sockets.in(room).emit('ready');
} else { // max two clients
socket.emit('full', room);
}
Unsere WebRTC-Anwendung erlaubt maximal zwei Peers, einen Raum zu teilen.
HTML und JavaScript
Aktualisieren Sie index.html so, dass die Datei so aussieht:
<!DOCTYPE html>
<html>
<head>
<title>Realtime communication with WebRTC</title>
<link rel="stylesheet" href="css/main.css">
</head>
<body>
<h1>Realtime communication with WebRTC</h1>
<script src="/socket.io/socket.io.js"></script>
<script src="js/main.js"></script>
</body>
</html>
In diesem Schritt wird auf der Seite nichts angezeigt. Alle Logs werden in der Browserkonsole ausgegeben. (Wenn Sie die Konsole in Chrome aufrufen möchten, drücken Sie „Strg + Umschalttaste + J“ oder „Befehlstaste + Wahltaste + J“ auf einem Mac.)
Ersetzen Sie js/main.js durch Folgendes:
'use strict';
var isInitiator;
window.room = prompt("Enter room name:");
var socket = io.connect();
if (room !== "") {
console.log('Message from client: Asking to join room ' + room);
socket.emit('create or join', room);
}
socket.on('created', function(room, clientId) {
isInitiator = true;
});
socket.on('full', function(room) {
console.log('Message from client: Room ' + room + ' is full :^(');
});
socket.on('ipaddr', function(ipaddr) {
console.log('Message from client: Server IP address is ' + ipaddr);
});
socket.on('joined', function(room, clientId) {
isInitiator = false;
});
socket.on('log', function(array) {
console.log.apply(console, array);
});
Socket.IO für die Ausführung in Node.js einrichten
In der HTML-Datei haben Sie möglicherweise gesehen, dass Sie eine Socket.IO-Datei verwenden:
<script src="/socket.io/socket.io.js"></script>
Erstellen Sie auf der obersten Ebene des Verzeichnisses work eine Datei namens package.json mit folgendem Inhalt:
{
"name": "webrtc-codelab",
"version": "0.0.1",
"description": "WebRTC codelab",
"dependencies": {
"node-static": "^0.7.10",
"socket.io": "^1.2.0"
}
}
Dies ist ein App-Manifest, das dem Node Package Manager (npm) mitteilt, welche Projektabhängigkeiten installiert werden sollen.
Führen Sie im Befehlszeilenterminal im Verzeichnis work den folgenden Befehl aus, um Abhängigkeiten wie /socket.io/socket.io.js zu installieren:
npm install
Sie sollten ein Installationsprotokoll sehen, das in etwa so endet:

Wie Sie sehen, hat npm die in package.json definierten Abhängigkeiten installiert.
Erstellen Sie eine neue Datei index.js auf der obersten Ebene des Verzeichnisses work (nicht im Verzeichnis js) und fügen Sie den folgenden Code hinzu:
'use strict';
var os = require('os');
var nodeStatic = require('node-static');
var http = require('http');
var socketIO = require('socket.io');
var fileServer = new(nodeStatic.Server)();
var app = http.createServer(function(req, res) {
fileServer.serve(req, res);
}).listen(8080);
var io = socketIO.listen(app);
io.sockets.on('connection', function(socket) {
// convenience function to log server messages on the client
function log() {
var array = ['Message from server:'];
array.push.apply(array, arguments);
socket.emit('log', array);
}
socket.on('message', function(message) {
log('Client said: ', message);
// for a real app, would be room-only (not broadcast)
socket.broadcast.emit('message', message);
});
socket.on('create or join', function(room) {
log('Received request to create or join room ' + room);
var clientsInRoom = io.sockets.adapter.rooms[room];
var numClients = clientsInRoom ? Object.keys(clientsInRoom.sockets).length : 0;
log('Room ' + room + ' now has ' + numClients + ' client(s)');
if (numClients === 0) {
socket.join(room);
log('Client ID ' + socket.id + ' created room ' + room);
socket.emit('created', room, socket.id);
} else if (numClients === 1) {
log('Client ID ' + socket.id + ' joined room ' + room);
io.sockets.in(room).emit('join', room);
socket.join(room);
socket.emit('joined', room, socket.id);
io.sockets.in(room).emit('ready');
} else { // max two clients
socket.emit('full', room);
}
});
socket.on('ipaddr', function() {
var ifaces = os.networkInterfaces();
for (var dev in ifaces) {
ifaces[dev].forEach(function(details) {
if (details.family === 'IPv4' && details.address !== '127.0.0.1') {
socket.emit('ipaddr', details.address);
}
});
}
});
});
Führen Sie im Befehlszeilenterminal im Verzeichnis work den folgenden Befehl aus:
node index.js
Öffnen Sie in Ihrem Browser localhost:8080.
Jedes Mal, wenn Sie diese URL öffnen, werden Sie aufgefordert, einen Raumnamen einzugeben. Wenn Sie demselben Raum beitreten möchten, wählen Sie jedes Mal denselben Raumnamen aus, z. B. „foo“.
Öffnen Sie einen neuen Tab und rufen Sie noch einmal localhost:8080 auf. Wähle denselben Raumnamen aus.
Öffnen Sie localhost:8080 in einem dritten Tab oder Fenster. Wähle noch einmal denselben Raumnamen aus.
Prüfen Sie die Konsole in jedem Tab. Sie sollten die Protokollierung aus dem vorherigen JavaScript-Code sehen.
Bonuspunkte
- Welche alternativen Messaging-Mechanismen sind möglich? Welche Probleme können bei der Verwendung von „reinem“ WebSocket auftreten?
- Welche Probleme könnten bei der Skalierung dieser Anwendung auftreten? Können Sie eine Methode entwickeln, um Tausende oder Millionen gleichzeitiger Raumanfragen zu testen?
- Diese App verwendet eine JavaScript-Eingabeaufforderung, um einen Raumnamen abzufragen. Finden Sie eine Möglichkeit, den Raumnamen aus der URL abzurufen. Beispiel: localhost:8080/foo würde den Raumnamen
fooergeben.
Das haben Sie gelernt
In diesem Schritt haben Sie Folgendes gelernt:
- Verwenden Sie npm, um Projektabhängigkeiten wie in package.json angegeben zu installieren.
- Führen Sie einen Node.js-Server aus, um statische Dateien bereitzustellen.
- Messaging-Dienst in Node.js mit socket.io einrichten
- Damit können Sie „Räume“ erstellen und Nachrichten austauschen.
Eine vollständige Version dieses Schritts finden Sie im Ordner step-04.
Weitere Informationen
- Socket.io-Chat-Beispiel-Repository
- WebRTC in der Praxis: STUN, TURN und Signalisierung
- Der Begriff „Signalisierung“ in WebRTC
Als Nächstes
Hier erfahren Sie, wie Sie mithilfe von Signalisierung zwei Nutzern ermöglichen, eine Peer-Verbindung herzustellen.
8. Peer-to-Peer-Verbindung und Signalisierung kombinieren
Lerninhalte
In diesem Schritt erfahren Sie, wie Sie:
- WebRTC-Signalisierungsdienst mit Socket.IO unter Node.js ausführen
- Verwenden Sie diesen Dienst, um WebRTC-Metadaten zwischen Peers auszutauschen.
Eine vollständige Version dieses Schritts finden Sie im Ordner step-05.
HTML und JavaScript ersetzen
Ersetzen Sie den Inhalt von index.html durch Folgendes:
<!DOCTYPE html>
<html>
<head>
<title>Realtime communication with WebRTC</title>
<link rel="stylesheet" href="/css/main.css">
</head>
<body>
<h1>Realtime communication with WebRTC</h1>
<div id="videos">
<video id="localVideo" autoplay muted></video>
<video id="remoteVideo" autoplay></video>
</div>
<script src="/socket.io/socket.io.js"></script>
<script src="https://webrtc.github.io/adapter/adapter-latest.js"></script>
<script src="js/main.js"></script>
</body>
</html>
Ersetzen Sie js/main.js durch den Inhalt von step-05/js/main.js.
Node.js-Server ausführen
Wenn Sie dieses Codelab nicht in Ihrem work-Verzeichnis ausführen, müssen Sie möglicherweise die Abhängigkeiten für den Ordner step-05 oder Ihren aktuellen Arbeitsordner installieren. Führen Sie den folgenden Befehl in Ihrem Arbeitsverzeichnis aus:
npm install
Wenn Ihr Node.js-Server nach der Installation nicht ausgeführt wird, starten Sie ihn, indem Sie den folgenden Befehl im Verzeichnis work aufrufen:
node index.js
Achten Sie darauf, dass Sie die Version von index.js aus dem vorherigen Schritt verwenden, in der Socket.IO implementiert ist. Weitere Informationen zu Node und Socket.IO finden Sie im Abschnitt „Signalisierungsdienst zum Austausch von Nachrichten einrichten“.
Öffnen Sie in Ihrem Browser localhost:8080.
Öffnen Sie localhost:8080 noch einmal in einem neuen Tab oder Fenster. In einem Videoelement wird der lokale Stream von getUserMedia() angezeigt, im anderen das „Remote“-Video, das über RTCPeerconnection gestreamt wird.
Logging in der Browserkonsole ansehen.
Bonuspunkte
- Diese Anwendung unterstützt nur Videoanrufe zwischen zwei Personen. Wie könnten Sie das Design ändern, damit mehrere Personen denselben Videochatraum nutzen können?
- Im Beispiel ist der Raumname foo hartcodiert. Wie lassen sich andere Raumnamen am besten aktivieren?
- Wie würden Nutzer den Raumnamen teilen? Versuchen Sie, eine Alternative zur Freigabe von Raumnamen zu entwickeln.
- Wie könnten Sie die App ändern,
- Nehmen Sie ein Foto auf und rufen Sie die Daten mithilfe des Canvas-Elements ab.
- Bilddaten mit einem Remote-Nutzer austauschen.
Eine vollständige Version dieses Schritts finden Sie im Ordner step-06.
Funktionsweise
Zuvor haben Sie gelernt, wie Sie Textnachrichten mit RTCDataChannel austauschen.
In diesem Schritt wird es möglich, ganze Dateien freizugeben, in diesem Beispiel Fotos, die mit getUserMedia() aufgenommen wurden.
Die wichtigsten Teile dieses Schritts sind:
- Datenkanal einrichten Beachten Sie, dass Sie in diesem Schritt keine Mediastreams zur Peer-Verbindung hinzufügen.
- Webcam-Videostream des Nutzers mit
getUserMedia()erfassen:
var video = document.getElementById('video');
function grabWebCamVideo() {
console.log('Getting user media (video) ...');
navigator.mediaDevices.getUserMedia({
video: true
})
.then(gotStream)
.catch(function(e) {
alert('getUserMedia() error: ' + e.name);
});
}
- Wenn der Nutzer auf die Schaltfläche Snap klickt, wird ein Snapshot (ein Videoframe) aus dem Videostream abgerufen und in einem
canvas-Element angezeigt:
var photo = document.getElementById('photo');
var photoContext = photo.getContext('2d');
function snapPhoto() {
photoContext.drawImage(video, 0, 0, photo.width, photo.height);
show(photo, sendBtn);
}
- Wenn der Nutzer auf den Button Senden klickt, wandeln Sie das Bild in Byte um und senden Sie es über einen Datenkanal:
function sendPhoto() {
// Split data channel message in chunks of this byte length.
var CHUNK_LEN = 64000;
var img = photoContext.getImageData(0, 0, photoContextW, photoContextH),
len = img.data.byteLength,
n = len / CHUNK_LEN | 0;
console.log('Sending a total of ' + len + ' byte(s)');
dataChannel.send(len);
// split the photo and send in chunks of about 64KB
for (var i = 0; i < n; i++) {
var start = i * CHUNK_LEN,
end = (i + 1) * CHUNK_LEN;
console.log(start + ' - ' + (end - 1));
dataChannel.send(img.data.subarray(start, end));
}
// send the reminder, if any
if (len % CHUNK_LEN) {
console.log('last ' + len % CHUNK_LEN + ' byte(s)');
dataChannel.send(img.data.subarray(n * CHUNK_LEN));
}
}
- Die Empfängerseite wandelt die Byte der Datenkanalnachricht wieder in ein Bild um und zeigt es dem Nutzer an:
function receiveDataChromeFactory() {
var buf, count;
return function onmessage(event) {
if (typeof event.data === 'string') {
buf = window.buf = new Uint8ClampedArray(parseInt(event.data));
count = 0;
console.log('Expecting a total of ' + buf.byteLength + ' bytes');
return;
}
var data = new Uint8ClampedArray(event.data);
buf.set(data, count);
count += data.byteLength;
console.log('count: ' + count);
if (count === buf.byteLength) {
// we're done: all data chunks have been received
console.log('Done. Rendering photo.');
renderPhoto(buf);
}
};
}
function renderPhoto(data) {
var canvas = document.createElement('canvas');
canvas.width = photoContextW;
canvas.height = photoContextH;
canvas.classList.add('incomingPhoto');
// trail is the element holding the incoming images
trail.insertBefore(canvas, trail.firstChild);
var context = canvas.getContext('2d');
var img = context.createImageData(photoContextW, photoContextH);
img.data.set(data);
context.putImageData(img, 0, 0);
}
Code abrufen
Ersetzen Sie den Inhalt des Ordners work durch den Inhalt von step-06. Ihre Datei index.html in work sollte jetzt so aussehen**:**
<!DOCTYPE html>
<html>
<head>
<title>Realtime communication with WebRTC</title>
<link rel="stylesheet" href="/css/main.css">
</head>
<body>
<h1>Realtime communication with WebRTC</h1>
<h2>
<span>Room URL: </span><span id="url">...</span>
</h2>
<div id="videoCanvas">
<video id="camera" autoplay></video>
<canvas id="photo"></canvas>
<script src="js/main.js"></script>
</body>
</html>
Wenn Sie dieses Codelab nicht in Ihrem work-Verzeichnis ausführen, müssen Sie möglicherweise die Abhängigkeiten für den Ordner step-06 oder Ihren aktuellen Arbeitsordner installieren. Führen Sie einfach den folgenden Befehl in Ihrem Arbeitsverzeichnis aus:
npm install
Wenn Ihr Node.js-Server nach der Installation nicht ausgeführt wird, starten Sie ihn, indem Sie den folgenden Befehl in Ihrem work-Verzeichnis aufrufen:
node index.js
Achten Sie darauf, dass Sie die Version von index.js verwenden, die Socket.IO implementiert. Denken Sie daran, Ihren Node.js-Server neu zu starten, wenn Sie Änderungen vornehmen. Weitere Informationen zu Node und Socket.IO finden Sie im Abschnitt „Signalisierungsdienst zum Austausch von Nachrichten einrichten“.
Klicken Sie bei Bedarf auf den Button Zulassen, um der App die Verwendung Ihrer Webcam zu erlauben.
Die App erstellt eine zufällige Raum-ID und fügt diese ID der URL hinzu. Öffnen Sie die URL aus der Adressleiste in einem neuen Browsertab oder -fenster.
Klicken Sie auf den Button Snap & Send und sehen Sie sich dann im anderen Tab unten auf der Seite den Bereich „Eingehend“ an. Die App überträgt Fotos zwischen Tabs.
Auf dem Bildschirm sollte Folgendes zu sehen sein:

Bonuspunkte
- Wie können Sie den Code so ändern, dass beliebige Dateitypen freigegeben werden können?
Weitere Informationen
- Die MediaStream Image Capture API: eine API zum Aufnehmen von Fotos und Steuern von Kameras – bald in einem Browser in Ihrer Nähe verfügbar!
- Die MediaRecorder API zum Aufzeichnen von Audio- und Videoinhalten: Demo, Dokumentation.
Das haben Sie gelernt
- Wie Sie mit dem Canvas-Element ein Foto aufnehmen und die Daten daraus abrufen.
- Wie Sie diese Daten mit einem Remote-Nutzer austauschen.
Eine vollständige Version dieses Schritts finden Sie im Ordner step-06.
9. Glückwunsch
Sie haben eine Anwendung für Echtzeit-Videostreaming und -Datenaustausch erstellt.
Das haben Sie gelernt
In diesem Codelab haben Sie Folgendes gelernt:
- Video von deiner Webcam abrufen.
- Video mit RTCPeerConnection streamen
- Daten mit RTCDataChannel streamen
- Richten Sie einen Signalisierungsdienst ein, um Nachrichten auszutauschen.
- Peer-Verbindung und Signalisierung kombinieren.
- Ein Foto aufnehmen und über einen Datenkanal teilen.
Nächste Schritte
- Sehen Sie sich den Code und die Architektur für die kanonische WebRTC-Chat-Anwendung AppRTC an: App, Code.
- Probieren Sie die Live-Demos unter github.com/webrtc/samples aus.
Weitere Informationen
- Auf webrtc.org finden Sie verschiedene Ressourcen für den Einstieg in WebRTC.