Rozmowy wideo w JavaScript: jak WebRTC łączy dwie przeglądarki

Rozmowa wideo w JavaScript wymaga trzech rzeczy: getUserMedia() dla kamery i mikrofonu, RTCPeerConnection, które przenosi obraz i dźwięk między dwiema przeglądarkami, oraz własnego kanału sygnalizacji, najczęściej websocketu, który przekazuje między nimi ich oferty i adresy sieciowe. Media obsługuje przeglądarka, a wszystko wokół, od znalezienia drugiej osoby po przejście przez zaporę, musisz zbudować sam.
Ten wpis pokazuje cały czat wideo z WebRTC w mniej niż stu liniach czystego JavaScriptu, przetestowany w dwóch kartach przeglądarki, wyjaśnia każdą jego część, a potem omawia, co prawdziwa aplikacja musi do niego dodać, zanim ludzie będą mogli na nim polegać.
Trzy części rozmowy WebRTC
| Część | Co robi |
|---|---|
getUserMedia() |
Otwiera kamerę i mikrofon, gdy przeglądarka zapyta o zgodę |
RTCPeerConnection |
Łączy dwie przeglądarki i przenosi media, zaszyfrowane |
| Sygnalizacja | Przekazuje między nimi oferty, odpowiedzi i adresy, przez Twój serwer |
Dwie pierwsze są wbudowane w każdą nowoczesną przeglądarkę. Trzecia nie jest, i to celowo. JavaScript Session Establishment Protocol, który opisuje działanie API przeglądarki, zostawia aplikacji sposób, w jaki dwie przeglądarki docierają do siebie. Zanim popłynie jakikolwiek obraz, muszą wymienić dwa rodzaje wiadomości:
- Opis, ofertę od jednej strony i odpowiedź od drugiej, z listą mediów, które każda wyśle, i sposobem ich szyfrowania.
- Kandydatów, adresy, pod którymi każda przeglądarka może być osiągalna: własny w sieci lokalnej, publiczny, który widzi serwer STUN, i przekaźnik na serwerze TURN, jeśli go ma. Przeglądarki próbują ich parami, aż któraś zadziała (Serwery STUN i TURN).
Czat wideo w czystym JavaScripcie
Dwie osoby otwierają tę samą stronę i każda widzi drugą. Strona potrzebuje dwóch elementów wideo:
<video id="me" autoplay playsinline muted></video>
<video id="them" autoplay playsinline></video>
<script type="module" src="/call.js"></script>Twoje własne wideo ma muted, więc nie słyszysz samego siebie, a to pozwala też przeglądarce odtworzyć je, zanim ktokolwiek kliknie. playsinline zatrzymuje je na stronie na iPhonie.
Serwer sygnalizacyjny
Najmniejszy serwer sygnalizacyjny przekazuje każdą wiadomość od jednej przeglądarki do drugiej. W Node.js, z pakietem ws:
import { WebSocketServer, WebSocket } from 'ws';
const wss = new WebSocketServer({ port: 8080 });
wss.on('connection', (socket) => {
socket.on('message', (data) => {
// Przekaż dalej wszystkim innym połączonym: tutaj drugiej osobie.
for (const other of wss.clients) {
if (other !== socket && other.readyState === WebSocket.OPEN) {
other.send(data.toString());
}
}
});
});Nie wie nic o rozmowach. Przekazuje tylko tekst, a sygnalizacja to właśnie tylko tekst. Ten sam przekaźnik w kilku linijkach Pythona oraz program w Pythonie, który sam dołącza do rozmowy, znajdziesz we wpisie WebRTC w Pythonie. Node.js też może dołączyć do rozmowy, przez pakiet npm, który przynosi ze sobą API przeglądarki, co pokazuje wpis WebRTC w Node.js.
Strona
Obie przeglądarki uruchamiają ten sam kod. Każda otwiera kamerę, mówi, że jest, i dodaje kamerę do połączenia dopiero wtedy, gdy druga osoba też to powie, żeby pierwsza oferta do kogoś dotarła. Część, która odpowiada na wiadomości, stosuje wzorzec perfect negotiation z MDN, dzięki któremu zacząć może każda strona, nawet obie naraz:
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' }],
});
// Dodaj kamerę, gdy druga osoba już jest.
let started = false;
const start = () => {
if (started) return;
started = true;
for (const track of local.getTracks()) pc.addTrack(track, local);
};
// Jedna strona ustępuje, gdy obie wysyłają ofertę w tej samej chwili.
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 }); // żeby druga strona też zaczęła
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 });Uruchom serwer, udostępnij stronę z localhost i otwórz ją w jednej karcie, a jako /#polite w drugiej, w dowolnej kolejności. Każda karta poprosi o kamerę, a potem każda pokaże drugą. Na Twoim własnym serwerze strona działa przez HTTPS, więc adres websocketu zmienia się na wss:// z certyfikatem, a stun.example.com oznacza serwer STUN, z którego masz prawo korzystać.
Co dzieje się po kolei:
- Kamera się otwiera.
getUserMedia()najpierw pyta o zgodę. MDN zaznacza, że działa tylko w bezpiecznym kontekście, na stronie przez HTTPS albo nalocalhost, a odmowa kończy się błędemNotAllowedError. Gdy kamera pozostaje czarna, nasz poradnik o niedziałającej kamerze omawia każdą przyczynę. - Obie strony się odnajdują. Każda strona mówi
here, gdy się łączy. Pierwsza nikogo nie słyszy, a gdy pojawia się druga, pierwsza ją słyszy i odpowiada, więc obie wiedzą, że druga jest. - Dodanie ścieżek wywołuje negocjację. Połączenie wysyła zdarzenie
negotiationneeded, asetLocalDescription()bez argumentu tworzy ofertę, która wychodzi przez websocket. - Druga strona odpowiada. Ustawia ofertę jako swój zdalny opis, w ten sam sposób tworzy odpowiedź i odsyła ją.
- Obie zbierają kandydatów i wysyłają każdego, gdy tylko go znajdą. Przeglądarki sprawdzają pary adresów i wybierają taką, która działa, najpierw bezpośrednie.
- Media płyną. Po każdej stronie wywoływane jest
ontracki pojawia się druga osoba. W drodze są zawsze szyfrowane, bo WebRTC tego wymaga (RFC 8827). Poproś tylko o{ audio: true }, a ten sam kod wykona rozmowę głosową, którą rozmowy głosowe i pokoje audio mierzą i objaśniają.
Ponieważ obie karty dodają kamerę mniej więcej w tej samej chwili, obie mogą wysłać ofertę. To właśnie kolizję rozwiązuje ten wzorzec: uprzejma strona porzuca własną ofertę i odpowiada na ofertę drugiej, a nieuprzejma ignoruje ofertę, która minęła się z jej własną.
Bez kroku 2 pierwsza karta wysłałaby ofertę, gdy jest sama, serwer przekazałby ją nikomu, a rozmowa nigdy by się nie zaczęła. Oferta, której nikt nie słyszy, to częsty powód, dla którego pierwsze demo WebRTC pokazuje dwa czarne prostokąty.
Czego demo nie obejmuje
Demo działa między dwiema kartami w jednej sieci. Aplikacja potrzebuje więcej, zanim jej użytkownicy będą mogli na niej polegać.
- Kto może dzwonić do kogo. Powyższy serwer przekazuje każdą wiadomość każdemu. Prawdziwy sprawdza, kto jest zalogowany i czy może dzwonić do tej osoby, zanim do kogokolwiek zadzwoni.
- Dzwonienie. Osoba, do której dzwonisz, musi to usłyszeć na każdej stronie, na której jest, w każdej karcie, i przestać to słyszeć wszędzie, gdy odbierze w jednej. To wymaga połączenia utrzymywanego dla każdego użytkownika przez cały czas, gdy jest na stronie (websockety na więcej niż jednym serwerze pokazują, czego to wymaga, gdy masz więcej niż jeden).
- Przekaźniki. Serwer STUN znajduje adresy publiczne, a to nie wystarcza za wieloma firmowymi zaporami i w sieciach komórkowych. Takie rozmowy potrzebują serwera TURN, z loginami, które wygasają, na portach, które takie sieci zostawiają otwarte (porty, których potrzebuje rozmowa).
- Ponowne łączenie. Telefon, który przechodzi z Wi-Fi na dane komórkowe, traci swoją drogę. Obserwuj
connectionStatei wywołajpc.restartIce(), gdy połączenie zawiedzie, żeby przeglądarki poszukały nowej pary adresów bez rozłączania. - Więcej niż dwie osoby. W tym układzie każda osoba wysyła swoje wideo do każdej innej. Przy trzech albo czterech to wystarcza, potem wysyłanie przestaje nadążać, i dlatego rozmowy grupowe idą przez serwery mediów (jak działają grupowe rozmowy wideo).
- Błędy, które widzą ludzie. Odrzucona kamera, brak mikrofonu, rozmowa, której nikt nie odbiera. Dlaczego połączenie WebRTC się nie udaje omawia, co sprawdzić po obu stronach.
Każdą z tych rzeczy można zbudować na tym samym API, i to właśnie ta praca stoi za większością produktów do czatu wideo. Druga droga to zostawić połączenia, dzwonienie i przekaźniki usłudze, a na swoim serwerze zatrzymać jedyną część, która naprawdę dotyczy Twojej aplikacji: kto może dzwonić do kogo. Jak wybrać API do rozmów wideo wymienia pytania, które warto takiej usłudze zadać.
Ta sama rozmowa z WordPlus Cloud
Z SDK WordPlus Cloud strona w czystym JavaScripcie wykonuje rozmowy bez serwera sygnalizacyjnego, przekaźnika i ekranu rozmowy do napisania. Twój serwer określa, kto może dzwonić, jako regułę dla każdej rozmowy, której nazwa pasuje do wzorca. Tutaj rozmowa z pomocą techniczną, taka jak support:34:42, jest dla dwóch osób z jej nazwy:
// server.mjs, z realtime z createRealtime() z @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));
});Strona łączy się z ustawieniami, które Twój serwer w niej wyrenderował, uruchamia ekran rozmowy i umieszcza przycisk tam, skąd ludzie dzwonią:
import { connect } from '@wordplus/realtime';
const rt = await connect(JSON.parse(document.getElementById('realtime').textContent));
await rt.callScreen(); // dzwonek i okno rozmowy, na tej stronie<call-button to="34" call="support:{pair}" type="video" name="Ann">Call Ann</call-button>Rozmowa dzwoni w każdej karcie i na każdym urządzeniu, które Ann ma otwarte. Idzie bezpośrednio między dwiema przeglądarkami, gdy pozwalają na to ich sieci, przez nasze przekaźniki na portach 443 i 80, gdy nie pozwalają, i przez nasze serwery mediów, gdy nawet przekaźniki nie mogą dotrzeć, przechodząc z jednej drogi na drugą bez rozłączania. Rozmowy między dwiema osobami są szyfrowane end-to-end na każdej drodze. Dla własnego ekranu rt.calls() daje Ci te same rozmowy bez gotowych części, calls.start(), żeby zadzwonić, i zdarzenie incoming, żeby odebrać.
Rozmowy w naszej dokumentacji pokazują każdy sposób, by zadzwonić, od przycisku po własny interfejs, a przewodnik po rozmowach wideo w Next.js wbudowuje je w całą aplikację.
Rozmowy wideo dla Twojej aplikacji
WordPlus Cloud for Apps ma cenę według jednoczesnych połączeń, od 1000 wzwyż, rozliczaną miesięcznie lub rocznie, a rozmowy między dwiema osobami nie zużywają kredytów na żadnej drodze. Zobacz rozmowy wideo i rozmowy grupowe dla aplikacji albo cennik dla aplikacji. Masz pytania o swoją integrację? Napisz do nas.