Videochiamate in JavaScript: come WebRTC collega due browser

Una videochiamata in JavaScript richiede tre cose: getUserMedia() per la fotocamera e il microfono, una RTCPeerConnection che porta l’immagine e il suono tra i due browser, e un canale di signaling tutto tuo, il più delle volte un WebSocket, che passa dall’uno all’altro le loro offerte e i loro indirizzi di rete. Il browser si occupa dei media, e tutto ciò che sta intorno, dal trovare l’altra persona all’attraversare un firewall, tocca a te costruirlo.
Questo articolo mostra un’intera videochat con WebRTC in meno di cento righe di JavaScript puro, provata in due schede del browser, ne spiega ogni parte, e poi passa in rassegna ciò che un’app vera ci aggiunge prima che le persone possano contarci.
Le tre parti di una chiamata WebRTC
| Parte | Cosa fa |
|---|---|
getUserMedia() |
Apre la fotocamera e il microfono, dopo che il browser lo chiede |
RTCPeerConnection |
Collega i due browser e porta i media, cifrati |
| Signaling | Passa offerte, risposte e indirizzi tra loro, tramite il tuo server |
Le prime due sono integrate in ogni browser moderno. La terza no, di proposito. Il JavaScript Session Establishment Protocol, che descrive come funziona l’API del browser, lascia all’app il modo in cui due browser si raggiungono. Prima che passi qualsiasi immagine, devono scambiarsi due tipi di messaggio:
- Una descrizione, un’offerta da un lato e una risposta dall’altro, che elenca i media che ognuno invierà e come sono cifrati.
- I candidati, gli indirizzi a cui ogni browser potrebbe essere raggiunto: il suo sulla rete locale, quello pubblico che vede un server STUN, e un relay su un server TURN, se ne ha uno. I browser li provano a coppie finché una non funziona (i server STUN e TURN, spiegati).
Una videochat in JavaScript puro
Due persone aprono la stessa pagina, e ognuna vede l’altra. Alla pagina servono due elementi video:
<video id="me" autoplay playsinline muted></video>
<video id="them" autoplay playsinline></video>
<script type="module" src="/call.js"></script>Il tuo video è muted, così non senti te stesso, e questo permette anche al browser di riprodurlo prima che qualcuno faccia clic. playsinline lo tiene dentro la pagina su un iPhone.
Il server di signaling
Il server di signaling più piccolo passa ogni messaggio da un browser all’altro. In Node.js, con il pacchetto ws:
import { WebSocketServer, WebSocket } from 'ws';
const wss = new WebSocketServer({ port: 8080 });
wss.on('connection', (socket) => {
socket.on('message', (data) => {
// Lo passa a tutti gli altri connessi: qui, all’altra persona.
for (const other of wss.clients) {
if (other !== socket && other.readyState === WebSocket.OPEN) {
other.send(data.toString());
}
}
});
});Non sa nulla di chiamate. Si limita a inoltrare testo, ed è tutto ciò che il signaling è. Lo stesso relay in poche righe di Python, e un programma Python che entra lui stesso nella chiamata, sono in WebRTC in Python. Anche Node.js può entrare in una chiamata, con un pacchetto npm che porta con sé l’API del browser, come mostra WebRTC in Node.js.
La pagina
Entrambi i browser eseguono lo stesso codice. Ognuno apre la propria fotocamera, dice di essere lì, e aggiunge la fotocamera alla connessione quando anche l’altra persona lo ha detto, così la prima offerta raggiunge qualcuno. La parte che risponde ai messaggi segue lo schema della perfect negotiation di MDN, che permette a entrambi i lati di iniziare, anche tutti e due insieme:
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' }],
});
// Aggiunge la fotocamera quando l’altra persona è lì.
let started = false;
const start = () => {
if (started) return;
started = true;
for (const track of local.getTracks()) pc.addTrack(track, local);
};
// Un lato cede quando entrambi fanno un’offerta nello stesso momento.
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 }); // così anche l’altro lato inizia
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 });Avvia il server, servi la pagina da localhost, e aprila in una scheda, e come /#polite in un’altra, in qualsiasi ordine. Ogni scheda chiede la fotocamera, e poi ognuna mostra l’altra. Su un tuo server la pagina è in HTTPS, quindi l’indirizzo del WebSocket diventa wss:// con un certificato, e stun.example.com sta per un server STUN che hai il diritto di usare.
Cosa succede, in ordine:
- La fotocamera si apre.
getUserMedia()prima chiede alla persona. MDN fa notare che funziona solo in un contesto sicuro, una pagina in HTTPS o sulocalhost, e che un rifiuto viene respinto conNotAllowedError. Quando una fotocamera resta nera, la nostra guida a una fotocamera che non funziona passa in rassegna ogni causa. - I due si trovano. Ogni pagina dice
herequando si collega. La prima non sente nessuno, e quando arriva la seconda, la prima la sente e risponde, così entrambe sanno che l’altra c’è. - Aggiungere le tracce richiede una negoziazione. La connessione genera
negotiationneeded, esetLocalDescription()senza argomenti crea un’offerta, che parte attraverso il WebSocket. - L’altro lato risponde. Imposta l’offerta come sua descrizione remota, crea una risposta allo stesso modo e la rimanda indietro.
- Entrambi raccolgono i candidati e li inviano uno per uno, man mano che li trovano. I browser provano coppie di indirizzi l’uno contro l’altro e si fermano su una che funziona, prima quelle dirette.
- I media passano.
ontrackscatta su ogni lato, e appare l’altra persona. Lungo il percorso sono cifrati, sempre: WebRTC lo richiede (RFC 8827). Chiedi soltanto{ audio: true }e lo stesso codice avvia una chiamata vocale, che chiamate vocali e stanze audio misura e spiega.
Dato che entrambe le schede aggiungono la fotocamera più o meno nello stesso momento, entrambe possono fare un’offerta. È la collisione che lo schema risolve: il lato polite lascia cadere la propria offerta e risponde a quella dell’altro, e il lato impolite ignora l’offerta che ha incrociato la sua.
Senza il passo 2, la prima scheda farebbe un’offerta mentre è da sola, il server la passerebbe a nessuno, e la chiamata non partirebbe mai. Un’offerta che nessuno sente è un motivo frequente per cui una prima demo WebRTC mostra due riquadri neri.
Cosa lascia fuori la demo
La demo funziona tra due schede sulla stessa rete. Un’app ha bisogno di altro prima che i suoi utenti possano contarci.
- Chi può chiamare chi. Il server qui sopra passa qualsiasi messaggio a chiunque. Uno vero controlla chi ha effettuato l’accesso, e se può chiamare quella persona, prima di far squillare qualcuno.
- Lo squillo. La persona chiamata deve sentirlo su qualunque pagina si trovi, in ogni scheda, e smettere di sentirlo ovunque appena risponde in una. Serve una connessione tenuta aperta per ogni utente, per tutto il tempo che passa sul sito (i WebSocket oltre un solo server mostra cosa comporta quando i server sono più di uno).
- I relay. Un server STUN trova gli indirizzi pubblici, e non basta dietro molti firewall d’ufficio e su molte reti mobili. Quelle chiamate hanno bisogno di un server TURN, con login che scadono, su porte che quelle reti lasciano aperte (le porte che servono a una chiamata).
- La riconnessione. Un telefono che passa dal Wi-Fi ai dati mobili perde il suo percorso. Tieni d’occhio
connectionState, e chiamapc.restartIce()quando fallisce, così i browser cercano una nuova coppia di indirizzi senza riagganciare. - Più di due persone. In questo schema ogni persona invia il proprio video a ciascuna delle altre. Regge per tre o quattro, poi gli upload cedono, ed è per questo che le chiamate di gruppo passano per i media server (come funzionano le videochiamate di gruppo).
- Gli errori che le persone vedono. Una fotocamera rifiutata, un microfono che manca, una chiamata a cui nessuno risponde. Perché una connessione WebRTC non riesce spiega cosa controllare da entrambi i lati.
Ognuna di queste cose si può costruire sulla stessa API, ed è il lavoro che sta dietro la maggior parte dei prodotti di videochat. L’altra strada è lasciare a un servizio le connessioni, lo squillo e i relay, e tenere sul tuo server l’unica parte che riguarda davvero la tua app: chi può chiamare chi. Come scegliere un’API per videochiamate elenca le domande da fargli.
La stessa chiamata con WordPlus Cloud
Con l’SDK di WordPlus Cloud, una pagina in JavaScript puro avvia chiamate senza un server di signaling, un relay o una schermata di chiamata da scrivere. Il tuo server dichiara chi può chiamare, come regola per ogni chiamata il cui nome corrisponde a uno schema. Qui una chiamata di assistenza come support:34:42 è per le due persone nel suo nome:
// server.mjs, con realtime da createRealtime() di @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));
});La pagina si collega con le impostazioni che il tuo server vi ha inserito, avvia la schermata di chiamata e mette un pulsante dove le persone chiamano:
import { connect } from '@wordplus/realtime';
const rt = await connect(JSON.parse(document.getElementById('realtime').textContent));
await rt.callScreen(); // lo squillo e la finestra di chiamata, su questa pagina<call-button to="34" call="support:{pair}" type="video" name="Ann">Call Ann</call-button>La chiamata squilla in ogni scheda e su ogni dispositivo che Ann ha aperto. Va direttamente tra i due browser quando le loro reti lo consentono, attraverso i nostri relay sulle porte 443 e 80 quando non lo consentono, e attraverso i nostri media server quando nemmeno i relay arrivano, passando dall’uno all’altro senza riagganciare. Le chiamate tra due persone sono cifrate end-to-end su ogni percorso. Per una schermata tutta tua, rt.calls() ti dà le stesse chiamate senza parti già pronte, calls.start() per avviarne una e un evento incoming per rispondere.
Le chiamate nella nostra documentazione mostrano ogni modo di avviarne una, da un pulsante alla tua interfaccia, e la guida alle videochiamate in Next.js le integra in un’app intera.
Videochiamate per la tua app
WordPlus Cloud for Apps ha un prezzo in base alle connessioni simultanee, a partire da 1.000, con fatturazione mensile o annuale, e le chiamate tra due persone non consumano crediti su nessun percorso. Scopri videochiamate e chiamate di gruppo per le app, oppure i prezzi per le app. Domande sulla tua integrazione? Scrivici.