Les appels vidéo en JavaScript : comment WebRTC relie deux navigateurs

Un appel vidéo en JavaScript demande trois choses : getUserMedia() pour la caméra et le micro, un RTCPeerConnection qui transporte l’image et le son entre les deux navigateurs, et un canal de signalisation à vous, le plus souvent un websocket, qui leur fait passer leurs offres et leurs adresses réseau. Le navigateur s’occupe des médias, et tout ce qui les entoure, de trouver l’autre personne à traverser un pare-feu, c’est à vous de le construire.
Cet article montre un chat vidéo complet avec WebRTC en moins de cent lignes de JavaScript pur, testé dans deux onglets, explique chaque partie, puis passe en revue ce qu’une vraie application y ajoute avant que les gens puissent compter dessus.
Les trois parties d’un appel WebRTC
| Partie | Ce qu’elle fait |
|---|---|
getUserMedia() |
Ouvre la caméra et le micro, après que le navigateur a demandé |
RTCPeerConnection |
Relie les deux navigateurs et transporte les médias, chiffrés |
| Signalisation | Fait passer offres, réponses et adresses entre eux, par votre serveur |
Les deux premières sont intégrées à tout navigateur moderne. La troisième ne l’est pas, et c’est voulu. Le JavaScript Session Establishment Protocol, qui décrit le fonctionnement de l’API du navigateur, laisse à l’application la façon dont deux navigateurs se joignent. Ils doivent échanger deux sortes de messages avant que la moindre image ne passe :
- Une description, une offre d’un côté et une réponse de l’autre, qui liste les médias que chacun enverra et la façon dont ils sont chiffrés.
- Des candidates, les adresses où chaque navigateur pourrait être joint : la sienne sur le réseau local, l’adresse publique que voit un serveur STUN, et un relais sur un serveur TURN, s’il en a un. Les navigateurs les essaient par paires jusqu’à ce que l’une fonctionne (les serveurs STUN et TURN, expliqués).
Un chat vidéo en JavaScript pur
Deux personnes ouvrent la même page, et chacune voit l’autre. La page a besoin de deux éléments vidéo :
<video id="me" autoplay playsinline muted></video>
<video id="them" autoplay playsinline></video>
<script type="module" src="/call.js"></script>Votre propre vidéo est muted, pour que vous ne vous entendiez pas, ce qui permet aussi au navigateur de la lire avant que quiconque clique. playsinline la garde dans la page sur un iPhone.
Le serveur de signalisation
Le plus petit serveur de signalisation fait passer chaque message d’un navigateur à l’autre. En Node.js, avec le paquet ws :
import { WebSocketServer, WebSocket } from 'ws';
const wss = new WebSocketServer({ port: 8080 });
wss.on('connection', (socket) => {
socket.on('message', (data) => {
// Le transmettre à tous les autres connectés : ici, l’autre personne.
for (const other of wss.clients) {
if (other !== socket && other.readyState === WebSocket.OPEN) {
other.send(data.toString());
}
}
});
});Il ne sait rien des appels. Il ne fait que relayer du texte, et la signalisation n’est rien de plus. Le même relais en quelques lignes de Python, et un programme Python qui rejoint lui-même l’appel, sont dans WebRTC en Python. Node.js peut aussi rejoindre un appel, grâce à un paquet npm qui apporte l’API du navigateur avec lui, comme le montre WebRTC en Node.js.
La page
Les deux navigateurs exécutent le même code. Chacun ouvre sa caméra, annonce qu’il est là, et ajoute la caméra à la connexion une fois que l’autre personne l’a annoncé à son tour, pour que la première offre parvienne à quelqu’un. La partie qui répond aux messages suit le modèle de la négociation parfaite décrit par MDN, qui permet à l’un ou l’autre côté de commencer, même aux deux à la fois :
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' }],
});
// Ajouter la caméra une fois l’autre personne présente.
let started = false;
const start = () => {
if (started) return;
started = true;
for (const track of local.getTracks()) pc.addTrack(track, local);
};
// Un côté cède quand les deux font une offre au même moment.
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 }); // pour que l’autre côté commence aussi
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 });Lancez le serveur, servez la page depuis localhost, et ouvrez-la dans un onglet, puis en /#polite dans un autre, dans n’importe quel ordre. Chaque onglet demande la caméra, puis chacun affiche l’autre. Sur un serveur à vous, la page est en HTTPS, si bien que l’adresse du websocket devient wss:// avec un certificat, et stun.example.com désigne un serveur STUN que vous avez le droit d’utiliser.
Ce qui se passe, dans l’ordre :
- La caméra s’ouvre.
getUserMedia()demande d’abord l’accord de la personne. MDN précise qu’il ne fonctionne que dans un contexte sécurisé, une page en HTTPS ou surlocalhost, et qu’un refus est rejeté avecNotAllowedError. Quand une caméra reste noire, notre guide sur une caméra qui ne fonctionne pas passe en revue chaque cause. - Les deux se trouvent. Chaque page envoie
hereen se connectant. La première n’entend personne, et quand la seconde arrive, la première l’entend et répond, si bien que chacune sait que l’autre est là. - L’ajout des pistes demande une négociation. La connexion déclenche
negotiationneeded, etsetLocalDescription()sans argument crée une offre, qui part par le websocket. - L’autre côté répond. Il pose l’offre comme description distante, crée une réponse de la même façon, et la renvoie.
- Les deux rassemblent des candidates et envoient chacune dès qu’elle est trouvée. Les navigateurs testent des paires d’adresses l’une contre l’autre et retiennent celle qui fonctionne, les directes d’abord.
- Les médias passent.
ontrackse déclenche de chaque côté, et l’autre personne apparaît. Les médias sont chiffrés en chemin, toujours : WebRTC l’exige (RFC 8827). Demandez{ audio: true }seul et le même code passe un appel vocal, mesuré et expliqué dans appels vocaux et salons audio.
Comme les deux onglets ajoutent leur caméra à peu près au même moment, les deux peuvent faire une offre. C’est la collision que résout le modèle : le côté poli abandonne sa propre offre et répond à celle de l’autre, et le côté impoli ignore l’offre qui a croisé la sienne.
Sans l’étape 2, le premier onglet ferait une offre alors qu’il est seul, le serveur ne la transmettrait à personne, et l’appel ne démarrerait jamais. Une offre que personne n’entend est une raison courante pour laquelle une première démo WebRTC affiche deux cadres noirs.
Ce que la démo laisse de côté
La démo fonctionne entre deux onglets sur un même réseau. Une application a besoin de plus avant que ses utilisateurs puissent compter dessus.
- Qui peut appeler qui. Le serveur ci-dessus transmet n’importe quel message à n’importe qui. Un vrai serveur vérifie qui est connecté, et si cette personne peut en appeler une autre, avant de faire sonner qui que ce soit.
- La sonnerie. La personne appelée doit l’entendre sur n’importe quelle page où elle se trouve, dans chaque onglet, et cesser de l’entendre partout dès qu’elle répond dans l’un d’eux. Il faut pour cela une connexion gardée ouverte pour chaque utilisateur, pendant tout le temps qu’il passe sur le site (les websockets au-delà d’un seul serveur montre ce que cela demande dès que vous en avez plusieurs).
- Les relais. Un serveur STUN trouve les adresses publiques, et cela ne suffit pas derrière beaucoup de pare-feu de bureau et de réseaux mobiles. Ces appels ont besoin d’un serveur TURN, avec des identifiants qui expirent, sur des ports que ces réseaux laissent ouverts (les ports dont un appel a besoin).
- La reconnexion. Un téléphone qui passe du Wi-Fi aux données mobiles perd son chemin. Surveillez
connectionState, et appelezpc.restartIce()quand la connexion échoue, pour que les navigateurs cherchent une nouvelle paire d’adresses sans raccrocher. - Plus de deux personnes. Dans ce montage, chaque personne envoie sa vidéo à chacune des autres. Cela tient pour trois ou quatre, puis les envois saturent, et c’est pourquoi les appels de groupe passent par des serveurs multimédias (comment fonctionnent les appels vidéo de groupe).
- Les erreurs que voient les gens. Une caméra refusée, un micro absent, un appel auquel personne ne répond. Pourquoi une connexion WebRTC échoue passe en revue ce qu’il faut vérifier des deux côtés.
Chacun de ces points peut se construire sur la même API, et c’est le travail derrière la plupart des produits de chat vidéo. L’autre voie consiste à confier les connexions, la sonnerie et les relais à un service, et à garder sur votre serveur la seule partie qui concerne vraiment votre application : qui peut appeler qui. Comment choisir une API d’appels vidéo liste les questions à lui poser.
Le même appel avec WordPlus Cloud
Avec le SDK de WordPlus Cloud, une page en JavaScript pur passe des appels sans serveur de signalisation, sans relais ni écran d’appel à écrire. Votre serveur déclare qui peut appeler, sous la forme d’une règle pour chaque appel dont le nom correspond à un modèle. Ici, un appel d’assistance comme support:34:42 est réservé aux deux personnes de son nom :
// server.mjs, avec realtime issu de createRealtime() de @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 page se connecte avec les réglages que votre serveur y a placés, démarre l’écran d’appel, et pose un bouton là d’où les gens appellent :
import { connect } from '@wordplus/realtime';
const rt = await connect(JSON.parse(document.getElementById('realtime').textContent));
await rt.callScreen(); // la sonnerie et la fenêtre d’appel, sur cette page<call-button to="34" call="support:{pair}" type="video" name="Ann">Call Ann</call-button>L’appel sonne dans chaque onglet et sur chaque appareil qu’Ann a ouverts. Il passe directement entre les deux navigateurs quand leurs réseaux le permettent, par nos relais sur les ports 443 et 80 quand ils ne le permettent pas, et par nos serveurs multimédias quand même les relais ne passent pas, en basculant de l’un à l’autre sans raccrocher. Les appels entre deux personnes sont chiffrés de bout en bout sur chaque chemin. Pour un écran à vous, rt.calls() vous donne les mêmes appels sans aucune pièce prête à l’emploi, calls.start() pour en passer un et un événement incoming pour répondre.
Les appels dans notre documentation montrent chaque façon d’en passer un, d’un bouton à votre propre interface, et le guide des appels vidéo avec Next.js les intègre à une application entière.
Des appels vidéo pour votre application
WordPlus Cloud for Apps a un prix selon les connexions simultanées, à partir de 1 000, facturé au mois ou à l’année, et les appels entre deux personnes ne prennent aucun crédit, quel que soit le chemin. Découvrez les appels vidéo et les appels de groupe pour les applications, ou les tarifs pour les applications. Des questions sur votre intégration ? Écrivez-nous.