Videoanrufe in JavaScript: wie WebRTC zwei Browser verbindet

Ein Videoanruf in JavaScript braucht drei Dinge: getUserMedia() für Kamera und Mikrofon, eine RTCPeerConnection, die Bild und Ton zwischen den beiden Browsern überträgt, und einen eigenen Signalisierungskanal, meist einen WebSocket, über den die beiden einander ihre Angebote und Netzwerkadressen schicken. Der Browser kümmert sich um die Medien, und alles darum herum, vom Finden der anderen Person bis zum Weg durch eine Firewall, bauen Sie selbst.
Dieser Beitrag zeigt einen ganzen Video-Chat mit WebRTC in weniger als hundert Zeilen reinem JavaScript, getestet in zwei Browser-Tabs, erklärt jeden Teil und geht dann durch, was eine echte App ergänzt, bevor sich Menschen darauf verlassen können.
Die drei Teile eines WebRTC-Anrufs
| Teil | Was er tut |
|---|---|
getUserMedia() |
Öffnet Kamera und Mikrofon, nachdem der Browser gefragt hat |
RTCPeerConnection |
Verbindet die beiden Browser und überträgt die Medien, verschlüsselt |
| Signalisierung | Reicht Angebote, Antworten und Adressen zwischen ihnen weiter, über Ihren Server |
Die ersten beiden sind in jeden modernen Browser eingebaut. Der dritte nicht, und das mit Absicht. Das JavaScript Session Establishment Protocol, das beschreibt, wie die Browser-API funktioniert, überlässt der App, wie zwei Browser einander erreichen. Sie müssen zwei Arten von Nachrichten austauschen, bevor ein Bild fließt:
- Eine Beschreibung, ein Angebot der einen Seite und eine Antwort der anderen, die auflistet, welche Medien jede senden wird und wie sie verschlüsselt werden.
- Kandidaten, die Adressen, unter denen jeder Browser erreichbar sein könnte: seine eigene im lokalen Netzwerk, die öffentliche, die ein STUN-Server sieht, und ein Relay auf einem TURN-Server, falls er eines hat. Die Browser probieren sie paarweise aus, bis eines funktioniert (STUN- und TURN-Server erklärt).
Ein Video-Chat in reinem JavaScript
Zwei Personen öffnen dieselbe Seite, und jede sieht die andere. Die Seite braucht zwei Video-Elemente:
<video id="me" autoplay playsinline muted></video>
<video id="them" autoplay playsinline></video>
<script type="module" src="/call.js"></script>Ihr eigenes Video ist muted, damit Sie sich nicht selbst hören, und so darf der Browser es auch abspielen, bevor jemand klickt. playsinline hält es auf einem iPhone in der Seite.
Der Signalisierungsserver
Der kleinste Signalisierungsserver reicht jede Nachricht von einem Browser an den anderen weiter. In Node.js, mit dem Paket ws:
import { WebSocketServer, WebSocket } from 'ws';
const wss = new WebSocketServer({ port: 8080 });
wss.on('connection', (socket) => {
socket.on('message', (data) => {
// An alle anderen Verbundenen weiterreichen: hier an die andere Person.
for (const other of wss.clients) {
if (other !== socket && other.readyState === WebSocket.OPEN) {
other.send(data.toString());
}
}
});
});Er weiß nichts über Anrufe. Er reicht nur Text weiter, und mehr ist Signalisierung nicht. Dasselbe Relay in wenigen Zeilen Python und ein Python-Programm, das selbst am Anruf teilnimmt, stehen in WebRTC in Python. Auch Node.js kann an einem Anruf teilnehmen, über ein npm-Paket, das die Browser-API mitbringt, wie WebRTC in Node.js zeigt.
Die Seite
Beide Browser führen denselben Code aus. Jeder öffnet seine Kamera, meldet, dass er da ist, und fügt die Kamera der Verbindung hinzu, sobald auch die andere Person das gemeldet hat, damit das erste Angebot jemanden erreicht. Der Teil, der auf Nachrichten antwortet, folgt dem Muster der Perfect Negotiation von MDN, bei dem jede Seite beginnen kann, sogar beide zugleich:
const local = await navigator.mediaDevices.getUserMedia({ video: true, audio: true });
document.getElementById('me').srcObject = local;
const signaler = new WebSocket('ws://localhost:8080');
await new Promise((resolve) => signaler.addEventListener('open', resolve, { once: true }));
const send = (message) => signaler.send(JSON.stringify(message));
const pc = new RTCPeerConnection({
iceServers: [{ urls: 'stun:stun.example.com:3478' }],
});
// Die Kamera hinzufügen, sobald die andere Person da ist.
let started = false;
const start = () => {
if (started) return;
started = true;
for (const track of local.getTracks()) pc.addTrack(track, local);
};
// Eine Seite gibt nach, wenn beide im selben Moment ein Angebot machen.
const polite = location.hash === '#polite';
let makingOffer = false;
let ignoreOffer = false;
let isSettingRemoteAnswerPending = false;
pc.onnegotiationneeded = async () => {
try {
makingOffer = true;
await pc.setLocalDescription();
send({ description: pc.localDescription });
} finally {
makingOffer = false;
}
};
pc.onicecandidate = ({ candidate }) => send({ candidate });
pc.ontrack = ({ streams }) => {
document.getElementById('them').srcObject = streams[0];
};
signaler.onmessage = async ({ data }) => {
const { here, description, candidate } = JSON.parse(data);
if (here) {
if (!started) send({ here: true }); // damit auch die andere Seite beginnt
start();
} else if (description) {
const readyForOffer = !makingOffer
&& (pc.signalingState === 'stable' || isSettingRemoteAnswerPending);
const offerCollision = description.type === 'offer' && !readyForOffer;
ignoreOffer = !polite && offerCollision;
if (ignoreOffer) return;
isSettingRemoteAnswerPending = description.type === 'answer';
await pc.setRemoteDescription(description);
isSettingRemoteAnswerPending = false;
if (description.type === 'offer') {
await pc.setLocalDescription();
send({ description: pc.localDescription });
}
} else if (candidate) {
try {
await pc.addIceCandidate(candidate);
} catch (error) {
if (!ignoreOffer) throw error;
}
}
};
send({ here: true });Starten Sie den Server, liefern Sie die Seite von localhost aus und öffnen Sie sie in einem Tab und als /#polite in einem zweiten, in beliebiger Reihenfolge. Jeder Tab fragt nach der Kamera, und dann zeigt jeder den anderen. Auf einem Ihrer Server liegt die Seite auf HTTPS, also wird die WebSocket-Adresse zu wss:// mit einem Zertifikat, und stun.example.com steht für einen STUN-Server, den Sie nutzen dürfen.
Was passiert, der Reihe nach:
- Die Kamera öffnet sich.
getUserMedia()fragt die Person zuerst. MDN weist darauf hin, dass es nur in einem sicheren Kontext funktioniert, auf einer Seite mit HTTPS oderlocalhost, und dass eine Ablehnung mitNotAllowedErrorscheitert. Bleibt eine Kamera schwarz, geht unsere Anleitung zu einer Kamera, die nicht funktioniert, jede Ursache durch. - Die beiden finden einander. Jede Seite sagt
here, sobald sie sich verbindet. Die erste hört niemanden, und wenn die zweite dazukommt, hört die erste sie und antwortet, sodass beide wissen, dass die andere da ist. - Das Hinzufügen der Tracks verlangt eine Aushandlung. Die Verbindung löst
negotiationneededaus, undsetLocalDescription()ohne Argument erstellt ein Angebot, das über den WebSocket hinausgeht. - Die andere Seite antwortet. Sie setzt das Angebot als ihre entfernte Beschreibung, erstellt auf dieselbe Weise eine Antwort und schickt sie zurück.
- Beide sammeln Kandidaten und senden jeden, sobald er gefunden ist. Die Browser testen Adresspaare gegeneinander und einigen sich auf eines, das funktioniert, die direkten zuerst.
- Die Medien fließen.
ontrackwird auf jeder Seite ausgelöst, und die andere Person erscheint. Unterwegs ist alles verschlüsselt, immer: WebRTC verlangt es (RFC 8827). Fragen Sie nur nach{ audio: true }, und derselbe Code führt einen Sprachanruf, den Sprachanrufe und Audioräume misst und erklärt.
Da beide Tabs ihre Kamera etwa im selben Moment hinzufügen, können beide ein Angebot machen. Das ist die Kollision, die das Muster auflöst: Die höfliche Seite verwirft ihr eigenes Angebot und beantwortet das der anderen, und die unhöfliche Seite ignoriert das Angebot, das sich mit ihrem gekreuzt hat.
Ohne Schritt 2 würde der erste Tab ein Angebot machen, während er allein ist, der Server würde dieses Angebot an niemanden weiterreichen, und der Anruf würde nie beginnen. Ein Angebot, das niemand hört, ist ein häufiger Grund, warum eine erste WebRTC-Demo zwei schwarze Kästen zeigt.
Was die Demo weglässt
Die Demo funktioniert zwischen zwei Tabs in einem Netzwerk. Eine App braucht mehr, bevor ihre Nutzer sich darauf verlassen können.
- Wer wen anrufen darf. Der Server oben reicht jede Nachricht an jeden weiter. Ein echter prüft, wer angemeldet ist und ob diese Person die andere anrufen darf, bevor er bei irgendjemandem klingelt.
- Klingeln. Die angerufene Person muss es auf jeder Seite hören, auf der sie gerade ist, in jedem Tab, und es überall nicht mehr hören, sobald sie in einem annimmt. Das braucht für jeden Nutzer eine offene Verbindung, die ganze Zeit, die er auf der Website ist (WebSockets über einen Server hinaus zeigt, was das verlangt, sobald Sie mehr als einen haben).
- Relays. Ein STUN-Server findet öffentliche Adressen, und hinter vielen Firewalls in Büros und in Mobilfunknetzen reicht das nicht. Diese Anrufe brauchen einen TURN-Server, mit Logins, die ablaufen, auf Ports, die solche Netzwerke offen lassen (die Ports, die ein Anruf braucht).
- Neu verbinden. Ein Smartphone, das vom WLAN zu mobilen Daten wechselt, verliert seinen Weg. Beobachten Sie
connectionStateund rufen Siepc.restartIce()auf, wenn die Verbindung scheitert, damit die Browser ein neues Adresspaar suchen, ohne aufzulegen. - Mehr als zwei Personen. In diesem Aufbau sendet jede Person ihr Video an jede andere. Für drei oder vier reicht das, danach geben die Uploads nach, und deshalb laufen Gruppenanrufe über Medienserver (wie Gruppen-Videoanrufe funktionieren).
- Fehler, die Menschen sehen. Eine abgelehnte Kamera, ein fehlendes Mikrofon, ein Anruf, den niemand annimmt. Warum eine WebRTC-Verbindung scheitert geht durch, was Sie von beiden Seiten prüfen sollten.
Jeder dieser Punkte lässt sich auf derselben API bauen, und das ist die Arbeit hinter den meisten Video-Chat-Produkten. Der andere Weg ist, die Verbindungen, das Klingeln und die Relays einem Dienst zu überlassen und auf Ihrem Server den einen Teil zu behalten, der wirklich Ihre App betrifft: wer wen anrufen darf. Videoanruf-API auswählen listet die Fragen auf, die Sie einem solchen Dienst stellen sollten.
Derselbe Anruf mit WordPlus Cloud
Mit dem SDK von WordPlus Cloud führt eine Seite in reinem JavaScript Anrufe, ohne dass Sie einen Signalisierungsserver, ein Relay oder einen Anrufbildschirm schreiben. Ihr Server legt fest, wer anrufen darf, als Regel für jeden Anruf, dessen Name zu einem Muster passt. Hier ist ein Support-Anruf wie support:34:42 für die beiden Personen in seinem Namen:
// server.mjs, mit realtime aus createRealtime() von @wordplus/realtime/server
realtime.calls('support:{a}:{b}', async (user, withUser, { a, b }) => {
const pair = [a, b];
return pair.includes(String(user)) && pair.includes(String(withUser));
});Die Seite verbindet sich mit den Einstellungen, die Ihr Server in sie geschrieben hat, startet den Anrufbildschirm und setzt einen Button dorthin, von wo aus Menschen anrufen:
import { connect } from '@wordplus/realtime';
const rt = await connect(JSON.parse(document.getElementById('realtime').textContent));
await rt.callScreen(); // das Klingeln und das Anruffenster, auf dieser Seite<call-button to="34" call="support:{pair}" type="video" name="Ann">Call Ann</call-button>Der Anruf klingelt in jedem Tab und auf jedem Gerät, das Ann offen hat. Er läuft direkt zwischen den beiden Browsern, wenn ihre Netzwerke es erlauben, über unsere Relays auf den Ports 443 und 80, wenn nicht, und über unsere Medienserver, wenn selbst die Relays nicht durchkommen, und wechselt von einem zum nächsten, ohne aufzulegen. Anrufe zwischen zwei Personen sind auf jedem Weg Ende-zu-Ende-verschlüsselt. Für einen eigenen Bildschirm gibt Ihnen rt.calls() dieselben Anrufe ohne fertige Teile, calls.start(), um einen zu starten, und ein incoming-Ereignis, um anzunehmen.
Anrufe in unserer Dokumentation zeigen jeden Weg, einen zu starten, von einem Button bis zu Ihrer eigenen Oberfläche, und die Next.js-Anleitung für Videoanrufe baut sie in eine ganze App ein.
Videoanrufe für Ihre App
Für WordPlus Cloud for Apps gelten Preise nach gleichzeitigen Verbindungen, ab 1.000, monatlich oder jährlich abgerechnet, und Anrufe zwischen zwei Personen verbrauchen auf keinem Weg Credits. Sehen Sie sich Videoanrufe und Gruppenanrufe für Apps an oder die Preise für Apps. Fragen zu Ihrer Integration? Schreiben Sie uns.