1. Wprowadzenie
WebRTC to projekt typu open source, który umożliwia komunikację w czasie rzeczywistym za pomocą dźwięku, obrazu i danych w aplikacjach internetowych i natywnych.
WebRTC ma kilka interfejsów JavaScript API – kliknij linki, aby zobaczyć wersje demonstracyjne.
getUserMedia(): nagrywanie dźwięku i obrazu.MediaRecorder: nagrywanie dźwięku i obrazu.RTCPeerConnection: przesyłanie strumieniowe dźwięku i obrazu między użytkownikami.RTCDataChannel: przesyłanie danych między użytkownikami.
Gdzie mogę korzystać z WebRTC?
W przeglądarkach Firefox, Opera i Chrome na komputerach i urządzeniach z Androidem. WebRTC jest też dostępny w aplikacjach natywnych na iOS i Androida.
Co to jest sygnalizacja?
WebRTC używa RTCPeerConnection do przesyłania danych strumieniowych między przeglądarkami, ale potrzebuje też mechanizmu do koordynowania komunikacji i wysyłania komunikatów sterujących. Proces ten jest nazywany sygnalizacją. Metody i protokoły sygnalizacji nie są określone przez WebRTC. W tym ćwiczeniu do obsługi wiadomości użyjesz Socket.IO, ale istnieje wiele alternatyw.
Czym są STUN i TURN?
WebRTC działa w trybie peer-to-peer, dzięki czemu użytkownicy mogą łączyć się najbardziej bezpośrednią drogą. WebRTC jest jednak zaprojektowany do obsługi sieci w świecie rzeczywistym: aplikacje klienckie muszą przechodzić przez bramy NAT i zapory sieciowe, a sieci peer-to-peer wymagają rozwiązań zastępczych w przypadku niepowodzenia połączenia bezpośredniego. W ramach tego procesu interfejsy WebRTC API używają serwerów STUN do uzyskiwania adresu IP komputera oraz serwerów TURN, które działają jako serwery przekazujące, gdy komunikacja peer-to-peer się nie powiedzie. (więcej informacji znajdziesz w artykule WebRTC in the real world).
Czy WebRTC jest bezpieczny?
Szyfrowanie jest obowiązkowe w przypadku wszystkich komponentów WebRTC, a interfejsy JavaScript API mogą być używane tylko z bezpiecznych źródeł (HTTPS lub localhost). Mechanizmy sygnalizacyjne nie są zdefiniowane przez standardy WebRTC, więc musisz zadbać o korzystanie z bezpiecznych protokołów.
2. Przegląd
Utwórz aplikację, która będzie nagrywać filmy i robić zdjęcia za pomocą kamery internetowej, a następnie udostępniać je w sieci peer-to-peer przy użyciu WebRTC. Przy okazji dowiesz się, jak używać podstawowych interfejsów WebRTC API i skonfigurować serwer wiadomości za pomocą Node.js.
Czego się nauczysz
- Pobieranie obrazu z kamery internetowej
- Strumieniowe przesyłanie wideo za pomocą RTCPeerConnection
- Strumieniowe przesyłanie danych za pomocą RTCDataChannel
- Konfigurowanie usługi sygnalizacyjnej do wymiany wiadomości
- Łączenie połączenia równorzędnego i sygnalizacji
- zrobić zdjęcie i udostępnić je za pomocą kanału danych,
Czego potrzebujesz
- Chrome 47 lub nowsza,
- Web Server for Chrome lub użyj własnego serwera WWW.
- Przykładowy kod
- edytor tekstu,
- podstawowa znajomość języków HTML, CSS i JavaScript;
3. Pobieranie przykładowego kodu
Pobieranie kodu
Jeśli znasz Gita, możesz pobrać kod do tego ćwiczenia z GitHuba, klonując go:
git clone https://github.com/googlecodelabs/webrtc-web
Możesz też kliknąć ten przycisk, aby pobrać plik ZIP z kodem:
Otwórz pobrany plik ZIP. Spowoduje to rozpakowanie folderu projektu (adaptive-web-media), który zawiera po 1 folderze dla każdego kroku tego ćwiczenia, wraz ze wszystkimi potrzebnymi zasobami.
Całą pracę związaną z kodowaniem będziesz wykonywać w katalogu o nazwie work.
Foldery step-nn zawierają gotową wersję każdego kroku tego ćwiczenia. Są one tam tylko w celach informacyjnych.
Instalowanie i weryfikowanie serwera WWW
Możesz użyć własnego serwera WWW, ale to ćwiczenie w Codelabs zostało zaprojektowane tak, aby działało dobrze z serwerem WWW Chrome. Jeśli nie masz jeszcze tej aplikacji, możesz ją zainstalować z Chrome Web Store.

Po zainstalowaniu aplikacji Web Server for Chrome kliknij skrót do aplikacji Chrome na pasku zakładek, na stronie Nowa karta lub w Menu z aplikacjami:

Kliknij ikonę serwera WWW:

Następnie zobaczysz to okno, w którym możesz skonfigurować lokalny serwer WWW:

Kliknij przycisk CHOOSE FOLDER (Wybierz folder) i wybierz utworzony przed chwilą folder work. Dzięki temu będziesz mieć możliwość wyświetlania swojej pracy w toku w Chrome, korzystając z adresu URL wyróżnionego w oknie Web Server w sekcji Web Server URL(s) (Adresy URL serwera WWW).
W sekcji Opcje zaznacz pole obok opcji Automatycznie wyświetlaj plik index.html, jak pokazano poniżej:

Następnie zatrzymaj i ponownie uruchom serwer, przesuwając przełącznik Web Server: STARTED (Serwer WWW: URUCHOMIONY) w lewo, a potem z powrotem w prawo.

Teraz otwórz witrynę roboczą w przeglądarce, klikając podświetlony adres URL serwera WWW. Powinna Ci się wyświetlić strona podobna do tej, która odpowiada plikowi work/index.html:

Oczywiście ta aplikacja nie robi jeszcze niczego ciekawego – na razie jest to tylko minimalny szkielet, którego używamy, aby upewnić się, że serwer WWW działa prawidłowo. W kolejnych krokach dodasz funkcje i elementy układu.
4. Strumieniowanie wideo z kamery internetowej
Czego się nauczysz
Z tego kroku dowiesz się, jak:
- pobierać strumień wideo z kamery internetowej,
- Manipulowanie odtwarzaniem transmisji.
- Używaj CSS i SVG do manipulowania filmem.
Pełna wersja tego kroku znajduje się w folderze step-01.
Odrobina HTML…
Dodaj element video i element script do pliku index.html w katalogu work:
<!DOCTYPE html>
<html>
<head>
<title>Realtime communication with WebRTC</title>
<link rel="stylesheet" href="css/main.css">
</head>
<body>
<h1>Realtime communication with WebRTC</h1>
<video autoplay playsinline></video>
<script src="js/main.js"></script>
</body>
</html>
…i odrobinę JavaScriptu.
Dodaj do pliku main.js w folderze js ten kod:
'use strict';
// On this codelab, you will be streaming only video (video: true).
const mediaStreamConstraints = {
video: true,
};
// Video element where stream will be placed.
const localVideo = document.querySelector('video');
// Local stream that will be reproduced on the video.
let localStream;
// Handles success by adding the MediaStream to the video element.
function gotLocalMediaStream(mediaStream) {
localStream = mediaStream;
localVideo.srcObject = mediaStream;
}
// Handles error by logging a message to the console with the error message.
function handleLocalMediaStreamError(error) {
console.log('navigator.getUserMedia error: ', error);
}
// Initializes media stream.
navigator.mediaDevices.getUserMedia(mediaStreamConstraints)
.then(gotLocalMediaStream).catch(handleLocalMediaStreamError);
Wypróbuj
Otwórz plik index.html w przeglądarce. Powinien wyświetlić się taki widok (oczywiście z obrazem z Twojej kamery internetowej):

Jak to działa
Po wywołaniu getUserMedia() przeglądarka prosi użytkownika o pozwolenie na dostęp do kamery (jeśli jest to pierwsza prośba o dostęp do kamery w przypadku bieżącego źródła). Jeśli operacja się powiedzie, zwracany jest obiekt MediaStream, który może być używany przez element multimedialny za pomocą atrybutu srcObject:
navigator.mediaDevices.getUserMedia(mediaStreamConstraints)
.then(gotLocalMediaStream).catch(handleLocalMediaStreamError);
}
function gotLocalMediaStream(mediaStream) {
localVideo.srcObject = mediaStream;
}
Argument constraints pozwala określić, jakie multimedia chcesz pobrać. W tym przykładzie tylko wideo, ponieważ dźwięk jest domyślnie wyłączony:
const mediaStreamConstraints = {
video: true,
};
Możesz użyć ograniczeń, aby określić dodatkowe wymagania, takie jak rozdzielczość filmu:
const hdConstraints = {
video: {
width: {
min: 1280
},
height: {
min: 720
}
}
}
Specyfikacja MediaTrackConstraints zawiera listę wszystkich potencjalnych typów ograniczeń, ale nie wszystkie opcje są obsługiwane przez wszystkie przeglądarki. Jeśli wybrana kamera nie obsługuje żądanej rozdzielczości, metoda getUserMedia() zostanie odrzucona z błędem OverconstrainedError, a użytkownik nie zostanie poproszony o przyznanie uprawnień dostępu do kamery.
Jeśli metoda getUserMedia() zakończy się powodzeniem, strumień wideo z kamery internetowej zostanie ustawiony jako źródło elementu wideo:
function gotLocalMediaStream(mediaStream) {
localVideo.srcObject = mediaStream;
}
Punkty bonusowe
- Obiekt
localStreamprzekazany dogetUserMedia()znajduje się w zakresie globalnym, więc możesz go sprawdzić w konsoli przeglądarki: otwórz konsolę, wpisz stream i naciśnij Enter. (Aby wyświetlić konsolę w Chrome, naciśnij Ctrl-Shift-J lub Command-Option-J na Macu). - Co zwraca
localStream.getVideoTracks()? - Spróbuj zadzwonić do użytkownika
localStream.getVideoTracks()[0].stop(). - Spójrz na obiekt constraints: co się stanie, gdy zmienisz go na
{audio: true, video: true}? - Jaki jest rozmiar elementu wideo? Jak można uzyskać naturalny rozmiar filmu z JavaScriptu, w odróżnieniu od rozmiaru wyświetlania? Sprawdź to za pomocą Narzędzi deweloperskich w Chrome.
- Spróbuj dodać filtry CSS do elementu wideo. Na przykład:
video {
filter: blur(4px) invert(1) opacity(0.5);
}
- Spróbuj dodać filtry SVG. Na przykład:
video {
filter: hue-rotate(180deg) saturate(200%);
}
Czego się nauczysz
W tym kroku dowiedzieliśmy się, jak:
- pobierać obraz z kamery internetowej,
- Ustaw ograniczenia multimediów.
- modyfikować elementu wideo,
Pełna wersja tego kroku znajduje się w folderze step-01.
Wskazówki
- Nie zapomnij o atrybucie
autoplayw elemencievideo. Bez tego zobaczysz tylko jedną klatkę. - Istnieje wiele innych opcji ograniczeń
getUserMedia(). Prezentację znajdziesz na stronie webrtc.github.io/samples/src/content/peerconnection/constraints. Jak zobaczysz, na tej stronie jest wiele interesujących przykładów WebRTC.
Sprawdzona metoda
- Upewnij się, że element wideo nie przekracza rozmiaru kontenera. Dodaliśmy
widthimax-width, aby ustawić preferowany i maksymalny rozmiar filmu. Przeglądarka automatycznie obliczy wysokość:
video {
max-width: 100%;
width: 320px;
}
Dalsze czynności
Masz film, ale jak go transmitować? Dowiesz się tego w następnym kroku.
5. Strumieniowanie wideo za pomocą RTCPeerConnection
Czego się nauczysz
Z tego kroku dowiesz się, jak:
- Zniweluj różnice między przeglądarkami za pomocą podkładki WebRTC adapter.js.
- użyć interfejsu RTCPeerConnection API do strumieniowego przesyłania wideo,
- Sterowanie przechwytywaniem i strumieniowym przesyłaniem multimediów.
Pełna wersja tego kroku znajduje się w folderze step-2.
Czym jest RTCPeerConnection?
RTCPeerConnection to interfejs API do nawiązywania połączeń WebRTC w celu strumieniowego przesyłania obrazu i dźwięku oraz wymiany danych.
Ten przykład pokazuje, jak skonfigurować połączenie między 2 obiektami RTCPeerConnection (nazywanymi połączeniami równorzędnymi) na tej samej stronie.
Nie ma to większego zastosowania praktycznego, ale pomaga zrozumieć, jak działa RTCPeerConnection.
Dodawanie elementów wideo i przycisków sterujących
W pliku index.html zastąp pojedynczy element wideo 2 elementami wideo i 3 przyciskami:
<video id="localVideo" autoplay playsinline></video>
<video id="remoteVideo" autoplay playsinline></video>
<div>
<button id="startButton">Start</button>
<button id="callButton">Call</button>
<button id="hangupButton">Hang Up</button>
</div>
Jeden element wideo będzie wyświetlać strumień z getUserMedia(), a drugi – ten sam film przesyłany strumieniowo za pomocą RTCPeerconnection. (W praktycznym zastosowaniu jeden element wideo wyświetlałby strumień lokalny, a drugi – zdalny).
Dodawanie podkładki adapter.js
Dodaj link do bieżącej wersji pliku adapter.js nad linkiem do pliku main.js:
<script src="https://webrtc.github.io/adapter/adapter-latest.js"></script>
Plik Index.html powinien teraz wyglądać tak:
<!DOCTYPE html>
<html>
<head>
<title>Realtime communication with WebRTC</title>
<link rel="stylesheet" href="css/main.css">
</head>
<body>
<h1>Realtime communication with WebRTC</h1>
<video id="localVideo" autoplay playsinline></video>
<video id="remoteVideo" autoplay playsinline></video>
<div>
<button id="startButton">Start</button>
<button id="callButton">Call</button>
<button id="hangupButton">Hang Up</button>
</div>
<script src="https://webrtc.github.io/adapter/adapter-latest.js"></script>
<script src="js/main.js"></script>
</body>
</html>
Instalowanie kodu RTCPeerConnection
Zastąp plik main.js wersją z folderu step-02.
Zadzwoń
Otwórz plik index.html, kliknij przycisk Start, aby uzyskać obraz z kamery internetowej, i kliknij Call (Połącz), aby nawiązać połączenie peer-to-peer. W obu elementach wideo powinien być widoczny ten sam obraz (z kamery internetowej). Aby wyświetlić dzienniki WebRTC, otwórz konsolę przeglądarki.
Jak to działa
Ten krok obejmuje wiele czynności…
WebRTC używa interfejsu RTCPeerConnection API do konfigurowania połączenia na potrzeby strumieniowego przesyłania obrazu między klientami WebRTC, czyli równorzędnymi uczestnikami.
W tym przykładzie 2 obiekty RTCPeerConnection znajdują się na tej samej stronie: pc1 i pc2. Nie ma on dużego zastosowania praktycznego, ale dobrze pokazuje, jak działają interfejsy API.
Konfigurowanie połączenia między urządzeniami WebRTC obejmuje 3 zadania:
- Utwórz RTCPeerConnection dla każdego końca połączenia i na każdym końcu dodaj strumień lokalny z
getUserMedia(). - pobieranie i udostępnianie informacji o sieci – potencjalne punkty końcowe połączenia są nazywane kandydatami ICE;
- pobieranie i udostępnianie opisów lokalnych i zdalnych: metadane dotyczące multimediów lokalnych w formacie SDP;
Wyobraź sobie, że Alicja i Bob chcą użyć RTCPeerConnection do skonfigurowania czatu wideo.
Najpierw Alicja i Robert wymieniają się informacjami o sieci. Wyrażenie „znajdowanie kandydatów” odnosi się do procesu znajdowania interfejsów sieciowych i portów za pomocą platformy ICE.
- Alicja tworzy obiekt RTCPeerConnection z modułem obsługi
onicecandidate (addEventListener('icecandidate')). Odpowiada to temu kodowi z pliku main.js:
let localPeerConnection;
localPeerConnection = new RTCPeerConnection(servers);
localPeerConnection.addEventListener('icecandidate', handleConnection);
localPeerConnection.addEventListener(
'iceconnectionstatechange', handleConnectionChange);
- Alicja wywołuje
getUserMedia()i dodaje przekazany do niego strumień:
navigator.mediaDevices.getUserMedia(mediaStreamConstraints).
then(gotLocalMediaStream).
catch(handleLocalMediaStreamError);
function gotLocalMediaStream(mediaStream) {
localVideo.srcObject = mediaStream;
localStream = mediaStream;
trace('Received local stream.');
callButton.disabled = false; // Enable call button.
}
localPeerConnection.addStream(localStream);
trace('Added local stream to localPeerConnection.');
- Gdy dostępne są kandydaty sieci, wywoływany jest moduł obsługi
onicecandidatez kroku 1. - Alicja wysyła do Roberta zserializowane dane kandydata. W prawdziwej aplikacji ten proces (znany jako sygnalizacja) odbywa się za pomocą usługi przesyłania wiadomości – dowiesz się, jak to zrobić, w późniejszym kroku. Oczywiście na tym etapie oba obiekty RTCPeerConnection znajdują się na tej samej stronie i mogą komunikować się bezpośrednio, bez konieczności korzystania z zewnętrznych wiadomości.
- Gdy Bob otrzyma od Alicji wiadomość z kandydatem, wywołuje funkcję
addIceCandidate(), aby dodać kandydata do opisu zdalnego peera:
function handleConnection(event) {
const peerConnection = event.target;
const iceCandidate = event.candidate;
if (iceCandidate) {
const newIceCandidate = new RTCIceCandidate(iceCandidate);
const otherPeer = getOtherPeer(peerConnection);
otherPeer.addIceCandidate(newIceCandidate)
.then(() => {
handleConnectionSuccess(peerConnection);
}).catch((error) => {
handleConnectionFailure(peerConnection, error);
});
trace(`${getPeerName(peerConnection)} ICE candidate:\n` +
`${event.candidate.candidate}.`);
}
}
Uczestnicy WebRTC muszą też znaleźć i wymienić lokalne i zdalne informacje o multimediach audio i wideo, takie jak rozdzielczość i możliwości kodeków. Sygnalizacja w celu wymiany informacji o konfiguracji multimediów odbywa się przez wymianę obiektów blob metadanych, znanych jako oferta i odpowiedź, przy użyciu formatu Session Description Protocol, znanego jako SDP:
- Alicja uruchamia metodę RTCPeerConnection
createOffer(). Zwrócona obietnica zawiera RTCSessionDescription: opis sesji lokalnej Alicji:
trace('localPeerConnection createOffer start.');
localPeerConnection.createOffer(offerOptions)
.then(createdOffer).catch(setSessionDescriptionError);
- Jeśli się powiedzie, Alicja ustawia opis lokalny za pomocą
setLocalDescription(), a następnie wysyła ten opis sesji do Boba za pomocą kanału sygnalizacyjnego. - Robert ustawia opis wysłany przez Alicję jako opis zdalny za pomocą
setRemoteDescription(). - Robert uruchamia metodę RTCPeerConnection
createAnswer(), przekazując jej opis zdalny, który otrzymał od Alicji, aby można było wygenerować sesję lokalną zgodną z jej sesją. Obiekt PromisecreateAnswer()przekazuje obiekt RTCSessionDescription: Bob ustawia go jako opis lokalny i wysyła do Alicji. - Gdy Alicja otrzyma opis sesji Roberta, ustawia go jako opis zdalny za pomocą
setRemoteDescription().
// Logs offer creation and sets peer connection session descriptions.
function createdOffer(description) {
trace(`Offer from localPeerConnection:\n${description.sdp}`);
trace('localPeerConnection setLocalDescription start.');
localPeerConnection.setLocalDescription(description)
.then(() => {
setLocalDescriptionSuccess(localPeerConnection);
}).catch(setSessionDescriptionError);
trace('remotePeerConnection setRemoteDescription start.');
remotePeerConnection.setRemoteDescription(description)
.then(() => {
setRemoteDescriptionSuccess(remotePeerConnection);
}).catch(setSessionDescriptionError);
trace('remotePeerConnection createAnswer start.');
remotePeerConnection.createAnswer()
.then(createdAnswer)
.catch(setSessionDescriptionError);
}
// Logs answer to offer creation and sets peer connection session descriptions.
function createdAnswer(description) {
trace(`Answer from remotePeerConnection:\n${description.sdp}.`);
trace('remotePeerConnection setLocalDescription start.');
remotePeerConnection.setLocalDescription(description)
.then(() => {
setLocalDescriptionSuccess(remotePeerConnection);
}).catch(setSessionDescriptionError);
trace('localPeerConnection setRemoteDescription start.');
localPeerConnection.setRemoteDescription(description)
.then(() => {
setRemoteDescriptionSuccess(localPeerConnection);
}).catch(setSessionDescriptionError);
}
- Ping!
Punkty bonusowe
- Otwórz stronę chrome://webrtc-internals. Znajdziesz tam statystyki WebRTC i dane debugowania. (Pełną listę adresów URL Chrome znajdziesz na stronie chrome://about).
- Dodaj styl do strony za pomocą CSS:
- Umieść filmy obok siebie.
- Ustaw taką samą szerokość przycisków i większy tekst.
- Upewnij się, że układ działa na urządzeniach mobilnych.
- W konsoli Narzędzi deweloperskich w Chrome sprawdź
localStream,localPeerConnectioniremotePeerConnection. - W konsoli sprawdź
localPeerConnectionpc1.localDescription. Jak wygląda format SDP?
Czego się nauczysz
W tym kroku dowiedzieliśmy się, jak:
- Zniweluj różnice między przeglądarkami za pomocą podkładki WebRTC adapter.js.
- użyć interfejsu RTCPeerConnection API do strumieniowego przesyłania wideo,
- Sterowanie przechwytywaniem i strumieniowym przesyłaniem multimediów.
- Udostępnianie informacji o multimediach i sieci między urządzeniami równorzędnymi w celu umożliwienia połączenia WebRTC.
Pełna wersja tego kroku znajduje się w folderze step-2.
Wskazówki
- Na tym etapie jest wiele do nauczenia. Więcej informacji o RTCPeerConnection znajdziesz na stronie webrtc.org. Ta strona zawiera sugestie dotyczące platform JavaScript, jeśli chcesz używać WebRTC, ale nie chcesz zajmować się interfejsami API.
- Więcej informacji o podkładce adapter.js znajdziesz w repozytorium adapter.js na GitHubie.
- Chcesz zobaczyć, jak wygląda najlepsza na świecie aplikacja do czatu wideo? Zapoznaj się z AppRTC, kanoniczną aplikacją projektu WebRTC do połączeń WebRTC: aplikacja, kod. Czas nawiązywania połączenia jest krótszy niż 500 ms.
Sprawdzona metoda
- Aby przygotować kod na przyszłość, używaj nowych interfejsów API opartych na obietnicach i zapewnij zgodność z przeglądarkami, które ich nie obsługują, za pomocą adapter.js.
Dalsze czynności
W tym kroku pokazujemy, jak używać WebRTC do strumieniowego przesyłania wideo między urządzeniami, ale to ćwiczenie dotyczy też danych.
W następnym kroku dowiesz się, jak przesyłać dowolne dane za pomocą RTCDataChannel.
6. Używanie RTCDataChannel do wymiany danych
Czego się nauczysz
- Jak wymieniać dane między punktami końcowymi WebRTC (równorzędnymi).
Pełną wersję tego kroku znajdziesz w folderze step-03.
Aktualizowanie kodu HTML
W tym kroku użyjesz kanałów danych WebRTC do przesyłania tekstu między 2 elementami textarea na tej samej stronie. Nie jest to zbyt przydatne, ale pokazuje, jak można używać WebRTC do udostępniania danych i strumieniowego przesyłania filmów.
Usuń elementy wideo i przycisku z pliku index.html i zastąp je tym kodem HTML:
<textarea id="dataChannelSend" disabled
placeholder="Press Start, enter some text, then press Send."></textarea>
<textarea id="dataChannelReceive" disabled></textarea>
<div id="buttons">
<button id="startButton">Start</button>
<button id="sendButton">Send</button>
<button id="closeButton">Stop</button>
</div>
Jedno pole tekstowe będzie służyć do wpisywania tekstu, a drugie będzie wyświetlać tekst przesyłany strumieniowo między uczestnikami.
Plik index.html powinien teraz wyglądać tak:
<!DOCTYPE html>
<html>
<head>
<title>Realtime communication with WebRTC</title>
<link rel="stylesheet" href="css/main.css">
</head>
<body>
<h1>Realtime communication with WebRTC</h1>
<textarea id="dataChannelSend" disabled
placeholder="Press Start, enter some text, then press Send."></textarea>
<textarea id="dataChannelReceive" disabled></textarea>
<div id="buttons">
<button id="startButton">Start</button>
<button id="sendButton">Send</button>
<button id="closeButton">Stop</button>
</div>
<script src="https://webrtc.github.io/adapter/adapter-latest.js"></script>
<script src="js/main.js"></script>
</body>
</html>
Aktualizowanie kodu JavaScript
Zastąp zawartość pliku main.js zawartością pliku step-03/js/main.js.
Wypróbuj przesyłanie strumieniowe danych między węzłami sieci: otwórz index.html, naciśnij Start, aby skonfigurować połączenie równorzędne, wpisz tekst w polu textarea po lewej stronie, a następnie kliknij Wyślij, aby przesłać tekst za pomocą kanałów danych WebRTC.
Jak to działa
Ten kod używa interfejsów RTCPeerConnection i RTCDataChannel, aby umożliwić wymianę SMS-ów.
Większość kodu w tym kroku jest taka sama jak w przykładzie RTCPeerConnection.
Funkcje sendData() i createConnection() zawierają większość nowego kodu:
function createConnection() {
dataChannelSend.placeholder = '';
var servers = null;
pcConstraint = null;
dataConstraint = null;
trace('Using SCTP based data channels');
// For SCTP, reliable and ordered delivery is true by default.
// Add localConnection to global scope to make it visible
// from the browser console.
window.localConnection = localConnection =
new RTCPeerConnection(servers, pcConstraint);
trace('Created local peer connection object localConnection');
sendChannel = localConnection.createDataChannel('sendDataChannel',
dataConstraint);
trace('Created send data channel');
localConnection.onicecandidate = iceCallback1;
sendChannel.onopen = onSendChannelStateChange;
sendChannel.onclose = onSendChannelStateChange;
// Add remoteConnection to global scope to make it visible
// from the browser console.
window.remoteConnection = remoteConnection =
new RTCPeerConnection(servers, pcConstraint);
trace('Created remote peer connection object remoteConnection');
remoteConnection.onicecandidate = iceCallback2;
remoteConnection.ondatachannel = receiveChannelCallback;
localConnection.createOffer().then(
gotDescription1,
onCreateSessionDescriptionError
);
startButton.disabled = true;
closeButton.disabled = false;
}
function sendData() {
var data = dataChannelSend.value;
sendChannel.send(data);
trace('Sent Data: ' + data);
}
Składnia RTCDataChannel jest celowo podobna do WebSocket, z metodą send() i zdarzeniem message.
Zwróć uwagę na użycie dataConstraint. Kanały danych można skonfigurować tak, aby umożliwiały różne typy udostępniania danych – na przykład priorytetowe traktowanie niezawodnego dostarczania nad wydajnością. Więcej informacji o opcjach znajdziesz na stronie Mozilla Developer Network.
Punkty bonusowe
- W przypadku SCTP, protokołu używanego przez kanały danych WebRTC, niezawodne i uporządkowane dostarczanie danych jest domyślnie włączone. Kiedy RTCDataChannel może wymagać niezawodnego dostarczania danych, a kiedy ważniejsza może być wydajność, nawet jeśli oznacza to utratę niektórych danych?
- Użyj CSS, aby poprawić układ strony, i dodaj atrybut obiektu zastępczego do obszaru tekstowego „dataChannelReceive”.
- Przetestuj stronę na urządzeniu mobilnym.
Czego się nauczysz
W tym kroku dowiedzieliśmy się, jak:
- Nawiąż połączenie między 2 urządzeniami równorzędnymi WebRTC.
- wymieniać dane tekstowe między aplikacjami z grupy porównawczej;
Pełną wersję tego kroku znajdziesz w folderze step-03.
Więcej informacji
- Kanały danych WebRTC (artykuł sprzed kilku lat, ale nadal warto go przeczytać)
- Why was SCTP Selected for WebRTC's Data Channel?
Dalsze czynności
Wiesz już, jak wymieniać dane między węzłami na tej samej stronie, ale jak to zrobić między różnymi komputerami? Najpierw musisz skonfigurować kanał sygnalizacyjny do wymiany wiadomości z metadanymi. Dowiedz się, jak to zrobić, w następnym kroku.
7. Konfigurowanie usługi sygnalizacyjnej do wymiany wiadomości
Czego się nauczysz
W tym kroku dowiesz się, jak:
- Użyj
npm, aby zainstalować zależności projektu określone w pliku package.json. - uruchomić serwer Node.js i użyć node-static do obsługi plików statycznych;
- skonfigurować usługę przesyłania wiadomości w Node.js przy użyciu Socket.IO;
- Używaj go do tworzenia „pokoi” i wymiany wiadomości.
Pełną wersję tego kroku znajdziesz w folderze step-04.
Pojęcia
Aby skonfigurować i utrzymać połączenie WebRTC, klienci WebRTC (równorzędni) muszą wymieniać metadane:
- Informacje o kandydacie (sieci).
- Wiadomości z ofertą i odpowiedzią, które zawierają informacje o multimediach, takie jak rozdzielczość i kodeki.
Innymi słowy, zanim będzie można przesyłać strumieniowo dźwięk, obraz lub dane w trybie peer-to-peer, konieczna jest wymiana metadanych. Ten proces nazywa się sygnalizacją.
W poprzednich krokach obiekty RTCPeerConnection nadawcy i odbiorcy znajdują się na tej samej stronie, więc „sygnalizacja” polega na przekazywaniu metadanych między obiektami.
W rzeczywistej aplikacji nadawca i odbiorca RTCPeerConnection działają na stronach internetowych na różnych urządzeniach i potrzebują sposobu na przekazywanie metadanych.
W tym celu używasz serwera sygnalizacyjnego, czyli serwera, który może przekazywać wiadomości między klientami WebRTC (równorzędnymi). Rzeczywiste wiadomości to zwykły tekst: obiekty w JavaScripcie w postaci ciągów znaków.
Wymaganie wstępne: zainstaluj Node.js
Aby wykonać kolejne kroki tego ćwiczenia (foldery od step-04 do step-06), musisz uruchomić serwer na hoście lokalnym za pomocą Node.js.
Możesz pobrać i zainstalować Node.js bezpośrednio ze strony Node.js lub za pomocą preferowanego menedżera pakietów.
Po zainstalowaniu możesz zaimportować zależności wymagane w następnych krokach (uruchamiając npm install) oraz uruchomić mały serwer localhost, aby wykonać ćwiczenie z programowania (uruchamiając node index.js). Te polecenia zostaną wskazane później, gdy będą wymagane.
Informacje o aplikacji
WebRTC używa interfejsu API JavaScriptu po stronie klienta, ale w praktyce wymaga też serwera sygnalizacyjnego (do obsługi wiadomości) oraz serwerów STUN i TURN. Więcej informacji o infrastrukturze WebRTC
W tym kroku utworzysz prosty serwer sygnalizacyjny Node.js, używając modułu Socket.IO Node.js i biblioteki JavaScript do obsługi wiadomości. Znajomość Node.js i Socket.IO będzie przydatna, ale nie jest niezbędna, ponieważ komponenty do obsługi wiadomości są proste.
W tym przykładzie serwer (aplikacja Node.js) jest zaimplementowany w pliku index.js, a klient, który na nim działa (aplikacja internetowa), jest zaimplementowany w pliku index.html.
Aplikacja Node.js w tym kroku ma 2 zadania.
Po pierwsze, działa jako przekaźnik wiadomości:
socket.on('message', function (message) {
log('Got message: ', message);
socket.broadcast.emit('message', message);
});
Po drugie, zarządza „pokojami” czatu wideo WebRTC:
if (numClients === 0) {
socket.join(room);
socket.emit('created', room, socket.id);
} else if (numClients === 1) {
socket.join(room);
socket.emit('joined', room, socket.id);
io.sockets.in(room).emit('ready');
} else { // max two clients
socket.emit('full', room);
}
Nasza aplikacja WebRTC pozwoli na udostępnianie pokoju maksymalnie 2 użytkownikom.
HTML i JavaScript
Zaktualizuj plik index.html, aby wyglądał tak:
<!DOCTYPE html>
<html>
<head>
<title>Realtime communication with WebRTC</title>
<link rel="stylesheet" href="css/main.css">
</head>
<body>
<h1>Realtime communication with WebRTC</h1>
<script src="/socket.io/socket.io.js"></script>
<script src="js/main.js"></script>
</body>
</html>
Na stronie nie zobaczysz niczego na tym etapie: wszystkie dane są zapisywane w konsoli przeglądarki. (Aby wyświetlić konsolę w Chrome, naciśnij Ctrl-Shift-J lub Command-Option-J na Macu).
Zastąp zawartość pliku js/main.js tym kodem:
'use strict';
var isInitiator;
window.room = prompt("Enter room name:");
var socket = io.connect();
if (room !== "") {
console.log('Message from client: Asking to join room ' + room);
socket.emit('create or join', room);
}
socket.on('created', function(room, clientId) {
isInitiator = true;
});
socket.on('full', function(room) {
console.log('Message from client: Room ' + room + ' is full :^(');
});
socket.on('ipaddr', function(ipaddr) {
console.log('Message from client: Server IP address is ' + ipaddr);
});
socket.on('joined', function(room, clientId) {
isInitiator = false;
});
socket.on('log', function(array) {
console.log.apply(console, array);
});
Konfigurowanie Socket.IO do działania w Node.js
W pliku HTML możesz zauważyć, że używasz pliku Socket.IO:
<script src="/socket.io/socket.io.js"></script>
Na najwyższym poziomie katalogu work utwórz plik o nazwie package.json z tą zawartością:
{
"name": "webrtc-codelab",
"version": "0.0.1",
"description": "WebRTC codelab",
"dependencies": {
"node-static": "^0.7.10",
"socket.io": "^1.2.0"
}
}
Jest to manifest aplikacji, który informuje menedżera pakietów Node (npm), jakie zależności projektu należy zainstalować.
Aby zainstalować zależności (takie jak /socket.io/socket.io.js), uruchom w terminalu wiersza poleceń w katalogu work to polecenie:
npm install
Powinien pojawić się dziennik instalacji, który kończy się mniej więcej tak:

Jak widać, npm zainstalował zależności zdefiniowane w pliku package.json.
Utwórz nowy plik index.js na najwyższym poziomie katalogu work (nie w katalogu js) i dodaj ten kod:
'use strict';
var os = require('os');
var nodeStatic = require('node-static');
var http = require('http');
var socketIO = require('socket.io');
var fileServer = new(nodeStatic.Server)();
var app = http.createServer(function(req, res) {
fileServer.serve(req, res);
}).listen(8080);
var io = socketIO.listen(app);
io.sockets.on('connection', function(socket) {
// convenience function to log server messages on the client
function log() {
var array = ['Message from server:'];
array.push.apply(array, arguments);
socket.emit('log', array);
}
socket.on('message', function(message) {
log('Client said: ', message);
// for a real app, would be room-only (not broadcast)
socket.broadcast.emit('message', message);
});
socket.on('create or join', function(room) {
log('Received request to create or join room ' + room);
var clientsInRoom = io.sockets.adapter.rooms[room];
var numClients = clientsInRoom ? Object.keys(clientsInRoom.sockets).length : 0;
log('Room ' + room + ' now has ' + numClients + ' client(s)');
if (numClients === 0) {
socket.join(room);
log('Client ID ' + socket.id + ' created room ' + room);
socket.emit('created', room, socket.id);
} else if (numClients === 1) {
log('Client ID ' + socket.id + ' joined room ' + room);
io.sockets.in(room).emit('join', room);
socket.join(room);
socket.emit('joined', room, socket.id);
io.sockets.in(room).emit('ready');
} else { // max two clients
socket.emit('full', room);
}
});
socket.on('ipaddr', function() {
var ifaces = os.networkInterfaces();
for (var dev in ifaces) {
ifaces[dev].forEach(function(details) {
if (details.family === 'IPv4' && details.address !== '127.0.0.1') {
socket.emit('ipaddr', details.address);
}
});
}
});
});
W terminalu wiersza poleceń uruchom to polecenie w katalogu work:
node index.js
W przeglądarce otwórz localhost:8080.
Za każdym razem, gdy otworzysz ten adres URL, pojawi się prośba o wpisanie nazwy pokoju. Aby dołączyć do tego samego pokoju, za każdym razem wybierz tę samą nazwę pokoju, np. „foo”.
Otwórz stronę nowej karty i ponownie otwórz localhost:8080. Wybierz tę samą nazwę pokoju.
Otwórz localhost:8080 w trzeciej karcie lub trzecim oknie. Ponownie wybierz tę samą nazwę pomieszczenia.
Sprawdź konsolę na każdej z kart: powinny być widoczne logi z poprzedniego kodu JavaScript.
Punkty bonusowe
- Jakie alternatywne mechanizmy przesyłania wiadomości mogą być możliwe? Jakie problemy mogą wystąpić podczas korzystania z „czystego” protokołu WebSocket?
- Jakie problemy mogą wystąpić podczas skalowania tej aplikacji? Czy możesz opracować metodę testowania tysięcy lub milionów jednoczesnych żądań dotyczących pokoi?
- Ta aplikacja używa prompta JavaScript, aby uzyskać nazwę pokoju. Znajdź sposób na pobranie nazwy pokoju z adresu URL. Na przykład localhost:8080/foo da nazwę pokoju
foo.
Czego się nauczysz
W tym kroku dowiedzieliśmy się, jak:
- Użyj npm, aby zainstalować zależności projektu określone w pliku package.json.
- uruchomić serwer Node.js, aby udostępniać pliki statyczne;
- skonfigurować usługę przesyłania wiadomości w Node.js przy użyciu socket.io,
- Możesz go używać do tworzenia „pokoi” i wymiany wiadomości.
Pełną wersję tego kroku znajdziesz w folderze step-04.
Więcej informacji
- Repozytorium Socket.io chat-example
- WebRTC in the real world: STUN, TURN and signaling
- Termin „sygnalizacja” w WebRTC
Dalsze czynności
Dowiedz się, jak używać sygnalizacji, aby umożliwić 2 użytkownikom nawiązanie połączenia peer-to-peer.
8. Łączenie połączenia równorzędnego i sygnalizacji
Czego się nauczysz
Z tego kroku dowiesz się, jak:
- uruchomić usługę sygnalizacyjną WebRTC przy użyciu Socket.IO w Node.js,
- Użyj tej usługi do wymiany metadanych WebRTC między urządzeniami.
Pełną wersję tego kroku znajdziesz w folderze step-05.
Zastępowanie kodu HTML i JavaScript
Zastąp zawartość pliku index.html tym kodem:
<!DOCTYPE html>
<html>
<head>
<title>Realtime communication with WebRTC</title>
<link rel="stylesheet" href="/css/main.css">
</head>
<body>
<h1>Realtime communication with WebRTC</h1>
<div id="videos">
<video id="localVideo" autoplay muted></video>
<video id="remoteVideo" autoplay></video>
</div>
<script src="/socket.io/socket.io.js"></script>
<script src="https://webrtc.github.io/adapter/adapter-latest.js"></script>
<script src="js/main.js"></script>
</body>
</html>
Zastąp zawartość pliku js/main.js zawartością pliku step-05/js/main.js.
Uruchamianie serwera Node.js
Jeśli nie wykonujesz tego ćwiczenia z katalogu work, może być konieczne zainstalowanie zależności dla folderu step-05 lub bieżącego folderu roboczego. Uruchom to polecenie z katalogu roboczego:
npm install
Jeśli po zainstalowaniu serwer Node.js nie działa, uruchom go, wywołując to polecenie w katalogu work:
node index.js
Upewnij się, że używasz wersji index.js z poprzedniego kroku, która implementuje Socket.IO. Więcej informacji o Node i Socket IO znajdziesz w sekcji „Konfigurowanie usługi sygnalizacyjnej do wymiany wiadomości”.
W przeglądarce otwórz localhost:8080.
Otwórz ponownie localhost:8080 w nowej karcie lub nowym oknie. Jeden element wideo będzie wyświetlać strumień lokalny z witryny getUserMedia(), a drugi – „zdalny” strumień wideo przesyłany za pomocą RTCPeerconnection.
Wyświetlanie logowania w konsoli przeglądarki.
Punkty bonusowe
- Ta aplikacja obsługuje tylko czat wideo 1:1. Jak można zmienić projekt, aby umożliwić więcej niż jednej osobie korzystanie z tego samego pokoju czatu wideo?
- W przykładzie nazwa pokoju foo jest zakodowana na stałe. Jak najlepiej włączyć inne nazwy sal?
- Jak użytkownicy mogą udostępniać nazwę pokoju? Spróbuj utworzyć alternatywę dla udostępniania nazw sal.
- Jak można zmienić aplikację
- Zrób zdjęcie i pobierz z niego dane za pomocą elementu canvas.
- Wymiana danych obrazu ze zdalnym użytkownikiem.
Pełną wersję tego kroku znajdziesz w folderze step-06.
Jak to działa
Wcześniej pokazaliśmy Ci, jak wymieniać wiadomości tekstowe za pomocą RTCDataChannel.
Ten krok umożliwia udostępnianie całych plików – w tym przykładzie zdjęć zrobionych za pomocą aplikacji getUserMedia().
Główne elementy tego kroku to:
- Ustanów kanał danych. Pamiętaj, że w tym kroku nie dodajesz do połączenia równorzędnego żadnych strumieni multimediów.
- Przechwytywanie strumienia wideo z kamery internetowej użytkownika za pomocą
getUserMedia():
var video = document.getElementById('video');
function grabWebCamVideo() {
console.log('Getting user media (video) ...');
navigator.mediaDevices.getUserMedia({
video: true
})
.then(gotStream)
.catch(function(e) {
alert('getUserMedia() error: ' + e.name);
});
}
- Gdy użytkownik kliknie przycisk Zrób zdjęcie, pobierz zdjęcie (klatkę wideo) ze strumienia wideo i wyświetl je w elemencie
canvas:
var photo = document.getElementById('photo');
var photoContext = photo.getContext('2d');
function snapPhoto() {
photoContext.drawImage(video, 0, 0, photo.width, photo.height);
show(photo, sendBtn);
}
- Gdy użytkownik kliknie przycisk Wyślij, przekonwertuj obraz na bajty i wyślij je za pomocą kanału danych:
function sendPhoto() {
// Split data channel message in chunks of this byte length.
var CHUNK_LEN = 64000;
var img = photoContext.getImageData(0, 0, photoContextW, photoContextH),
len = img.data.byteLength,
n = len / CHUNK_LEN | 0;
console.log('Sending a total of ' + len + ' byte(s)');
dataChannel.send(len);
// split the photo and send in chunks of about 64KB
for (var i = 0; i < n; i++) {
var start = i * CHUNK_LEN,
end = (i + 1) * CHUNK_LEN;
console.log(start + ' - ' + (end - 1));
dataChannel.send(img.data.subarray(start, end));
}
// send the reminder, if any
if (len % CHUNK_LEN) {
console.log('last ' + len % CHUNK_LEN + ' byte(s)');
dataChannel.send(img.data.subarray(n * CHUNK_LEN));
}
}
- Strona odbierająca konwertuje bajty wiadomości kanału danych z powrotem na obraz i wyświetla go użytkownikowi:
function receiveDataChromeFactory() {
var buf, count;
return function onmessage(event) {
if (typeof event.data === 'string') {
buf = window.buf = new Uint8ClampedArray(parseInt(event.data));
count = 0;
console.log('Expecting a total of ' + buf.byteLength + ' bytes');
return;
}
var data = new Uint8ClampedArray(event.data);
buf.set(data, count);
count += data.byteLength;
console.log('count: ' + count);
if (count === buf.byteLength) {
// we're done: all data chunks have been received
console.log('Done. Rendering photo.');
renderPhoto(buf);
}
};
}
function renderPhoto(data) {
var canvas = document.createElement('canvas');
canvas.width = photoContextW;
canvas.height = photoContextH;
canvas.classList.add('incomingPhoto');
// trail is the element holding the incoming images
trail.insertBefore(canvas, trail.firstChild);
var context = canvas.getContext('2d');
var img = context.createImageData(photoContextW, photoContextH);
img.data.set(data);
context.putImageData(img, 0, 0);
}
Pobierz kod
Zastąp zawartość folderu work zawartością folderu step-06. Plik index.html w folderze work powinien teraz wyglądać tak**:**
<!DOCTYPE html>
<html>
<head>
<title>Realtime communication with WebRTC</title>
<link rel="stylesheet" href="/css/main.css">
</head>
<body>
<h1>Realtime communication with WebRTC</h1>
<h2>
<span>Room URL: </span><span id="url">...</span>
</h2>
<div id="videoCanvas">
<video id="camera" autoplay></video>
<canvas id="photo"></canvas>
<script src="js/main.js"></script>
</body>
</html>
Jeśli nie wykonujesz tego ćwiczenia z katalogu work, może być konieczne zainstalowanie zależności dla folderu step-06 lub bieżącego folderu roboczego. Wystarczy, że uruchomisz to polecenie w katalogu roboczym:
npm install
Jeśli po zainstalowaniu serwer Node.js nie działa, uruchom go, wywołując to polecenie z katalogu work:
node index.js
Upewnij się, że używasz wersji pliku index.js, która implementuje Socket.IO, i pamiętaj o ponownym uruchomieniu serwera Node.js, jeśli wprowadzisz zmiany. Więcej informacji o Node i Socket IO znajdziesz w sekcji „Konfigurowanie usługi sygnalizacyjnej do wymiany wiadomości”.
W razie potrzeby kliknij przycisk Zezwól, aby zezwolić aplikacji na korzystanie z kamery internetowej.
Aplikacja utworzy losowy identyfikator pokoju i doda go do adresu URL. Otwórz adres URL z paska adresu w nowej karcie lub nowym oknie przeglądarki.
Kliknij przycisk Snap & Send (Zrób zdjęcie i wyślij), a następnie spójrz na obszar Incoming (Przychodzące) na drugiej karcie u dołu strony. Aplikacja przenosi zdjęcia między kartami.
Powinien pojawić się ekran podobny do tego:

Punkty bonusowe
- Jak możesz zmienić kod, aby umożliwić udostępnianie dowolnego typu pliku?
Więcej informacji
- MediaStream Image Capture API: interfejs API do robienia zdjęć i sterowania aparatami – już wkrótce w Twojej przeglądarce.
- Interfejs MediaRecorder API do nagrywania dźwięku i obrazu: wersja demonstracyjna, dokumentacja.
Czego się nauczysz
- Jak zrobić zdjęcie i pobrać z niego dane za pomocą elementu canvas.
- Jak wymieniać te dane ze zdalnym użytkownikiem.
Pełną wersję tego kroku znajdziesz w folderze step-06.
9. Gratulacje
Udało Ci się utworzyć aplikację do strumieniowego przesyłania wideo i wymiany danych w czasie rzeczywistym.
Czego się nauczysz
Z tego ćwiczenia wiesz już, jak:
- pobierać obraz z kamery internetowej,
- Przesyłanie strumieniowe wideo za pomocą RTCPeerConnection.
- Przesyłanie strumieniowe danych za pomocą RTCDataChannel.
- Skonfiguruj usługę sygnalizacyjną do wymiany wiadomości.
- Połączenie równorzędne i sygnalizacja.
- zrobić zdjęcie i udostępnić je przez kanał danych.
Dalsze kroki
- Zapoznaj się z kodem i architekturą kanonicznej aplikacji do czatu WebRTC AppRTC: aplikacja, kod.
- Wypróbuj wersje demonstracyjne na stronie github.com/webrtc/samples.
Więcej informacji
- Na stronie webrtc.org znajdziesz wiele materiałów, które pomogą Ci rozpocząć korzystanie z WebRTC.