בלוג

שיחות וידאו ב-JavaScript: איך WebRTC מחבר שני דפדפנים

· Andrij Tkachenko · 7 דקות קריאה

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

שיחת וידאו ב-JavaScript דורשת שלושה דברים: getUserMedia() למצלמה ולמיקרופון, ‏RTCPeerConnection שמעביר את התמונה והקול בין שני הדפדפנים, וערוץ איתות (signaling) משלכם, לרוב websocket, שמעביר ביניהם את ההצעות ואת כתובות הרשת שלהם. הדפדפן מטפל במדיה, וכל מה שמסביב, ממציאת האדם השני ועד מעבר דרך חומת אש, נשאר לכם לבנות.

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

שלושת החלקים של שיחת WebRTC

חלק מה הוא עושה
getUserMedia() פותח את המצלמה והמיקרופון, אחרי שהדפדפן שואל
RTCPeerConnection מחבר את שני הדפדפנים ומעביר את המדיה, מוצפנת
איתות מעביר ביניהם הצעות, תשובות וכתובות, דרך השרת שלכם

שני הראשונים מובנים בכל דפדפן מודרני. השלישי לא, ובכוונה. JavaScript Session Establishment Protocol, שמתאר איך ה-API של הדפדפן עובד, משאיר לאפליקציה את הדרך שבה שני דפדפנים מגיעים זה לזה. הם צריכים להחליף שני סוגים של הודעות לפני שתמונה כלשהי עוברת:

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

צ׳אט וידאו ב-JavaScript רגיל

שני אנשים פותחים את אותו דף, וכל אחד רואה את השני. הדף צריך שני רכיבי וידאו:

HTML
<video id="me" autoplay playsinline muted></video>
<video id="them" autoplay playsinline></video>
<script type="module" src="/call.js"></script>

הווידאו שלכם הוא muted, כדי שלא תשמעו את עצמכם, וזה גם מאפשר לדפדפן להפעיל אותו לפני שמישהו לוחץ. ‏playsinline משאיר אותו בתוך הדף באייפון.

שרת האיתות

שרת האיתות הקטן ביותר מעביר כל הודעה מדפדפן אחד לשני. ב-Node.js, עם החבילה ws:

server.mjs
import { WebSocketServer, WebSocket } from 'ws';

const wss = new WebSocketServer({ port: 8080 });

wss.on('connection', (socket) => {
  socket.on('message', (data) => {
    // מעבירים לכל שאר המחוברים: כאן, לאדם השני.
    for (const other of wss.clients) {
      if (other !== socket && other.readyState === WebSocket.OPEN) {
        other.send(data.toString());
      }
    }
  });
});

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

הדף

שני הדפדפנים מריצים את אותו קוד. כל אחד פותח את המצלמה שלו, מודיע שהוא כאן, ומוסיף את המצלמה לחיבור ברגע שגם האדם השני הודיע על כך, כדי שההצעה הראשונה תגיע למישהו. החלק שעונה להודעות הולך לפי התבנית perfect negotiation של MDN, שמאפשרת לכל אחד מהצדדים להתחיל, אפילו לשניהם בבת אחת:

call.js
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' }],
});

// מוסיפים את המצלמה ברגע שהאדם השני כאן.
let started = false;
const start = () => {
  if (started) return;
  started = true;
  for (const track of local.getTracks()) pc.addTrack(track, local);
};

// צד אחד מוותר כששניהם מציעים באותו רגע.
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 }); // כדי שגם הצד השני יתחיל
    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 });

הריצו את השרת, הגישו את הדף מ-localhost, ופתחו אותו בלשונית אחת, וכ-/#polite בלשונית אחרת, בכל סדר שהוא. כל לשונית מבקשת גישה למצלמה, ואז כל אחת מציגה את השנייה. בשרת שלכם הדף נמצא ב-HTTPS, ולכן כתובת ה-websocket הופכת ל-wss:// עם תעודה, ו-stun.example.com מייצג שרת STUN שמותר לכם להשתמש בו.

מה קורה, לפי הסדר:

  1. המצלמה נפתחת. ‏getUserMedia() שואל את האדם קודם. MDN מציין שהוא עובד רק בהקשר מאובטח, דף ב-HTTPS או ב-localhost, ושסירוב נדחה עם NotAllowedError. כשמצלמה נשארת שחורה, המדריך שלנו למצלמה שלא עובדת עובר על כל סיבה.
  2. השניים מוצאים זה את זה. כל דף אומר here כשהוא מתחבר. הראשון לא שומע אף אחד, וכשהשני מגיע, הראשון שומע אותו ועונה, כך ששניהם יודעים שהשני כאן.
  3. הוספת הערוצים מבקשת משא ומתן. החיבור מפעיל את negotiationneeded, ו-setLocalDescription() בלי ארגומנט יוצר הצעה, שיוצאת דרך ה-websocket.
  4. הצד השני עונה. הוא קובע את ההצעה כתיאור המרוחק שלו, יוצר תשובה באותה דרך, ושולח אותה בחזרה.
  5. שני הצדדים אוספים מועמדים ושולחים כל אחד מהם ברגע שהוא נמצא. הדפדפנים בודקים זוגות של כתובות זה מול זה ומתייצבים על אחד שעובד, הישירים קודם.
  6. המדיה זורמת. ‏ontrack מופעל בכל צד, והאדם השני מופיע. היא מוצפנת בדרכה, תמיד: WebRTC מחייב זאת (RFC 8827). בקשו רק { audio: true } ואותו קוד מקיים שיחה קולית, ששיחות קוליות וחדרי שמע מודד ומסביר.

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

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

מה ההדגמה משאירה בחוץ

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

  • מי רשאי להתקשר למי. השרת שלמעלה מעביר כל הודעה לכל אחד. שרת אמיתי בודק מי מחובר, והאם מותר לו להתקשר לאדם הזה, לפני שהוא מצלצל למישהו.
  • צלצול. מי שמתקשרים אליו צריך לשמוע אותו בכל דף שבו הוא נמצא, בכל לשונית, ולהפסיק לשמוע אותו בכולן ברגע שהוא עונה באחת. זה דורש חיבור פתוח לכל משתמש, כל הזמן שהוא באתר (websockets מעבר לשרת אחד מראה מה זה דורש כשיש לכם יותר משרת אחד).
  • ממסרים. שרת STUN מוצא כתובות ציבוריות, וזה לא מספיק מאחורי חומות אש רבות של משרדים ורשתות סלולריות. השיחות האלה צריכות שרת TURN, עם פרטי כניסה שתוקפם פג, בפורטים שרשתות כאלה משאירות פתוחים (הפורטים ששיחה צריכה).
  • התחברות מחדש. טלפון שעובר מ-Wi-Fi לגלישה סלולרית מאבד את הנתיב שלו. עקבו אחרי connectionState, וקראו ל-pc.restartIce() כשהוא נכשל, כדי שהדפדפנים יחפשו זוג כתובות חדש בלי לנתק.
  • יותר משני אנשים. במבנה הזה כל אדם שולח את הווידאו שלו לכל אחד מהאחרים. זה מחזיק לשלושה או ארבעה, ואז ההעלאות נגמרות, ולכן שיחות קבוצתיות רצות דרך שרתי מדיה (איך שיחות וידאו קבוצתיות עובדות).
  • שגיאות שאנשים רואים. מצלמה שנחסמה, מיקרופון חסר, שיחה שאף אחד לא עונה לה. למה חיבור WebRTC נכשל עובר על מה לבדוק משני הצדדים.

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

אותה שיחה עם WordPlus Cloud

עם ה-SDK של WordPlus Cloud, דף של JavaScript רגיל מתקשר בלי שרת איתות, ממסר או מסך שיחה לכתוב. השרת שלכם מצהיר מי רשאי להתקשר, ככלל לכל שיחה ששמה מתאים לתבנית. כאן, שיחת תמיכה כמו support:34:42 מיועדת לשני האנשים שבשמה:

JavaScript
// server.mjs, כש-realtime מגיע מ-createRealtime() של @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));
});

הדף מתחבר עם ההגדרות שהשרת שלכם הכניס אליו, מפעיל את מסך השיחה, ומציב כפתור במקום שממנו אנשים מתקשרים:

JavaScript
import { connect } from '@wordplus/realtime';

const rt = await connect(JSON.parse(document.getElementById('realtime').textContent));
await rt.callScreen(); // הצלצול וחלון השיחה, בדף הזה
HTML
<call-button to="34" call="support:{pair}" type="video" name="Ann">Call Ann</call-button>

השיחה מצלצלת בכל לשונית ובכל מכשיר שפתוחים אצל Ann. היא עוברת ישירות בין שני הדפדפנים כשהרשתות שלהם מאפשרות זאת, דרך הממסרים שלנו בפורטים 443 ו-80 כשלא, ודרך שרתי המדיה שלנו כשאפילו הממסרים לא מצליחים להגיע, ועוברת מנתיב לנתיב בלי לנתק. שיחות בין שני אנשים מוצפנות מקצה לקצה בכל נתיב. למסך משלכם, rt.calls() נותן לכם את אותן שיחות בלי חלקים מוכנים, calls.start() כדי להתקשר ואירוע incoming כדי לענות.

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

שיחות וידאו לאפליקציה שלכם

WordPlus Cloud for Apps מתומחר לפי חיבורים בו-זמניים, החל מ-1,000, בחיוב חודשי או שנתי, ושיחות בין שני אנשים לא לוקחות קרדיטים באף נתיב. ראו שיחות וידאו ושיחות קבוצתיות לאפליקציות, או את המחירים לאפליקציות. שאלות על האינטגרציה שלכם? כתבו לנו.