การสื่อสารแบบเรียลไทม์ด้วย WebRTC

1. บทนำ

WebRTC เป็นโปรเจ็กต์โอเพนซอร์สที่ช่วยให้สามารถสื่อสารเสียง วิดีโอ และข้อมูลแบบเรียลไทม์ในเว็บและแอปที่มาพร้อมเครื่อง

WebRTC มี JavaScript API หลายรายการ โปรดคลิกลิงก์เพื่อดูการสาธิต

  • getUserMedia(): บันทึกเสียงและวิดีโอ
  • MediaRecorder: บันทึกเสียงและวิดีโอ
  • RTCPeerConnection: สตรีมเสียงและวิดีโอระหว่างผู้ใช้
  • RTCDataChannel: สตรีมข้อมูลระหว่างผู้ใช้

ฉันจะใช้ WebRTC ได้ที่ไหนบ้าง

ใน Firefox, Opera และใน Chrome บนเดสก์ท็อปและ Android นอกจากนี้ WebRTC ยังพร้อมใช้งานสำหรับแอปที่มาพร้อมเครื่องบน iOS และ Android ด้วย

การส่งสัญญาณคืออะไร

WebRTC ใช้ RTCPeerConnection เพื่อสื่อสารข้อมูลสตรีมมิงระหว่างเบราว์เซอร์ แต่ก็ต้องมีกลไกในการประสานงานการสื่อสารและส่งข้อความควบคุมด้วย ซึ่งเป็นกระบวนการที่เรียกว่าการส่งสัญญาณ WebRTC ไม่ได้ระบุวิธีการและโปรโตคอลการส่งสัญญาณ ใน Codelab นี้ คุณจะใช้ Socket.IO สำหรับการรับส่งข้อความ แต่ก็มีทางเลือกอื่นๆ อีกมากมาย

STUN และ TURN คืออะไร

WebRTC ออกแบบมาให้ทำงานแบบเพียร์ทูเพียร์ เพื่อให้ผู้ใช้เชื่อมต่อผ่านเส้นทางที่ตรงที่สุดเท่าที่จะเป็นไปได้ อย่างไรก็ตาม WebRTC สร้างขึ้นเพื่อรับมือกับเครือข่ายในชีวิตจริง โดยแอปพลิเคชันไคลเอ็นต์ต้องข้ามเกตเวย์ NAT และไฟร์วอลล์ และเครือข่ายแบบเพียร์ทูเพียร์ต้องมีทางเลือกสำรองในกรณีที่การเชื่อมต่อโดยตรงล้มเหลว ในกระบวนการนี้ WebRTC API จะใช้เซิร์ฟเวอร์ STUN เพื่อรับที่อยู่ IP ของคอมพิวเตอร์ และใช้เซิร์ฟเวอร์ TURN เพื่อทำหน้าที่เป็นเซิร์ฟเวอร์รีเลย์ในกรณีที่การสื่อสารแบบเพียร์ทูเพียร์ล้มเหลว (WebRTC in the real world จะอธิบายรายละเอียดเพิ่มเติม)

WebRTC ปลอดภัยไหม

คอมโพเนนต์ WebRTC ทั้งหมดต้องมีการเข้ารหัส และ JavaScript API ของ WebRTC จะใช้ได้จากต้นทางที่ปลอดภัย (HTTPS หรือ localhost) เท่านั้น มาตรฐาน WebRTC ไม่ได้กำหนดกลไกการส่งสัญญาณ ดังนั้นคุณจึงต้องตรวจสอบว่าใช้โปรโตคอลที่ปลอดภัย

2. ภาพรวม

สร้างแอปเพื่อรับวิดีโอและถ่ายภาพสแนปชอตด้วยเว็บแคม แล้วแชร์แบบเพียร์ทูเพียร์โดยใช้ WebRTC ในระหว่างนี้ คุณจะได้เรียนรู้วิธีใช้ WebRTC API หลักและตั้งค่าเซิร์ฟเวอร์การรับส่งข้อความโดยใช้ 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) ที่มีโฟลเดอร์ 1 โฟลเดอร์สำหรับแต่ละขั้นตอนของ Codelab นี้ พร้อมกับทรัพยากรทั้งหมดที่คุณต้องการ

คุณจะเขียนโค้ดทั้งหมดในไดเรกทอรีชื่อ work

โฟลเดอร์ step-nn มีเวอร์ชันที่เสร็จสมบูรณ์สำหรับแต่ละขั้นตอนของ Codelab นี้ ซึ่งมีไว้เพื่อใช้อ้างอิงเท่านั้น

ติดตั้งและยืนยันเว็บเซิร์ฟเวอร์

แม้ว่าคุณจะใช้เว็บเซิร์ฟเวอร์ของคุณเองได้ แต่ Codelab นี้ออกแบบมาให้ทำงานได้ดีกับ Chrome Web Server หากยังไม่ได้ติดตั้งแอปดังกล่าว คุณสามารถติดตั้งได้จาก Chrome เว็บสโตร์

หลังจากติดตั้งแอป Web Server for Chrome แล้ว ให้คลิกทางลัดแอป Chrome จากแถบบุ๊กมาร์ก หน้าแท็บใหม่ หรือจากตัวเปิดแอป

คลิกไอคอนเว็บเซิร์ฟเวอร์

ถัดไป คุณจะเห็นกล่องโต้ตอบนี้ ซึ่งช่วยให้คุณกำหนดค่าเว็บเซิร์ฟเวอร์ในเครื่องได้

คลิกปุ่มเลือกโฟลเดอร์ แล้วเลือกโฟลเดอร์ work ที่คุณเพิ่งสร้าง ซึ่งจะช่วยให้คุณดูงานที่กำลังดำเนินการใน Chrome ได้โดยใช้ URL ที่ไฮไลต์ในกล่องโต้ตอบเว็บเซิร์ฟเวอร์ในส่วน URL ของเว็บเซิร์ฟเวอร์

ในส่วนตัวเลือก ให้เลือกช่องข้างแสดง 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 2 รายการ (เรียกว่าเพียร์) ในหน้าเดียวกัน

ไม่ค่อยมีประโยชน์ในทางปฏิบัติ แต่เหมาะสำหรับการทำความเข้าใจวิธีการทำงานของ RTCPeerConnection

เพิ่มองค์ประกอบวิดีโอและปุ่มควบคุม

ใน index.html ให้แทนที่องค์ประกอบวิดีโอเดียวด้วยองค์ประกอบวิดีโอ 2 รายการและปุ่ม 3 ปุ่ม ดังนี้

<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 คลิกปุ่มเริ่มเพื่อรับวิดีโอจากเว็บแคม แล้วคลิกโทรเพื่อทำการเชื่อมต่อแบบเพียร์ทูเพียร์ คุณควรเห็นวิดีโอเดียวกัน (จากเว็บแคม) ในองค์ประกอบวิดีโอทั้ง 2 รายการ ดูคอนโซลเบราว์เซอร์เพื่อดูการบันทึก WebRTC

วิธีการทำงาน

ขั้นตอนนี้มีหลายอย่างที่ต้องทำ...

WebRTC ใช้ RTCPeerConnection API เพื่อตั้งค่าการเชื่อมต่อเพื่อสตรีมวิดีโอระหว่างไคลเอ็นต์ WebRTC หรือที่เรียกว่าเพียร์

ในตัวอย่างนี้ ออบเจ็กต์ RTCPeerConnection 2 รายการอยู่ในหน้าเดียวกัน ได้แก่ pc1 และ pc2 แม้จะไม่ได้มีประโยชน์มากนักในทางปฏิบัติ แต่ก็เหมาะสำหรับการสาธิตวิธีการทำงานของ API

การตั้งค่าการโทรระหว่างเพียร์ WebRTC ประกอบด้วยงาน 3 อย่าง ได้แก่

  • สร้าง RTCPeerConnection สำหรับปลายสายแต่ละด้าน และเพิ่มสตรีมในเครื่องจาก getUserMedia() ที่ปลายสายแต่ละด้าน
  • รับและแชร์ข้อมูลเครือข่าย: ปลายทางการเชื่อมต่อที่เป็นไปได้เรียกว่าผู้สมัคร ICE
  • รับและแชร์คำอธิบายในเครื่องและระยะไกล: ข้อมูลเมตาเกี่ยวกับสื่อในเครื่องในรูปแบบ SDP

สมมติว่าอลิซและบ็อบต้องการใช้ RTCPeerConnection เพื่อตั้งค่าวิดีโอแชท

ขั้นแรก Alice และ Bob จะแลกเปลี่ยนข้อมูลเครือข่ายกัน นิพจน์ "การค้นหาผู้สมัคร" หมายถึงกระบวนการค้นหาอินเทอร์เฟซเครือข่ายและพอร์ตโดยใช้เฟรมเวิร์ก ICE

  1. Alice สร้างออบเจ็กต์ RTCPeerConnection ด้วยแฮนเดิล onicecandidate (addEventListener('icecandidate')) ซึ่งสอดคล้องกับโค้ดต่อไปนี้จาก main.js
let localPeerConnection;
localPeerConnection = new RTCPeerConnection(servers);
localPeerConnection.addEventListener('icecandidate', handleConnection);
localPeerConnection.addEventListener(
    'iceconnectionstatechange', handleConnectionChange);
  1. Alice เรียกใช้ getUserMedia() และเพิ่มสตรีมที่ส่งไปยังเมธอดดังกล่าว
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. ระบบจะเรียกใช้แฮนเดิล onicecandidate จากขั้นตอนที่ 1 เมื่อมีตัวเลือกเครือข่ายที่พร้อมใช้งาน
  2. Alice ส่งข้อมูลผู้สมัครที่เรียงลำดับแล้วให้ Bob ในแอปพลิเคชันจริง กระบวนการนี้ (เรียกว่าการส่งสัญญาณ) จะเกิดขึ้นโดยใช้บริการรับส่งข้อความ ซึ่งคุณจะได้เรียนรู้วิธีดำเนินการในขั้นตอนถัดไป แน่นอนว่าในขั้นตอนนี้ ออบเจ็กต์ RTCPeerConnection ทั้ง 2 รายการจะอยู่ในหน้าเดียวกันและสื่อสารกันได้โดยตรงโดยไม่ต้องใช้การรับส่งข้อความภายนอก
  3. เมื่อ Bob ได้รับข้อความผู้สมัครจาก Alice เขาจะเรียกใช้ 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. Alice เรียกใช้เมธอด RTCPeerConnection createOffer() สัญญาที่ส่งคืนจะให้ RTCSessionDescription: คำอธิบายเซสชันในเครื่องของ Alice:
trace('localPeerConnection createOffer start.');
localPeerConnection.createOffer(offerOptions)
  .then(createdOffer).catch(setSessionDescriptionError);
  1. หากสำเร็จ Alice จะตั้งค่าคำอธิบายในเครื่องโดยใช้ setLocalDescription() แล้วส่งคำอธิบายเซสชันนี้ให้ Bob โดยใช้ช่องทางการส่งสัญญาณ
  2. Bob ตั้งค่าคำอธิบายที่ Alice ส่งมาให้เป็นคำอธิบายระยะไกลโดยใช้ setRemoteDescription()
  3. Bob เรียกใช้เมธอด RTCPeerConnection createAnswer() โดยส่งคำอธิบายระยะไกลที่ได้รับจาก Alice เพื่อให้สร้างเซสชันในเครื่องที่เข้ากันได้กับเซสชันของ Alice สัญญา createAnswer() จะส่งต่อ RTCSessionDescription: บ็อบตั้งค่าเป็นคำอธิบายในเครื่องและส่งให้แอนนา
  4. เมื่อ Alice ได้รับคำอธิบายเซสชันของ Bob เธอจะตั้งค่าเป็นคำอธิบายระยะไกลด้วย 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. Ping!

คะแนนโบนัส

  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

เคล็ดลับ

  • มีหลายสิ่งหลายอย่างให้เรียนรู้ในขั้นตอนนี้ หากต้องการดูแหล่งข้อมูลอื่นๆ ที่อธิบาย RTCPeerConnection โดยละเอียด โปรดไปที่ webrtc.org หน้านี้มีคำแนะนำสำหรับเฟรมเวิร์ก JavaScript หากคุณต้องการใช้ WebRTC แต่ไม่ต้องการจัดการ API
  • ดูข้อมูลเพิ่มเติมเกี่ยวกับ Shim ของ adapter.js ได้จากที่เก็บ GitHub ของ adapter.js
  • อยากเห็นหน้าตาของแอปวิดีโอแชทที่ดีที่สุดในโลกไหม ดู AppRTC ซึ่งเป็นแอป Canonical ของโปรเจ็กต์ WebRTC สำหรับการโทร WebRTC: แอป, โค้ด เวลาในการตั้งค่าการโทรน้อยกว่า 500 มิลลิวินาที

แนวทางปฏิบัติแนะนำ

  • หากต้องการให้โค้ดใช้งานได้ในอนาคต ให้ใช้ API ใหม่ที่อิงตาม Promise และเปิดใช้ความเข้ากันได้กับเบราว์เซอร์ที่ไม่รองรับ API ดังกล่าวโดยใช้ adapter.js

รายการถัดไป

ขั้นตอนนี้แสดงวิธีใช้ WebRTC เพื่อสตรีมวิดีโอระหว่างเพียร์ แต่ Codelab นี้ยังเกี่ยวกับข้อมูลด้วย

ในขั้นตอนถัดไป ให้ดูวิธีสตรีมข้อมูลที่กำหนดเองโดยใช้ RTCDataChannel

6. ใช้ RTCDataChannel เพื่อแลกเปลี่ยนข้อมูล

สิ่งที่คุณจะได้เรียนรู้

  • วิธีแลกเปลี่ยนข้อมูลระหว่างอุปกรณ์ปลายทาง WebRTC (เพียร์)

เวอร์ชันที่สมบูรณ์ของขั้นตอนนี้อยู่ในโฟลเดอร์ step-03

อัปเดต HTML

ในขั้นตอนนี้ คุณจะใช้ช่องทางข้อมูล WebRTC เพื่อส่งข้อความระหว่างองค์ประกอบ textarea 2 รายการในหน้าเดียวกัน ซึ่งอาจไม่ค่อยมีประโยชน์นัก แต่ก็แสดงให้เห็นว่า 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 กดเริ่มเพื่อตั้งค่าการเชื่อมต่อเพียร์ ป้อนข้อความใน textarea ทางด้านซ้าย แล้วคลิกส่งเพื่อโอนข้อความโดยใช้ช่องทางข้อมูล 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 Developer Network

คะแนนโบนัส

  1. เมื่อใช้ SCTP ซึ่งเป็นโปรโตคอลที่ช่องทางข้อมูล WebRTC ใช้ ระบบจะเปิดใช้การนำส่งข้อมูลที่เชื่อถือได้และเป็นระเบียบโดยค่าเริ่มต้น เมื่อใดที่ RTCDataChannel อาจต้องส่งข้อมูลที่เชื่อถือได้ และเมื่อใดที่ประสิทธิภาพอาจมีความสำคัญมากกว่า แม้ว่าจะหมายถึงการสูญเสียข้อมูลบางส่วนก็ตาม
  2. ใช้ CSS เพื่อปรับปรุงเลย์เอาต์หน้าเว็บ และเพิ่มแอตทริบิวต์ตัวยึดตำแหน่งลงในพื้นที่ข้อความ "dataChannelReceive"
  3. ทดสอบหน้าเว็บบนอุปกรณ์เคลื่อนที่

สิ่งที่คุณได้เรียนรู้

ในขั้นตอนนี้ คุณได้เรียนรู้วิธีทำสิ่งต่อไปนี้

  • สร้างการเชื่อมต่อระหว่างเพียร์ WebRTC 2 รายการ
  • แลกเปลี่ยนข้อมูลข้อความระหว่างเพียร์

เวอร์ชันสมบูรณ์ของขั้นตอนนี้อยู่ในโฟลเดอร์ step-03

ดูข้อมูลเพิ่มเติม

รายการถัดไป

คุณได้เรียนรู้วิธีแลกเปลี่ยนข้อมูลระหว่างเพียร์ในหน้าเดียวกันแล้ว แต่จะทำอย่างไรระหว่างเครื่องที่ต่างกัน ก่อนอื่น คุณต้องตั้งค่าช่องทางการส่งสัญญาณเพื่อแลกเปลี่ยนข้อความข้อมูลเมตา ดูวิธีได้ในขั้นตอนถัดไป

7. ตั้งค่าบริการส่งสัญญาณเพื่อแลกเปลี่ยนข้อความ

สิ่งที่คุณจะได้เรียนรู้

ในขั้นตอนนี้ คุณจะได้ทราบวิธีทำสิ่งต่อไปนี้

  • ใช้ npm เพื่อติดตั้งทรัพยากร Dependency ของโปรเจ็กต์ตามที่ระบุไว้ใน package.json
  • เรียกใช้เซิร์ฟเวอร์ Node.js และใช้ node-static เพื่อแสดงไฟล์แบบคงที่
  • ตั้งค่าบริการรับส่งข้อความใน Node.js โดยใช้ Socket.IO
  • ใช้ฟีเจอร์ดังกล่าวเพื่อสร้าง "ห้อง" และแลกเปลี่ยนข้อความ

เวอร์ชันที่สมบูรณ์ของขั้นตอนนี้อยู่ในโฟลเดอร์ step-04

แนวคิด

ในการตั้งค่าและรักษาการโทร WebRTC ไคลเอ็นต์ WebRTC (เพียร์) จะต้องแลกเปลี่ยนข้อมูลเมตาต่อไปนี้

  • ข้อมูลผู้สมัคร (เครือข่าย)
  • ข้อความข้อเสนอและคำตอบที่ให้ข้อมูลเกี่ยวกับสื่อ เช่น ความละเอียดและตัวแปลงรหัส

กล่าวคือ ต้องมีการแลกเปลี่ยนข้อมูลเมตาก่อนจึงจะสตรีมเสียง วิดีโอ หรือข้อมูลแบบเพียร์ทูเพียร์ได้ กระบวนการนี้เรียกว่าการส่งสัญญาณ

ในขั้นตอนก่อนหน้า ออบเจ็กต์ RTCPeerConnection ของผู้ส่งและผู้รับจะอยู่ในหน้าเดียวกัน ดังนั้น "การส่งสัญญาณ" จึงเป็นเรื่องของการส่งข้อมูลเมตาระหว่างออบเจ็กต์

ในแอปพลิเคชันจริง RTCPeerConnection ของผู้ส่งและผู้รับจะทำงานในหน้าเว็บบนอุปกรณ์ที่ต่างกัน และคุณต้องมีวิธีให้ทั้ง 2 ฝ่ายสื่อสารข้อมูลเมตา

ซึ่งคุณจะต้องใช้เซิร์ฟเวอร์การส่งสัญญาณ ซึ่งเป็นเซิร์ฟเวอร์ที่สามารถส่งข้อความระหว่างไคลเอ็นต์ WebRTC (เพียร์) ได้ ข้อความจริงเป็นข้อความธรรมดา ซึ่งก็คือออบเจ็กต์ JavaScript ที่แปลงเป็นสตริง

ข้อกำหนดเบื้องต้น: ติดตั้ง Node.js

หากต้องการเรียกใช้ขั้นตอนถัดไปของ Codelab นี้ (โฟลเดอร์ step-04 ถึง step-06) คุณจะต้องเรียกใช้เซิร์ฟเวอร์ใน Localhost โดยใช้ Node.js

คุณสามารถดาวน์โหลดและติดตั้ง Node.js ได้โดยตรงจากเว็บไซต์ Node.js หรือใช้เครื่องมือจัดการแพ็กเกจที่ต้องการ

เมื่อติดตั้งแล้ว คุณจะสามารถนำเข้าทรัพยากร Dependency ที่จำเป็นสำหรับขั้นตอนถัดไป (เรียกใช้ npm install) รวมถึงเรียกใช้เซิร์ฟเวอร์ Localhost ขนาดเล็กเพื่อเรียกใช้ Codelab (เรียกใช้ node index.js) ระบบจะระบุคำสั่งเหล่านี้ในภายหลังเมื่อจำเป็น

เกี่ยวกับแอป

WebRTC ใช้ JavaScript API ฝั่งไคลเอ็นต์ แต่สำหรับการใช้งานจริงยังต้องใช้เซิร์ฟเวอร์การส่งสัญญาณ (การรับส่งข้อความ) รวมถึงเซิร์ฟเวอร์ STUN และ TURN ด้วย ดูข้อมูลเพิ่มเติมเกี่ยวกับโครงสร้างพื้นฐาน WebRTC

ในขั้นตอนนี้ คุณจะสร้างเซิร์ฟเวอร์การส่งสัญญาณ Node.js แบบง่ายโดยใช้โมดูล Node.js ของ Socket.IO และไลบรารี JavaScript สำหรับการรับส่งข้อความ ประสบการณ์การใช้งาน Node.js และ Socket.IO จะเป็นประโยชน์ แต่ไม่จำเป็น เนื่องจากคอมโพเนนต์การรับส่งข้อความนั้นตรงไปตรงมา

ในตัวอย่างนี้ เซิร์ฟเวอร์ (แอปพลิเคชัน Node.js) จะติดตั้งใช้งานใน index.js และไคลเอ็นต์ที่ทำงานบนเซิร์ฟเวอร์ (เว็บแอป) จะติดตั้งใช้งานใน index.html

แอปพลิเคชัน Node.js ในขั้นตอนนี้มีงาน 2 อย่าง

ประการแรก ทำหน้าที่เป็นรีเลย์ข้อความ

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

ประการที่ 2 คือจัดการ "ห้อง" วิดีโอแชท 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 ของเราจะอนุญาตให้แชร์ห้องได้สูงสุด 2 เพียร์

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

นี่คือไฟล์ Manifest ของแอปที่บอก Node Package Manager (npm) ว่าต้องติดตั้งทรัพยากร Dependency ของโปรเจ็กต์ใดบ้าง

หากต้องการติดตั้งทรัพยากร Dependency (เช่น /socket.io/socket.io.js) ให้เรียกใช้คำสั่งต่อไปนี้จากเทอร์มินัลบรรทัดคำสั่งในไดเรกทอรี work

npm install

คุณควรเห็นบันทึกการติดตั้งที่ลงท้ายด้วยข้อความลักษณะนี้

คุณจะเห็นว่า npm ได้ติดตั้งทรัพยากร Dependency ที่กำหนดไว้ใน 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 ในแท็บหรือหน้าต่างที่ 3 เลือกชื่อห้องเดิมอีกครั้ง

ตรวจสอบคอนโซลในแต่ละแท็บ คุณควรเห็นการบันทึกจากโค้ด JavaScript ก่อนหน้า

คะแนนโบนัส

  1. กลไกการรับส่งข้อความทางเลือกใดบ้างที่อาจเป็นไปได้ คุณอาจพบปัญหาใดบ้างเมื่อใช้ WebSocket "ล้วน"
  2. ปัญหาใดที่อาจเกี่ยวข้องกับการปรับขนาดแอปพลิเคชันนี้ คุณสามารถพัฒนาวิธีการทดสอบคำขอห้องพักพร้อมกันหลายพันหรือหลายล้านรายการได้ไหม
  3. แอปนี้ใช้พรอมต์ JavaScript เพื่อรับชื่อห้อง หาวิธีรับชื่อห้องจาก URL เช่น localhost:8080/foo จะให้ชื่อห้องเป็น foo

สิ่งที่คุณได้เรียนรู้

ในขั้นตอนนี้ คุณได้เรียนรู้วิธีทำสิ่งต่อไปนี้

  • ใช้ npm เพื่อติดตั้งทรัพยากร Dependency ของโปรเจ็กต์ตามที่ระบุไว้ใน package.json
  • เรียกใช้เซิร์ฟเวอร์ Node.js เพื่อแสดงไฟล์แบบคงที่
  • ตั้งค่าบริการรับส่งข้อความใน Node.js โดยใช้ socket.io
  • ใช้ฟีเจอร์ดังกล่าวเพื่อสร้าง "ห้อง" และแลกเปลี่ยนข้อความ

เวอร์ชันที่สมบูรณ์ของขั้นตอนนี้อยู่ในโฟลเดอร์ step-04

ดูข้อมูลเพิ่มเติม

รายการถัดไป

ดูวิธีใช้การส่งสัญญาณเพื่อเปิดใช้การเชื่อมต่อแบบเพียร์ทูเพียร์ระหว่างผู้ใช้ 2 คน

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 นี้จากไดเรกทอรีงาน คุณอาจต้องติดตั้งทรัพยากร Dependency สำหรับโฟลเดอร์ step-05 หรือโฟลเดอร์ที่ใช้งานอยู่ในปัจจุบัน เรียกใช้คำสั่งต่อไปนี้จากไดเรกทอรีที่ทำงานอยู่

npm install

เมื่อติดตั้งแล้ว หากเซิร์ฟเวอร์ Node.js ไม่ทำงาน ให้เริ่มเซิร์ฟเวอร์โดยเรียกใช้คำสั่งต่อไปนี้ในไดเรกทอรี work

node index.js

ตรวจสอบว่าคุณใช้ index.js เวอร์ชันจากขั้นตอนก่อนหน้าที่ใช้ Socket.IO ดูข้อมูลเพิ่มเติมเกี่ยวกับ Node และ Socket IO ได้ที่ส่วน "ตั้งค่าบริการส่งสัญญาณเพื่อแลกเปลี่ยนข้อความ"

เปิด localhost:8080 จากเบราว์เซอร์

เปิด localhost:8080 อีกครั้งในแท็บหรือหน้าต่างใหม่ องค์ประกอบวิดีโอหนึ่งจะแสดงสตรีมในเครื่องจาก getUserMedia() และอีกองค์ประกอบหนึ่งจะแสดงวิดีโอ "ระยะไกล" ที่สตรีมโดยใช้ RTCPeerconnection

ดูการบันทึกในคอนโซลของเบราว์เซอร์

แต้มโบนัส

  1. แอปพลิเคชันนี้รองรับเฉพาะวิดีโอแชทแบบตัวต่อตัว คุณจะเปลี่ยนการออกแบบอย่างไรเพื่อให้ผู้ใช้มากกว่า 1 คนแชร์ห้องวิดีโอแชทเดียวกันได้
  2. ตัวอย่างนี้มีชื่อห้อง foo ที่ฮาร์ดโค้ดไว้ วิธีใดเป็นวิธีที่ดีที่สุดในการเปิดใช้ชื่อห้องอื่นๆ
  3. ผู้ใช้จะแชร์ชื่อห้องแชทได้อย่างไร ลองสร้างทางเลือกอื่นนอกเหนือจากการแชร์ชื่อห้อง
  4. คุณจะเปลี่ยนแอปได้อย่างไร
  • ถ่ายภาพและรับข้อมูลจากภาพโดยใช้องค์ประกอบ Canvas
  • แลกเปลี่ยนข้อมูลรูปภาพกับผู้ใช้ระยะไกล

เวอร์ชันที่สมบูรณ์ของขั้นตอนนี้อยู่ในโฟลเดอร์ 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. เมื่อผู้ใช้คลิกปุ่มถ่ายภาพ ให้จับภาพสแนปชอต (เฟรมวิดีโอ) จากสตรีมวิดีโอและแสดงในองค์ประกอบ 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 นี้จากไดเรกทอรีงาน คุณอาจต้องติดตั้งทรัพยากร Dependency สำหรับโฟลเดอร์ step-06 หรือโฟลเดอร์ที่ใช้งานอยู่ในปัจจุบัน เพียงเรียกใช้คำสั่งต่อไปนี้จากไดเรกทอรีที่ทำงานอยู่

npm install

เมื่อติดตั้งแล้ว หากเซิร์ฟเวอร์ Node.js ไม่ทำงาน ให้เริ่มเซิร์ฟเวอร์โดยเรียกใช้คำสั่งต่อไปนี้จากไดเรกทอรี work

node index.js

ตรวจสอบว่าคุณใช้ index.js เวอร์ชันที่ใช้ Socket.IO และอย่าลืมรีสตาร์ทเซิร์ฟเวอร์ Node.js หากทำการเปลี่ยนแปลง ดูข้อมูลเพิ่มเติมเกี่ยวกับ Node และ Socket IO ได้ที่ส่วน "ตั้งค่าบริการส่งสัญญาณเพื่อแลกเปลี่ยนข้อความ"

หากจำเป็น ให้คลิกปุ่มอนุญาตเพื่ออนุญาตให้แอปใช้เว็บแคม

แอปจะสร้างรหัสห้องแบบสุ่มและเพิ่มรหัสนั้นลงใน URL เปิด URL จากแถบที่อยู่ในแท็บเบราว์เซอร์หรือหน้าต่างเบราว์เซอร์ใหม่

คลิกปุ่ม Snap & Send แล้วดูที่พื้นที่ขาเข้าในแท็บอื่นที่ด้านล่างของหน้า แอปจะโอนรูปภาพระหว่างแท็บ

คุณควรเห็นข้อความในลักษณะนี้

คะแนนโบนัส

  1. คุณจะเปลี่ยนโค้ดอย่างไรเพื่อให้แชร์ไฟล์ประเภทใดก็ได้

ดูข้อมูลเพิ่มเติม

  • MediaStream Image Capture API: API สำหรับการถ่ายภาพและควบคุมกล้อง ซึ่งจะพร้อมใช้งานในเบราว์เซอร์ของคุณเร็วๆ นี้
  • MediaRecorder API สำหรับบันทึกเสียงและวิดีโอ: เดโม, เอกสารประกอบ

สิ่งที่คุณได้เรียนรู้

  • วิธีถ่ายภาพและรับข้อมูลจากภาพโดยใช้องค์ประกอบ Canvas
  • วิธีแลกเปลี่ยนข้อมูลดังกล่าวกับผู้ใช้ระยะไกล

เวอร์ชันที่สมบูรณ์ของขั้นตอนนี้อยู่ในโฟลเดอร์ step-06

9. ขอแสดงความยินดี

คุณได้สร้างแอปเพื่อสตรีมวิดีโอและแลกเปลี่ยนข้อมูลแบบเรียลไทม์

สิ่งที่คุณได้เรียนรู้

ใน Codelab นี้ คุณได้เรียนรู้วิธีทำสิ่งต่อไปนี้

  • รับวิดีโอจากเว็บแคม
  • สตรีมวิดีโอด้วย RTCPeerConnection
  • สตรีมข้อมูลด้วย RTCDataChannel
  • ตั้งค่าบริการส่งสัญญาณเพื่อแลกเปลี่ยนข้อความ
  • รวมการเชื่อมต่อแบบเพียร์และการส่งสัญญาณ
  • ถ่ายภาพและแชร์โดยใช้ช่องทางข้อมูล

ขั้นตอนถัดไป

ดูข้อมูลเพิ่มเติม

  • แหล่งข้อมูลต่างๆ สำหรับการเริ่มต้นใช้งาน WebRTC มีให้บริการที่ webrtc.org