Videogesprekken in JavaScript: hoe WebRTC twee browsers verbindt

Een videogesprek in JavaScript vraagt drie dingen: getUserMedia() voor de camera en de microfoon, een RTCPeerConnection die het beeld en het geluid tussen de twee browsers vervoert, en een eigen signalingkanaal, meestal een WebSocket, dat hun aanbiedingen en netwerkadressen aan elkaar doorgeeft. De browser regelt de media, en alles eromheen, van de ander vinden tot door een firewall komen, bouw je zelf.
Dit artikel laat een complete videochat met WebRTC zien in minder dan honderd regels gewoon JavaScript, getest in twee browsertabbladen, legt elk onderdeel uit, en loopt daarna door wat een echte app eraan toevoegt voordat mensen erop kunnen rekenen.
De drie onderdelen van een WebRTC-gesprek
| Onderdeel | Wat het doet |
|---|---|
getUserMedia() |
Opent de camera en de microfoon, nadat de browser het vraagt |
RTCPeerConnection |
Verbindt de twee browsers en vervoert de media, versleuteld |
| Signaling | Geeft aanbiedingen, antwoorden en adressen door, via je server |
De eerste twee zitten in elke moderne browser. De derde niet, en dat is bewust. Het JavaScript Session Establishment Protocol, dat beschrijft hoe de API van de browser werkt, laat de manier waarop twee browsers elkaar bereiken aan de app over. Ze moeten twee soorten berichten uitwisselen voordat er beeld komt:
- Een beschrijving, een aanbieding van de ene kant en een antwoord van de andere, met de media die elk zal versturen en hoe die versleuteld zijn.
- Kandidaten, de adressen waarop elke browser bereikbaar zou kunnen zijn: het eigen adres op het lokale netwerk, het openbare adres dat een STUN-server ziet, en een relay op een TURN-server, als die er is. De browsers proberen ze in paren tot er een werkt (STUN- en TURN-servers uitgelegd).
Een videochat in gewoon JavaScript
Twee mensen openen dezelfde pagina, en ieder ziet de ander. De pagina heeft twee video-elementen nodig:
<video id="me" autoplay playsinline muted></video>
<video id="them" autoplay playsinline></video>
<script type="module" src="/call.js"></script>Je eigen video is muted, zodat je jezelf niet hoort, en daardoor mag de browser hem ook afspelen voordat iemand klikt. playsinline houdt hem op een iPhone in de pagina.
De signalingserver
De kleinste signalingserver geeft elk bericht van de ene browser door aan de andere. In Node.js, met het pakket ws:
import { WebSocketServer, WebSocket } from 'ws';
const wss = new WebSocketServer({ port: 8080 });
wss.on('connection', (socket) => {
socket.on('message', (data) => {
// Geef het door aan iedereen die verder verbonden is: hier de ander.
for (const other of wss.clients) {
if (other !== socket && other.readyState === WebSocket.OPEN) {
other.send(data.toString());
}
}
});
});Hij weet niets van gesprekken. Hij geeft alleen tekst door, en meer is signaling niet. Dezelfde relay in een paar regels Python, en een Python-programma dat zelf aan het gesprek meedoet, staan in WebRTC in Python. Ook Node.js kan aan een gesprek meedoen, via een npm-pakket dat de API van de browser meebrengt, zoals WebRTC in Node.js laat zien.
De pagina
Beide browsers draaien dezelfde code. Elk opent zijn camera, meldt dat hij er is, en voegt de camera aan de verbinding toe zodra de ander dat ook heeft gemeld, zodat de eerste aanbieding iemand bereikt. Het deel dat op berichten reageert, volgt het patroon perfect negotiation van MDN, waarmee elke kant kan beginnen, zelfs allebei tegelijk:
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' }],
});
// Voeg de camera toe zodra de ander er is.
let started = false;
const start = () => {
if (started) return;
started = true;
for (const track of local.getTracks()) pc.addTrack(track, local);
};
// Eén kant geeft voorrang als beide op hetzelfde moment een aanbieding doen.
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 }); // zodat de andere kant ook begint
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 });Start de server, serveer de pagina vanaf localhost, en open hem in één tabblad, en als /#polite in een ander, in willekeurige volgorde. Elk tabblad vraagt om de camera, en daarna toont elk de ander. Op een eigen server staat de pagina op HTTPS, dus wordt het adres van de WebSocket wss:// met een certificaat, en stun.example.com staat voor een STUN-server die je mag gebruiken.
Wat er gebeurt, op volgorde:
- De camera gaat aan.
getUserMedia()vraagt het eerst aan de persoon. MDN merkt op dat het alleen werkt in een beveiligde context, een pagina op HTTPS oflocalhost, en dat een weigering eindigt metNotAllowedError. Blijft een camera zwart, dan loopt onze gids voor een camera die niet werkt elke oorzaak na. - De twee vinden elkaar. Elke pagina zegt
herezodra hij verbinding maakt. De eerste hoort niemand, en als de tweede binnenkomt, hoort de eerste die en antwoordt, zodat beide weten dat de ander er is. - Het toevoegen van de tracks vraagt om onderhandeling. De verbinding vuurt
negotiationneededaf, ensetLocalDescription()zonder argument maakt een aanbieding, die via de WebSocket vertrekt. - De andere kant antwoordt. Die zet de aanbieding als zijn remote description, maakt op dezelfde manier een antwoord, en stuurt het terug.
- Beide verzamelen kandidaten en versturen elke kandidaat zodra die gevonden is. De browsers testen paren van adressen tegen elkaar en kiezen er een die werkt, de rechtstreekse eerst.
- De media stromen.
ontrackvuurt aan elke kant af, en de ander verschijnt. Onderweg is alles versleuteld, altijd: WebRTC eist dat (RFC 8827). Vraag alleen om{ audio: true }en dezelfde code zet een spraakgesprek op, dat spraakgesprekken en audioruimtes meet en uitlegt.
Omdat beide tabbladen hun camera ongeveer tegelijk toevoegen, kunnen ze allebei een aanbieding doen. Dat is de botsing die het patroon oplost: de beleefde kant laat zijn eigen aanbieding vallen en beantwoordt die van de ander, en de onbeleefde kant negeert de aanbieding die de zijne kruiste.
Zonder stap 2 zou het eerste tabblad een aanbieding doen terwijl het alleen is, de server zou die aan niemand doorgeven, en het gesprek zou nooit beginnen. Een aanbieding die niemand hoort, is een veelvoorkomende reden dat een eerste WebRTC-demo twee zwarte vakken toont.
Wat de demo weglaat
De demo werkt tussen twee tabbladen op één netwerk. Een app heeft meer nodig voordat de gebruikers erop kunnen rekenen.
- Wie wie mag bellen. De server hierboven geeft elk bericht aan iedereen door. Een echte server controleert wie er is ingelogd, en of die deze persoon mag bellen, voordat hij iemand laat overgaan.
- Overgaan. Wie gebeld wordt, moet het horen op welke pagina die ook is, in elk tabblad, en het overal niet meer horen zodra die in één ervan opneemt. Daarvoor is een verbinding nodig die voor elke gebruiker open blijft, de hele tijd dat die op de site is (WebSockets voorbij één server laat zien wat dat vraagt zodra je er meer dan één hebt).
- Relays. Een STUN-server vindt openbare adressen, en dat is niet genoeg achter veel kantoorfirewalls en mobiele netwerken. Die gesprekken hebben een TURN-server nodig, met logins die verlopen, op poorten die zulke netwerken openlaten (de poorten die een gesprek nodig heeft).
- Opnieuw verbinden. Een telefoon die van wifi naar mobiele data overstapt, verliest zijn route. Houd
connectionStatein de gaten en roeppc.restartIce()aan als die mislukt, zodat de browsers een nieuw paar adressen zoeken zonder op te hangen. - Meer dan twee mensen. In deze opzet stuurt ieder zijn video naar iedere ander. Dat houdt het voor drie of vier, en daarna houden de uploads het niet meer, en daarom lopen groepsgesprekken via mediaservers (hoe groepsvideogesprekken werken).
- Fouten die mensen zien. Een geweigerde camera, een ontbrekende microfoon, een gesprek dat niemand opneemt. Waarom een WebRTC-verbinding mislukt loopt na wat je aan beide kanten controleert.
Elk hiervan kan op dezelfde API worden gebouwd, en dat is het werk achter de meeste videochatproducten. De andere weg is de verbindingen, het overgaan en de relays aan een dienst over te laten, en op je server het ene deel te houden dat echt over je app gaat: wie wie mag bellen. Een API voor videogesprekken kiezen zet de vragen op een rij die je aan zo’n dienst stelt.
Hetzelfde gesprek met WordPlus Cloud
Met de SDK van WordPlus Cloud plaatst een pagina met gewoon JavaScript gesprekken zonder dat je een signalingserver, relay of belscherm hoeft te schrijven. Je server legt vast wie mag bellen, als een regel voor elk gesprek waarvan de naam bij een patroon past. Hier is een supportgesprek zoals support:34:42 voor de twee mensen in de naam:
// server.mjs, met realtime uit createRealtime() van @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));
});De pagina maakt verbinding met de instellingen die je server erin heeft gezet, start het belscherm, en zet een knop waar mensen vandaan bellen:
import { connect } from '@wordplus/realtime';
const rt = await connect(JSON.parse(document.getElementById('realtime').textContent));
await rt.callScreen(); // het overgaan en het gespreksvenster, op deze pagina<call-button to="34" call="support:{pair}" type="video" name="Ann">Call Ann</call-button>Het gesprek gaat over in elk tabblad en op elk apparaat dat Ann open heeft. Het gaat rechtstreeks tussen de twee browsers als hun netwerken dat toelaten, via onze relays op de poorten 443 en 80 als dat niet zo is, en via onze mediaservers als zelfs de relays er niet doorkomen, en het wisselt van de ene weg naar de andere zonder op te hangen. Gesprekken tussen twee mensen zijn op elke weg end-to-end versleuteld. Voor een eigen scherm geeft rt.calls() je dezelfde gesprekken zonder kant-en-klare onderdelen, met calls.start() om er een te plaatsen en een incoming-event om op te nemen.
Gesprekken in onze documentatie laten elke manier zien om er een te plaatsen, van een knop tot je eigen interface, en de Next.js-gids voor videogesprekken bouwt ze in een hele app.
Videogesprekken voor je app
WordPlus Cloud for Apps is geprijsd op gelijktijdige verbindingen, vanaf 1.000, maandelijks of jaarlijks gefactureerd, en gesprekken tussen twee mensen kosten op geen enkele weg credits. Bekijk videogesprekken en groepsgesprekken voor apps, of de prijzen voor apps. Vragen over je integratie? Schrijf ons.