תקשורת בזמן אמת עם WebRTC

1. מבוא

‫WebRTC הוא פרויקט קוד פתוח שמאפשר תקשורת בזמן אמת של אודיו, וידאו ונתונים באפליקציות אינטרנט ובאפליקציות נייטיב.

ל-WebRTC יש כמה ממשקי API של JavaScript – לחצו על הקישורים כדי לראות הדגמות.

איפה אפשר להשתמש ב-WebRTC?

ב-Firefox, ב-Opera וב-Chrome במחשב וב-Android. ‫WebRTC זמין גם לאפליקציות נייטיב ב-iOS וב-Android.

מה זה איתות?

‫WebRTC משתמש ב-RTCPeerConnection כדי להעביר נתונים בסטרימינג בין דפדפנים, אבל הוא צריך גם מנגנון לתיאום התקשורת ולשליחת הודעות בקרה, תהליך שנקרא איתות. שיטות ופרוטוקולים של איתות לא מצוינים ב-WebRTC. ב-Codelab הזה תשתמשו ב-Socket.IO להעברת הודעות, אבל יש הרבה חלופות.

מהם STUN ו-TURN?

‫WebRTC נועד לפעול בשיטת קצה-לקצה (P2P), כך שהמשתמשים יכולים להתחבר בדרך הכי ישירה שאפשר. עם זאת, WebRTC נועד להתמודד עם רשתות בעולם האמיתי: אפליקציות לקוח צריכות לעבור דרך שערי NAT וחומות אש, ורשתות מסוג P2P צריכות גיבויים למקרה שהחיבור הישיר נכשל. כחלק מהתהליך הזה, ממשקי ה-API של WebRTC משתמשים בשרתי STUN כדי לקבל את כתובת ה-IP של המחשב שלכם, ובשרתי TURN כדי לתפקד כשרתי ממסר במקרה שתקשורת בין עמיתים נכשלת. (הסבר מפורט יותר זמין במאמר WebRTC in the real world).

האם WebRTC מאובטח?

ההצפנה היא חובה לכל רכיבי WebRTC, ואפשר להשתמש בממשקי ה-API של JavaScript רק ממקורות מאובטחים (HTTPS או localhost). מנגנוני האיתות לא מוגדרים בתקני WebRTC, ולכן אתם צריכים לוודא שאתם משתמשים בפרוטוקולים מאובטחים.

2. סקירה כללית

בניית אפליקציה לקבלת וידאו וצילום תמונות באמצעות מצלמת האינטרנט ושיתוף שלהן בין משתמשים באמצעות WebRTC. במהלך השיעור תלמדו איך להשתמש בממשקי ה-API העיקריים של WebRTC ולהגדיר שרת להעברת הודעות באמצעות Node.js.

מה תלמדו

  • איך מקבלים וידאו ממצלמת האינטרנט
  • סטרימינג של וידאו באמצעות RTCPeerConnection
  • העברת נתונים בסטרימינג באמצעות RTCDataChannel
  • הגדרת שירות איתות להחלפת הודעות
  • שילוב של חיבור בין עמיתים ואיתות
  • איך לצלם תמונה ולשתף אותה באמצעות ערוץ נתונים

הדרישות

  • ‫Chrome מגרסה 47 ומעלה
  • שרת אינטרנט ל-Chrome, או להשתמש בשרת אינטרנט משלכם.
  • הקוד לדוגמה
  • כלי לעריכת טקסט
  • ידע בסיסי ב-HTML, ב-CSS וב-JavaScript

3. קבלת הקוד לדוגמה

הורדת הקוד

אם אתם מכירים את Git, אתם יכולים להוריד את הקוד ל-Codelab הזה מ-GitHub על ידי שכפול שלו:

git clone https://github.com/googlecodelabs/webrtc-web

לחלופין, אפשר ללחוץ על הכפתור הבא כדי להוריד קובץ ZIP של הקוד:

פותחים את קובץ ה-ZIP שהורדתם. הפעולה הזו תפרוק תיקיית פרויקט (adaptive-web-media) שמכילה תיקייה אחת לכל שלב ב-Codelab הזה, יחד עם כל המשאבים שתצטרכו.

אתם תבצעו את כל עבודת התכנות בספרייה שנקראת work.

התיקיות step-nn מכילות גרסה סופית לכל שלב ב-Codelab הזה. הן נועדו לשמש כהפניה.

התקנה ואימות של שרת אינטרנט

אתם יכולים להשתמש בשרת אינטרנט משלכם, אבל ה-Codelab הזה מיועד לעבוד טוב עם שרת האינטרנט של Chrome. אם האפליקציה הזו עדיין לא מותקנת, אתם יכולים להתקין אותה מחנות האינטרנט של Chrome.

אחרי שמתקינים את האפליקציה Web Server for Chrome, לוחצים על קיצור הדרך לאפליקציות Chrome מסרגל הסימניות, מדף הכרטיסייה החדשה או ממרכז האפליקציות:

לוחצים על הסמל של שרת האינטרנט:

בשלב הבא תופיע תיבת הדו-שיח הזו, שבה אפשר להגדיר את שרת האינטרנט המקומי:

לוחצים על הכפתור CHOOSE FOLDER ובוחרים את התיקייה work שיצרתם. כך תוכלו לראות את העבודה שלכם בתהליך ב-Chrome באמצעות כתובת ה-URL שמודגשת בתיבת הדו-שיח של שרת האינטרנט בקטע כתובות URL של שרת אינטרנט.

בקטע Options, מסמנים את התיבה לצד Automatically show index.html, כמו שמוצג כאן:

לאחר מכן עוצרים ומפעילים מחדש את השרת על ידי הזזת המתג Web Server: STARTED (שרת אינטרנט: הופעל) שמאלה ואז חזרה ימינה.

עכשיו נכנסים לאתר העבודה בדפדפן האינטרנט בלחיצה על כתובת ה-URL המודגשת של שרת האינטרנט. אמור להופיע דף שנראה כך, שתואם ל-work/index.html:

ברור שהאפליקציה הזו עדיין לא עושה שום דבר מעניין – עד עכשיו, זה רק שלד מינימלי שבו אנחנו משתמשים כדי לוודא ששרת האינטרנט פועל כמו שצריך. בשלבים הבאים תוסיפו פונקציונליות ותכונות פריסה.

4. וידאו בסטרימינג עם מצלמת האינטרנט

מה תלמדו

בשלב הזה נסביר איך:

  • לקבל וידאו בסטרימינג ממצלמת האינטרנט.
  • לשנות את ההפעלה של השידור.
  • שימוש ב-CSS וב-SVG כדי לשנות את הסרטון.

גרסה מלאה של השלב הזה נמצאת בתיקייה step-01.

קצת HTML…

מוסיפים רכיב video ורכיב script לקובץ index.html בספריית 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>

...וקורטוב של JavaScript

מוסיפים את הקוד הבא לקובץ main.js בתיקייה js:

'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);

רוצה לנסות?

פותחים את index.html בדפדפן. אמור להופיע משהו כזה (עם התצוגה ממצלמת האינטרנט, כמובן):

איך זה עובד

אחרי הקריאה ל-getUserMedia(), הדפדפן מבקש מהמשתמש הרשאה לגשת למצלמה (אם זו הפעם הראשונה שמתבקשת גישה למצלמה מהמקור הנוכחי). אם הפעולה בוצעה ללא שגיאות, מוחזר MediaStream, שבו רכיב מדיה יכול להשתמש באמצעות המאפיין srcObject:

navigator.mediaDevices.getUserMedia(mediaStreamConstraints)
  .then(gotLocalMediaStream).catch(handleLocalMediaStreamError);


}
function gotLocalMediaStream(mediaStream) {
  localVideo.srcObject = mediaStream;
}

הארגומנט constraints מאפשר לציין איזו מדיה לקבל. בדוגמה הזו, רק וידאו, כי האודיו מושבת כברירת מחדל:

const mediaStreamConstraints = {
  video: true,
};

אפשר להשתמש באילוצים לדרישות נוספות, כמו רזולוציית וידאו:

const hdConstraints = {
  video: {
    width: {
      min: 1280
    },
    height: {
      min: 720
    }
  }
}

במפרט של MediaTrackConstraints מפורטים כל סוגי האילוצים האפשריים, אבל לא כל האפשרויות נתמכות בכל הדפדפנים. אם הרזולוציה המבוקשת לא נתמכת על ידי המצלמה שנבחרה, getUserMedia() יידחה עם OverconstrainedError והמשתמש לא יתבקש לתת הרשאת גישה למצלמה שלו.

אם getUserMedia() מצליח, שידור הווידאו ממצלמת האינטרנט מוגדר כמקור של רכיב הווידאו:

function gotLocalMediaStream(mediaStream) {
  localVideo.srcObject = mediaStream;
}

נקודות בונוס

  • האובייקט localStream שמועבר אל getUserMedia() נמצא בהיקף גלובלי, כך שאפשר לבדוק אותו ממסוף הדפדפן: פותחים את המסוף, מקלידים stream ומקישים על Return. (כדי להציג את המסוף ב-Chrome, לוחצים על Ctrl-Shift-J, או על Command-Option-J ב-Mac).
  • מה localStream.getVideoTracks() מחזיר?
  • אפשר לנסות להתקשר אל localStream.getVideoTracks()[0].stop().
  • תסתכלו על אובייקט האילוצים: מה קורה כשמשנים אותו ל-{audio: true, video: true}?
  • מה הגודל של רכיב הסרטון? איך אפשר לקבל את הגודל הטבעי של הסרטון מ-JavaScript, בניגוד לגודל התצוגה? אפשר להשתמש בכלי הפיתוח ל-Chrome כדי לבדוק את זה.
  • אפשר לנסות להוסיף מסנני CSS לרכיב הסרטון. לדוגמה:
video {
  filter: blur(4px) invert(1) opacity(0.5);
}
  • נסו להוסיף מסנני SVG. לדוגמה:
video {
   filter: hue-rotate(180deg) saturate(200%);
 }

מה למדתם

בשלב הזה למדתם איך:

  • לקבל וידאו ממצלמת האינטרנט.
  • הגדרת מגבלות מדיה.
  • לשנות את רכיב הסרטון.

גרסה מלאה של השלב הזה נמצאת בתיקייה step-01.

טיפים

  • אל תשכחו להוסיף את המאפיין autoplay לרכיב video. בלי זה, תראו רק פריים אחד.
  • יש עוד הרבה אפשרויות לאילוצים של getUserMedia(). אפשר לראות הדגמה בכתובת webrtc.github.io/samples/src/content/peerconnection/constraints. כמו שתראו, יש הרבה דוגמאות מעניינות ל-WebRTC באתר הזה.

שיטה מומלצת

  • חשוב לוודא שרכיב הסרטון לא חורג מהמאגר שלו. הוספנו את width ואת max-width כדי להגדיר את הגודל המועדף והגודל המקסימלי של הסרטון. הדפדפן יחשב את הגובה באופן אוטומטי:
video {
  max-width: 100%;
  width: 320px;
}

הבאים בתור

יש לכם סרטון, אבל איך משדרים אותו? בשלב הבא נגלה איך.

5. סטרימינג של וידאו באמצעות RTCPeerConnection

מה תלמדו

בשלב הזה נסביר איך:

  • אפשר להשתמש ב-shim של WebRTC,‏ adapter.js, כדי להסתיר את ההבדלים בין הדפדפנים.
  • משתמשים ב-RTCPeerConnection API כדי לשדר וידאו בסטרימינג.
  • לשלוט בצילום מדיה ובסטרימינג.

גרסה מלאה של השלב הזה נמצאת בתיקייה step-2.

מה זה RTCPeerConnection?

‫RTCPeerConnection הוא API לביצוע שיחות WebRTC כדי להעביר וידאו ואודיו בסטרימינג ולהחליף נתונים.

בדוגמה הזו מוגדר חיבור בין שני אובייקטים של RTCPeerConnection (שנקראים עמיתים) באותו דף.

אין לזה הרבה שימוש מעשי, אבל זה טוב כדי להבין איך RTCPeerConnection פועל.

הוספת רכיבי וידאו וכפתורי בקרה

בקובץ index.html, מחליפים את רכיב הווידאו היחיד בשני רכיבי וידאו ובשלושה כפתורים:

<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>

רכיב וידאו אחד יציג את השידור מ-getUserMedia() והשני יציג את אותו סרטון שמשודר באמצעות RTCPeerconnection. (באפליקציה בעולם האמיתי, רכיב וידאו אחד יציג את הסטרימינג המקומי והשני את הסטרימינג מרחוק).

הוספת ה-shim של adapter.js

מוסיפים קישור לגרסה הנוכחית של adapter.js מעל הקישור ל-main.js:

<script src="https://webrtc.github.io/adapter/adapter-latest.js"></script>

עכשיו הקובץ Index.html אמור להיראות כך:

<!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>

התקנת הקוד של RTCPeerConnection

מחליפים את main.js בגרסה שבתיקייה step-02.

התחלת השיחה

פותחים את index.html, לוחצים על הכפתור Start כדי לקבל וידאו ממצלמת האינטרנט, ולוחצים על Call כדי ליצור את החיבור בין נקודות הקצה. אותו סרטון (ממצלמת האינטרנט) אמור להופיע בשני רכיבי הווידאו. כדי לראות את הרישום ביומן של WebRTC, פותחים את מסוף הדפדפן.

איך זה עובד

השלב הזה עושה הרבה…

‫WebRTC משתמש ב-RTCPeerConnection API כדי להגדיר חיבור לסטרימינג של וידאו בין לקוחות WebRTC, שנקראים עמיתים.

בדוגמה הזו, שני האובייקטים של RTCPeerConnection נמצאים באותו דף: pc1 ו-pc2. אין להם הרבה שימוש מעשי, אבל הם טובים להדגמה של אופן הפעולה של ממשקי ה-API.

כדי להגדיר שיחה בין עמיתי WebRTC, צריך לבצע שלוש משימות:

  • יוצרים RTCPeerConnection לכל קצה של השיחה, ובכל קצה מוסיפים את הסטרימינג המקומי מ-getUserMedia().
  • לקבל ולשתף מידע על הרשת: נקודות קצה פוטנציאליות לחיבור נקראות מועמדי ICE.
  • קבלת תיאורים מקומיים ומרוחקים ושיתוף שלהם: מטא-נתונים על מדיה מקומית בפורמט SDP.

נניח שעינת וירון רוצים להשתמש ב-RTCPeerConnection כדי להגדיר וידאו צ'אט.

קודם כול, מיכל ויוסי מחליפים ביניהם מידע על הרשת. הביטוי "חיפוש מועמדים" מתייחס לתהליך של חיפוש ממשקי רשת ויציאות באמצעות מסגרת ICE.

  1. עינת יוצרת אובייקט RTCPeerConnection עם handler של onicecandidate (addEventListener('icecandidate')). הפעולה הזו תואמת לקוד הבא מ-main.js:
let localPeerConnection;
localPeerConnection = new RTCPeerConnection(servers);
localPeerConnection.addEventListener('icecandidate', handleConnection);
localPeerConnection.addEventListener(
    'iceconnectionstatechange', handleConnectionChange);
  1. אליס קוראת ל-getUserMedia() ומוסיפה את ה-stream שהועבר אליו:
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.');
  1. ה-handler של onicecandidate משלב 1 נקרא כשמועמדים לרשת הופכים לזמינים.
  2. עינת שולחת לירון נתונים סדרתיים של מועמדים. באפליקציה אמיתית, התהליך הזה (שנקרא איתות) מתבצע באמצעות שירות הודעות – נסביר איך לעשות את זה בשלב מאוחר יותר. כמובן שבשלב הזה, שני האובייקטים של RTCPeerConnection נמצאים באותו דף ויכולים לתקשר ישירות בלי צורך בהעברת הודעות חיצונית.
  3. כשבוב מקבל הודעת מועמד מאליס, הוא קורא ל-addIceCandidate() כדי להוסיף את המועמד לתיאור של הצד המרוחק:
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}.`);
  }
}

בנוסף, עמיתי WebRTC צריכים לגלות ולהחליף מידע על מדיה של אודיו ווידאו מקומיים ומרוחקים, כמו רזולוציה ויכולות קודק. האיתות להחלפת מידע על הגדרות המדיה מתבצע על ידי החלפת קובצי blob של מטא-נתונים, שנקראים הצעה ותשובה, באמצעות הפורמט Session Description Protocol, שנקרא SDP:

  1. עינת מפעילה את ה-method‏ createOffer() של RTCPeerConnection. ההבטחה שמוחזרת מספקת RTCSessionDescription: תיאור הסשן המקומי של עינת:
trace('localPeerConnection createOffer start.');
localPeerConnection.createOffer(offerOptions)
  .then(createdOffer).catch(setSessionDescriptionError);
  1. אם הפעולה מצליחה, אליס מגדירה את התיאור המקומי באמצעות setLocalDescription() ואז שולחת את תיאור הסשן הזה לבוב באמצעות ערוץ האיתות שלהם.
  2. אביב מגדיר את התיאור שקיבל מעדי כתיאור המרוחק באמצעות setRemoteDescription().
  3. אבי מפעיל את השיטה RTCPeerConnection createAnswer() ומעביר לה את התיאור מרחוק שקיבל מענת, כדי שניתן יהיה ליצור סשן מקומי שתואם לסשן שלה. ה-promise של createAnswer() מעביר RTCSessionDescription: דני מגדיר אותו כתיאור המקומי ושולח אותו לענת.
  4. כשעינת מקבלת את תיאור הסשן של ירון, היא מגדירה אותו כתיאור המרוחק באמצעות 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);
}
  1. פינג!

נקודות בונוס

  1. בודקים את הכתובת chrome://webrtc-internals. כך אפשר לקבל נתונים סטטיסטיים ונתונים לניפוי באגים של WebRTC. (רשימה מלאה של כתובות URL ב-Chrome מופיעה בכתובת chrome://about.)
  2. מעצבים את הדף באמצעות CSS:
  • מציבים את הסרטונים זה לצד זה.
  • הכפתורים צריכים להיות באותו רוחב, עם טקסט גדול יותר.
  • חשוב לוודא שהפריסה פועלת בנייד.
  1. במסוף של כלי הפיתוח ל-Chrome, בודקים את localStream, localPeerConnection ו-remotePeerConnection.
  2. במסוף, בודקים את localPeerConnectionpc1.localDescription. איך נראה פורמט SDP?

מה למדתם

בשלב הזה למדתם איך:

  • אפשר להשתמש ב-shim של WebRTC,‏ adapter.js, כדי להסתיר את ההבדלים בין הדפדפנים.
  • משתמשים ב-RTCPeerConnection API כדי לשדר וידאו בסטרימינג.
  • לשלוט בצילום מדיה ובסטרימינג.
  • שיתוף מידע על מדיה ורשת בין עמיתים כדי לאפשר שיחת WebRTC.

גרסה מלאה של השלב הזה נמצאת בתיקייה step-2.

טיפים

  • יש הרבה מה ללמוד בשלב הזה. באתר webrtc.org יש מקורות מידע נוספים שמסבירים על RTCPeerConnection בפירוט. הדף הזה כולל הצעות ל-JavaScript frameworks – אם אתם רוצים להשתמש ב-WebRTC, אבל לא רוצים להתעסק עם ממשקי ה-API.
  • מידע נוסף על ה-shim של adapter.js זמין במאגר GitHub של adapter.js.
  • רוצה לראות איך נראית אפליקציית הווידאו צ'אט הכי טובה בעולם? כדאי לעיין ב-AppRTC, האפליקציה הקנונית של פרויקט WebRTC לשיחות WebRTC: אפליקציה, קוד. זמן ההגדרה של השיחה הוא פחות מ-500 אלפיות השנייה.

שיטה מומלצת

  • כדי להכין את הקוד לעתיד, השתמשו בממשקי ה-API החדשים שמבוססים על Promise והפעילו תאימות לדפדפנים שלא תומכים בהם באמצעות adapter.js.

הבאים בתור

בשלב הזה נסביר איך להשתמש ב-WebRTC כדי להעביר וידאו בסטרימינג בין עמיתים, אבל ב-Codelab הזה נתמקד גם בנתונים.

בשלב הבא נלמד איך להעביר נתונים שרירותיים באמצעות RTCDataChannel.

6. שימוש ב-RTCDataChannel להחלפת נתונים

מה תלמדו

  • איך להחליף נתונים בין נקודות קצה (עמיתים) של WebRTC.

גרסה מלאה של השלב הזה נמצאת בתיקייה step-03.

עדכון ה-HTML

בשלב הזה, תשתמשו בערוצי נתונים של WebRTC כדי לשלוח טקסט בין שני רכיבי textarea באותו דף. זה לא ממש שימושי, אבל זה מדגים איך אפשר להשתמש ב-WebRTC כדי לשתף נתונים וגם וידאו בסטרימינג.

מסירים את רכיבי הווידאו והלחצנים מהקובץ index.html ומחליפים אותם בקוד ה-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>

אזור טקסט אחד ישמש להזנת טקסט, והשני יציג את הטקסט כפי שהוא מועבר בין עמיתים.

עכשיו הקובץ index.html אמור להיראות כך:

<!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>

עדכון ה-JavaScript

מחליפים את main.js בתוכן של step-03/js/main.js.

כדי לנסות להעביר נתונים בין עמיתים: פותחים את index.html, לוחצים על Start כדי להגדיר את החיבור בין העמיתים, מזינים טקסט ב-textarea בצד שמאל ולוחצים על Send כדי להעביר את הטקסט באמצעות ערוצי נתונים של WebRTC.

איך זה עובד

הקוד הזה משתמש ב-RTCPeerConnection וב-RTCDataChannel כדי לאפשר החלפה של הודעות טקסט.

רוב הקוד בשלב הזה זהה לקוד בדוגמה של RTCPeerConnection.

רוב הקוד החדש נמצא בפונקציות sendData() ו-createConnection():

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);
}

התחביר של RTCDataChannel דומה בכוונה ל-WebSocket, עם שיטת send() ואירוע message.

שימו לב לשימוש ב-dataConstraint. אפשר להגדיר ערוצי נתונים כדי לאפשר סוגים שונים של שיתוף נתונים – לדוגמה, לתת עדיפות למסירה אמינה על פני ביצועים. מידע נוסף על האפשרויות זמין ברשת המפתחים של Mozilla.

נקודות בונוס

  1. ב-SCTP, הפרוטוקול שמשמש את ערוצי הנתונים של WebRTC, העברת נתונים אמינה ומסודרת מופעלת כברירת מחדל. מתי יכול להיות ש-RTCDataChannel יצטרך לספק העברת נתונים אמינה, ומתי הביצועים עשויים להיות חשובים יותר – גם אם זה אומר לאבד חלק מהנתונים?
  2. משתמשים ב-CSS כדי לשפר את פריסת הדף, ומוסיפים מאפיין פלייסהולדר לאזור הטקסט dataChannelReceive.
  3. בודקים את הדף במכשיר נייד.

מה למדתם

בשלב הזה למדתם איך:

  • ליצור חיבור בין שני עמיתים ב-WebRTC.
  • החלפת נתוני טקסט בין המשתתפים.

גרסה מלאה של השלב הזה נמצאת בתיקייה step-03.

מידע נוסף

הבאים בתור

למדתם איך להחליף נתונים בין עמיתים באותו דף, אבל איך עושים את זה בין מכונות שונות? קודם כל, צריך להגדיר ערוץ איתות כדי להחליף הודעות מטא-נתונים. בשלב הבא נסביר איך עושים את זה.

7. הגדרת שירות איתות להחלפת הודעות

מה תלמדו

בשלב הזה נסביר איך:

  • משתמשים ב-npm כדי להתקין את יחסי התלות של הפרויקט, כמו שמצוין ב-package.json
  • מפעילים שרת Node.js ומשתמשים ב-node-static כדי להציג קבצים סטטיים.
  • הגדרת שירות הודעות ב-Node.js באמצעות Socket.IO.
  • אפשר להשתמש בה כדי ליצור "חדרים" ולהחליף הודעות.

גרסה מלאה של השלב הזה נמצאת בתיקייה step-04.

מושגים

כדי להגדיר ולתחזק שיחת WebRTC, לקוחות WebRTC (עמיתים) צריכים להחליף מטא-נתונים:

  • מידע על המועמד (רשת).
  • הודעות הצעה ותשובה שמספקות מידע על המדיה, כמו רזולוציה וקודקים.

במילים אחרות, נדרש חילוף של מטא-נתונים לפני שניתן לבצע סטרימינג של אודיו, וידאו או נתונים בין משתמשים. התהליך הזה נקרא איתות.

בשלבים הקודמים, האובייקטים של RTCPeerConnection של השולח והמקבל נמצאים באותו דף, כך ש"איתות" הוא עניין של העברת מטא-נתונים בין אובייקטים.

באפליקציה בעולם האמיתי, ה-RTCPeerConnection של השולח והמקבל פועלים בדפי אינטרנט במכשירים שונים, ואתם צריכים דרך שבה הם יוכלו להעביר מטא-נתונים.

לשם כך, משתמשים בשרת איתות: שרת שיכול להעביר הודעות בין לקוחות WebRTC (עמיתים). ההודעות עצמן הן טקסט פשוט: אובייקטים ב-JavaScript שהומרו למחרוזות.

דרישה מוקדמת: התקנת Node.js

כדי להריץ את השלבים הבאים ב-Codelab הזה (תיקיות step-04 עד step-06), תצטרכו להריץ שרת ב-localhost באמצעות Node.js.

אתם יכולים להוריד ולהתקין את Node.js ישירות מאתר האינטרנט של Node.js או באמצעות מנהל החבילות המועדף עליכם.

אחרי ההתקנה, תוכלו לייבא את יחסי התלות שנדרשים לשלבים הבאים (מריצים את npm install), וגם להריץ שרת קטן של מארח מקומי כדי להפעיל את ה-Codelab (מריצים את node index.js). הפקודות האלה יצוינו בהמשך, כשהן יידרשו.

על היישום

‫WebRTC משתמש ב-API של JavaScript בצד הלקוח, אבל לשימוש בעולם האמיתי נדרש גם שרת איתות (העברת הודעות), וגם שרתי STUN ו-TURN. מידע נוסף על התשתית של WebRTC

בשלב הזה תיצרו שרת איתות פשוט ב-Node.js, באמצעות מודול Socket.IO Node.js וספריית JavaScript להעברת הודעות. ניסיון עם Node.js ו-Socket.IO יהיה שימושי, אבל לא חיוני. רכיבי ההודעות פשוטים.

בדוגמה הזו, השרת (אפליקציית Node.js) מוטמע ב-index.js, והלקוח שפועל בו (אפליקציית האינטרנט) מוטמע ב-index.html.

לאפליקציית Node.js בשלב הזה יש שתי משימות.

קודם כול, הוא משמש כממסר הודעות:

socket.on('message', function (message) {
  log('Got message: ', message);
  socket.broadcast.emit('message', message);
});

שנית, הוא מנהל את "חדרי" הווידאו צ'אט של 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);
}

אפליקציית WebRTC שלנו תאפשר לשני עמיתים לכל היותר לשתף חדר.

‫HTML ו-JavaScript

מעדכנים את index.html כך שייראה כך:

<!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>

לא תראו שום דבר בדף בשלב הזה: כל הרישום ביומן מתבצע במסוף הדפדפן. (כדי להציג את המסוף ב-Chrome, לוחצים על Ctrl-Shift-J, או על Command-Option-J ב-Mac).

מחליפים את js/main.js בקוד הבא:

'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);
});

הגדרת Socket.IO להפעלה ב-Node.js

בקובץ ה-HTML, יכול להיות שראיתם שאתם משתמשים בקובץ Socket.IO:

<script src="/socket.io/socket.io.js"></script>

ברמה העליונה של ספריית work, יוצרים קובץ בשם package.json עם התוכן הבא:

{
  "name": "webrtc-codelab",
  "version": "0.0.1",
  "description": "WebRTC codelab",
  "dependencies": {
    "node-static": "^0.7.10",
    "socket.io": "^1.2.0"
  }
}

זהו קובץ מניפסט של אפליקציה שמציין למנהל החבילות של Node (npm) אילו יחסי תלות של הפרויקט צריך להתקין.

כדי להתקין יחסי תלות (כמו /socket.io/socket.io.js), מריצים את הפקודה הבאה מהטרמינל של שורת הפקודה, בספריית work:

npm install

אמור להופיע יומן התקנה שמסתיים בערך כך:

כמו שאפשר לראות, npm התקין את יחסי התלות שהוגדרו ב-package.json.

יוצרים קובץ חדש בשם index.js ברמה העליונה של ספריית work (לא בספריית js) ומוסיפים את הקוד הבא:

'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);
        }
      });
    }
  });

});

במסוף של שורת הפקודה, מריצים את הפקודה הבאה בספרייה work:

node index.js

בדפדפן, פותחים את localhost:8080.

בכל פעם שתפתחו את כתובת ה-URL הזו, תתבקשו להזין שם חדר. כדי להצטרף לאותו חדר, בוחרים באותו שם חדר בכל פעם, למשל "foo".

פותחים דף כרטיסייה חדשה ופותחים שוב את localhost:8080. בוחרים את אותו שם חדר.

פותחים את localhost:8080 בכרטיסייה או בחלון שלישיים. בוחרים שוב את אותו שם חדר.

בודקים את המסוף בכל אחת מהכרטיסיות: אמורים לראות את הרישום ביומן מקוד ה-JavaScript הקודם.

נקודות בונוס

  1. אילו מנגנוני העברת הודעות חלופיים אפשר להציע? באילו בעיות אתם עלולים להיתקל אם תשתמשו ב-WebSocket "טהור"?
  2. אילו בעיות יכולות להיות קשורות להרחבת האפליקציה הזו? אתה יכול לפתח שיטה לבדיקת אלפי או מיליוני בקשות בו-זמנית לחדרים?
  3. האפליקציה הזו משתמשת בהנחיית JavaScript כדי לקבל שם של חדר. צריך למצוא דרך לקבל את שם החדר מכתובת ה-URL. לדוגמה, אם הכתובת היא localhost:8080/foo, שם החדר יהיה foo.

מה למדתם

בשלב הזה למדתם איך:

  • משתמשים ב-npm כדי להתקין את יחסי התלות של הפרויקט, כמו שצוין ב-package.json.
  • מפעילים שרת Node.js כדי להציג קבצים סטטיים.
  • הגדרת שירות הודעות ב-Node.js באמצעות socket.io.
  • אפשר להשתמש בה כדי ליצור "חדרים" ולהחליף הודעות.

גרסה מלאה של השלב הזה נמצאת בתיקייה step-04.

מידע נוסף

הבאים בתור

איך משתמשים באיתות כדי לאפשר לשני משתמשים ליצור חיבור בין עמיתים.

8. שילוב של חיבור בין משתמשים ואיתות

מה תלמדו

בשלב הזה נסביר איך:

  • הפעלת שירות איתות של WebRTC באמצעות Socket.IO שפועל ב-Node.js
  • השתמשו בשירות הזה כדי להחליף מטא-נתונים של WebRTC בין עמיתים.

גרסה מלאה של השלב הזה נמצאת בתיקייה step-05.

החלפת HTML ו-JavaScript

מחליפים את התוכן של index.html בתוכן הבא:

<!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>

מחליפים את js/main.js בתוכן של step-05/js/main.js.

הפעלת שרת Node.js

אם אתם לא עוקבים אחרי ה-Codelab הזה מספריית העבודה שלכם, יכול להיות שתצטרכו להתקין את יחסי התלות של התיקייה step-05 או של תיקיית העבודה הנוכחית שלכם. מריצים את הפקודה הבאה מספריית העבודה:

npm install

אחרי ההתקנה, אם שרת Node.js לא פועל, מפעילים אותו באמצעות הפקודה הבאה בספרייה work:

node index.js

חשוב לוודא שאתם משתמשים בגרסה של index.js מהשלב הקודם שמטמיעה את Socket.IO. מידע נוסף על Node ו-Socket IO זמין בקטע "הגדרת שירות איתות להחלפת הודעות".

בדפדפן, פותחים את localhost:8080.

פותחים שוב את localhost:8080 בכרטיסייה או בחלון חדשים. רכיב וידאו אחד יציג את השידור המקומי מ-getUserMedia() והשני יציג את הווידאו "מרחוק" שמשודר באמצעות RTCPeerconnection.

לצפות ביומנים במסוף הדפדפן.

נקודות בונוס

  1. האפליקציה הזו תומכת רק בווידאו צ'אט בין שני משתתפים. איך אפשר לשנות את העיצוב כדי לאפשר ליותר מאדם אחד לשתף את אותו חדר וידאו צ'אט?
  2. בדוגמה הזו, שם החדר foo מוטמע בקוד. מה הדרך הכי טובה להפעיל שמות אחרים של חדרים?
  3. איך המשתמשים יכולים לשתף את שם החדר? נסו ליצור חלופה לשיתוף שמות של חדרים.
  4. איך הייתם משנים את האפליקציה?
  • מצלמים תמונה ומקבלים את הנתונים ממנה באמצעות רכיב הקנבס.
  • להחליף נתוני תמונות עם משתמש מרוחק.

גרסה מלאה של השלב הזה נמצאת בתיקייה step-06.

איך זה עובד

בשיעורים הקודמים למדתם איך להחליף הודעות טקסט באמצעות RTCDataChannel.

השלב הזה מאפשר לשתף קבצים שלמים: בדוגמה הזו, תמונות שצולמו באמצעות getUserMedia().

החלקים העיקריים בשלב הזה:

  1. הגדרת ערוץ נתונים. שימו לב שבשלב הזה לא מוסיפים זרמי מדיה לחיבור בין נקודות הקצה.
  2. מצלמים את שידור הווידאו של המשתמש ממצלמת האינטרנט באמצעות 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);
  });
}
  1. כשהמשתמש לוחץ על הלחצן Snap, מקבלים תמונת מצב (פריים של סרטון) משידור הווידאו ומציגים אותה ברכיב 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);
}
  1. כשהמשתמש לוחץ על הכפתור שליחה, ממירים את התמונה לבייטים ושולחים אותם באמצעות ערוץ נתונים:
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));
  }
}
  1. הצד המקבל ממיר את הבייטים של ההודעה בערוץ הנתונים בחזרה לתמונה ומציג את התמונה למשתמש:
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);
}

קבל את הקוד

מחליפים את התוכן של התיקייה work בתוכן של step-06. קובץ index.html ב-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>

  <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>

אם אתם לא עוקבים אחרי ה-Codelab הזה מספריית העבודה שלכם, יכול להיות שתצטרכו להתקין את יחסי התלות של התיקייה step-06 או של תיקיית העבודה הנוכחית שלכם. פשוט מריצים את הפקודה הבאה מספריית העבודה:

npm install

אחרי ההתקנה, אם שרת Node.js לא פועל, מפעילים אותו באמצעות הפקודה הבאה מספריית העבודה:

node index.js

חשוב לוודא שאתם משתמשים בגרסה של index.js שמטמיעה את Socket.IO, ולזכור להפעיל מחדש את שרת Node.js אם אתם מבצעים שינויים. למידע נוסף על Node ו-Socket IO, עיינו בקטע "הגדרת שירות איתות להחלפת הודעות".

אם צריך, לוחצים על הכפתור אישור כדי לאפשר לאפליקציה להשתמש במצלמת האינטרנט.

האפליקציה תיצור מזהה חדר אקראי ותוסיף אותו לכתובת ה-URL. פותחים את כתובת ה-URL מסרגל הכתובות בכרטיסייה חדשה או בחלון חדש בדפדפן.

לוחצים על הכפתור Snap & Send (צילום ושליחה) ואז מסתכלים על האזור Incoming (נכנס) בכרטיסייה השנייה בתחתית הדף. האפליקציה מעבירה תמונות בין כרטיסיות.

אמורה להופיע הודעה כזו:

נקודות בונוס

  1. איך אפשר לשנות את הקוד כדי לאפשר שיתוף של כל סוג קובץ?

מידע נוסף

מה למדתם

  • איך לצלם תמונה ולקבל ממנה את הנתונים באמצעות רכיב ה-canvas.
  • איך להחליף את הנתונים האלה עם משתמש מרוחק.

גרסה מלאה של השלב הזה נמצאת בתיקייה step-06.

9. מזל טוב

יצרתם אפליקציה לסטרימינג של וידאו בזמן אמת ולהחלפת נתונים.

מה למדתם

ב-Codelab הזה למדתם איך:

  • לקבל וידאו ממצלמת האינטרנט.
  • סטרימינג של וידאו באמצעות RTCPeerConnection.
  • העברת נתונים בסטרימינג באמצעות RTCDataChannel.
  • מגדירים שירות איתות להחלפת הודעות.
  • שילוב של חיבור בין עמיתים ואיתות.
  • לצלם תמונה ולשתף אותה באמצעות ערוץ נתונים.

השלבים הבאים

מידע נוסף

  • באתר webrtc.org יש מגוון מקורות מידע שיעזרו לכם להתחיל להשתמש ב-WebRTC.