WebRTC के साथ रीयल टाइम कम्यूनिकेशन

1. परिचय

WebRTC एक ओपन सोर्स प्रोजेक्ट है. इसकी मदद से, वेब और खास ऐप्लिकेशन में ऑडियो, वीडियो, और डेटा का रीयल-टाइम कम्यूनिकेशन किया जा सकता है.

WebRTC में कई JavaScript एपीआई होते हैं — डेमो देखने के लिए लिंक पर क्लिक करें.

  • getUserMedia(): ऑडियो और वीडियो कैप्चर करना.
  • MediaRecorder: ऑडियो और वीडियो रिकॉर्ड करना.
  • RTCPeerConnection: उपयोगकर्ताओं के बीच ऑडियो और वीडियो स्ट्रीम करना.
  • RTCDataChannel: उपयोगकर्ताओं के बीच डेटा स्ट्रीम करना.

WebRTC का इस्तेमाल कहां किया जा सकता है?

Firefox, Opera, और डेस्कटॉप और Android पर Chrome में. WebRTC, iOS और Android पर नेटिव ऐप्लिकेशन के लिए भी उपलब्ध है.

सिग्नलिंग क्या है?

WebRTC, ब्राउज़र के बीच स्ट्रीमिंग डेटा शेयर करने के लिए RTCPeerConnection का इस्तेमाल करता है. हालांकि, इसे कम्यूनिकेशन को मैनेज करने और कंट्रोल मैसेज भेजने के लिए भी एक सिस्टम की ज़रूरत होती है. इस प्रोसेस को सिग्नलिंग कहा जाता है. WebRTC, सिग्नल भेजने के तरीकों और प्रोटोकॉल के बारे में नहीं बताता. इस कोडलैब में, मैसेज भेजने के लिए Socket.IO का इस्तेमाल किया जाएगा. हालांकि, इसके कई विकल्प मौजूद हैं.

STUN और TURN क्या हैं?

WebRTC को पीयर-टू-पीयर काम करने के लिए डिज़ाइन किया गया है, ताकि उपयोगकर्ता सबसे सीधे रास्ते से कनेक्ट कर सकें. हालांकि, WebRTC को असल दुनिया की नेटवर्किंग से निपटने के लिए बनाया गया है: क्लाइंट ऐप्लिकेशन को NAT गेटवे और फ़ायरवॉल को पार करना पड़ता है. साथ ही, डायरेक्ट कनेक्शन काम न करने पर, पीयर-टू-पीयर नेटवर्किंग को फ़ॉलबैक की ज़रूरत होती है. इस प्रोसेस के तहत, WebRTC एपीआई आपके कंप्यूटर का आईपी पता पाने के लिए, STUN सर्वर का इस्तेमाल करते हैं. साथ ही, पीयर-टू-पीयर कम्यूनिकेशन न होने पर, TURN सर्वर का इस्तेमाल रिले सर्वर के तौर पर करते हैं. (WebRTC in the real world में इसके बारे में ज़्यादा जानकारी दी गई है.)

क्या WebRTC सुरक्षित है?

WebRTC के सभी कॉम्पोनेंट के लिए, एन्क्रिप्शन ज़रूरी है. साथ ही, इसके JavaScript एपीआई का इस्तेमाल सिर्फ़ सुरक्षित ऑरिजिन (एचटीटीपीएस या लोकलहोस्ट) से किया जा सकता है. सिग्नलिंग मैकेनिज़्म, WebRTC के स्टैंडर्ड के हिसाब से तय नहीं किए जाते. इसलिए, यह पक्का करना आपकी ज़िम्मेदारी है कि सुरक्षित प्रोटोकॉल का इस्तेमाल किया जाए.

2. खास जानकारी

एक ऐसा ऐप्लिकेशन बनाएं जो आपके वेबकैम से वीडियो और स्नैपशॉट ले सके. साथ ही, WebRTC का इस्तेमाल करके उन्हें पीयर-टू-पीयर शेयर कर सके. इस दौरान, आपको WebRTC के मुख्य एपीआई इस्तेमाल करने और Node.js का इस्तेमाल करके, मैसेज सेवा देने वाला सर्वर सेट अप करने का तरीका पता चलेगा.

आपको क्या सीखने को मिलेगा

  • अपने वेबकैम से वीडियो रिकॉर्ड करना
  • RTCPeerConnection की मदद से वीडियो स्ट्रीम करना
  • RTCDataChannel की मदद से डेटा स्ट्रीम करना
  • मैसेज एक्सचेंज करने के लिए, सिग्नलिंग सेवा सेट अप करना
  • पीयर कनेक्शन और सिग्नलिंग को जोड़ना
  • फ़ोटो लेना और उसे डेटा चैनल की मदद से शेयर करना

आपको किन चीज़ों की ज़रूरत होगी

  • Chrome 47 या इसके बाद का वर्शन
  • Web Server for Chrome या अपनी पसंद का कोई वेब सर्वर इस्तेमाल करें.
  • सैंपल कोड
  • टेक्स्ट एडिटर
  • एचटीएमएल, सीएसएस, और JavaScript की बुनियादी जानकारी

3. सैंपल कोड पाना

कोड डाउनलोड करें

अगर आपको Git के बारे में जानकारी है, तो GitHub से इस कोडलैब का कोड डाउनलोड किया जा सकता है. इसके लिए, इसे क्लोन करें:

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

इसके अलावा, कोड की .zip फ़ाइल डाउनलोड करने के लिए, इस बटन पर क्लिक करें:

डाउनलोड की गई ZIP फ़ाइल खोलें. इससे एक प्रोजेक्ट फ़ोल्डर (adaptive-web-media) अनपैक हो जाएगा. इसमें इस कोडलैब के हर चरण के लिए एक फ़ोल्डर होगा. साथ ही, इसमें वे सभी संसाधन होंगे जिनकी आपको ज़रूरत होगी.

आपको कोडिंग का सारा काम work नाम की डायरेक्ट्री में करना होगा.

step-nn फ़ोल्डर में, इस कोडलैब के हर चरण का पूरा वर्शन मौजूद होता है. ये रेफ़रंस के लिए हैं.

वेब सर्वर इंस्टॉल करना और उसकी पुष्टि करना

आपके पास अपने वेब सर्वर का इस्तेमाल करने का विकल्प है. हालांकि, यह कोडलैब, Chrome वेब सर्वर के साथ अच्छी तरह से काम करने के लिए डिज़ाइन किया गया है. अगर आपने अब तक वह ऐप्लिकेशन इंस्टॉल नहीं किया है, तो उसे Chrome Web Store से इंस्टॉल किया जा सकता है.

Web Server for Chrome ऐप्लिकेशन इंस्टॉल करने के बाद, बुकमार्क बार, नए टैब पेज या ऐप्लिकेशन लॉन्चर से Chrome ऐप्लिकेशन के शॉर्टकट पर क्लिक करें:

वेब सर्वर आइकॉन पर क्लिक करें:

इसके बाद, आपको यह डायलॉग दिखेगा. इसकी मदद से, अपने लोकल वेब सर्वर को कॉन्फ़िगर किया जा सकता है:

फ़ोल्डर चुनें बटन पर क्लिक करें. इसके बाद, अभी-अभी बनाया गया work फ़ोल्डर चुनें. इससे आपको Chrome में अपने काम की प्रोग्रेस देखने में मदद मिलेगी. इसके लिए, वेब सर्वर यूआरएल सेक्शन में, वेब सर्वर डायलॉग में हाइलाइट किए गए यूआरएल का इस्तेमाल करें.

विकल्प में जाकर, index.html अपने-आप दिखाएं के बगल में मौजूद बॉक्स को चुनें, जैसा कि यहां दिखाया गया है:

इसके बाद, सर्वर को बंद करके रीस्टार्ट करें. इसके लिए, वेब सर्वर: चालू है लेबल वाले टॉगल को बाईं ओर स्लाइड करें और फिर वापस दाईं ओर स्लाइड करें.

अब हाइलाइट किए गए वेब सर्वर यूआरएल पर क्लिक करके, अपने वेब ब्राउज़र में अपनी वर्क साइट पर जाएं. आपको इस तरह का एक पेज दिखेगा, जो work/index.html से जुड़ा है:

ज़ाहिर है कि यह ऐप्लिकेशन अभी तक कुछ भी दिलचस्प नहीं कर रहा है. अब तक, यह सिर्फ़ एक बुनियादी ढांचा है, जिसका इस्तेमाल हम यह पक्का करने के लिए कर रहे हैं कि आपका वेब सर्वर ठीक से काम कर रहा है. अगले चरणों में, आपको फ़ंक्शन और लेआउट की सुविधाएं जोड़ने का विकल्प मिलेगा.

4. वेबकैम से वीडियो स्ट्रीम करना

आपको क्या सीखने को मिलेगा

इस चरण में आपको इनके बारे में जानकारी मिलेगी:

  • अपने वेबकैम से वीडियो स्ट्रीम करना.
  • स्ट्रीम के प्लेबैक में बदलाव करना.
  • वीडियो में बदलाव करने के लिए, सीएसएस और एसवीजी का इस्तेमाल करें.

इस चरण का पूरा वर्शन, step-01 फ़ोल्डर में है.

एचटीएमएल का इस्तेमाल...

अपनी work डायरेक्ट्री में मौजूद index.html में, video एलिमेंट और script एलिमेंट जोड़ें:

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

अपने js फ़ोल्डर में मौजूद main.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;
}

बोनस पॉइंट

  • getUserMedia() को पास किया गया localStream ऑब्जेक्ट, ग्लोबल स्कोप में है. इसलिए, इसे ब्राउज़र कंसोल से जांचा जा सकता है: कंसोल खोलें, stream टाइप करें, और Return दबाएं. (Chrome में कंसोल देखने के लिए, Ctrl-Shift-J दबाएं. अगर Mac का इस्तेमाल किया जा रहा है, तो Command-Option-J दबाएं.)
  • localStream.getVideoTracks() से क्या मिलता है?
  • localStream.getVideoTracks()[0].stop() को कॉल करके देखें.
  • कंस्ट्रेंट ऑब्जेक्ट देखें: इसे {audio: true, video: true} में बदलने पर क्या होता है?
  • वीडियो एलिमेंट का साइज़ क्या है? JavaScript से वीडियो का नैचुरल साइज़ कैसे पाया जा सकता है, जो डिसप्ले साइज़ से अलग होता है? जांच करने के लिए, Chrome DevTools का इस्तेमाल करें.
  • वीडियो एलिमेंट में सीएसएस फ़िल्टर जोड़कर देखें. उदाहरण के लिए:
video {
  filter: blur(4px) invert(1) opacity(0.5);
}
  • एसवीजी फ़िल्टर जोड़कर देखें. उदाहरण के लिए:
video {
   filter: hue-rotate(180deg) saturate(200%);
 }

आपको क्या सीखने को मिला

इस चरण में आपने यह सीखा:

  • अपने वेबकैम से वीडियो कैप्चर करें.
  • मीडिया से जुड़ी पाबंदियां सेट करें.
  • वीडियो एलिमेंट में बदलाव करना.

इस चरण का पूरा वर्शन, step-01 फ़ोल्डर में है.

सलाह

  • video एलिमेंट पर autoplay एट्रिब्यूट का इस्तेमाल करना न भूलें. इसके बिना, आपको सिर्फ़ एक फ़्रेम दिखेगा!
  • getUserMedia() की पाबंदियों के लिए कई और विकल्प मौजूद हैं. webrtc.github.io/samples/src/content/peerconnection/constraints पर जाकर डेमो देखें. जैसा कि आपको दिखेगा, उस साइट पर WebRTC के कई दिलचस्प सैंपल मौजूद हैं.

सबसे सही तरीका

  • पक्का करें कि आपका वीडियो एलिमेंट, अपने कंटेनर से बाहर न निकले. हमने width और max-width को जोड़ा है, ताकि वीडियो के लिए पसंदीदा साइज़ और ज़्यादा से ज़्यादा साइज़ सेट किया जा सके. ब्राउज़र, ऊंचाई का हिसाब अपने-आप लगा लेगा:
video {
  max-width: 100%;
  width: 320px;
}

अगला सेक्शन

आपके पास वीडियो है, लेकिन उसे स्ट्रीम कैसे करें? अगले चरण में जानें!

5. RTCPeerConnection की मदद से वीडियो स्ट्रीम करना

आपको क्या सीखने को मिलेगा

इस चरण में आपको इनके बारे में जानकारी मिलेगी:

  • WebRTC शिम, adapter.js की मदद से, ब्राउज़र के बीच के अंतर को कम करें.
  • वीडियो स्ट्रीम करने के लिए, RTCPeerConnection API का इस्तेमाल करना.
  • मीडिया कैप्चर और स्ट्रीमिंग को कंट्रोल करना.

इस चरण का पूरा वर्शन, step-2 फ़ोल्डर में मौजूद है.

RTCPeerConnection क्या है?

RTCPeerConnection एक एपीआई है. इसका इस्तेमाल, वीडियो और ऑडियो स्ट्रीम करने और डेटा शेयर करने के लिए, 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 का इस्तेमाल करके स्ट्रीम किया गया है. (असल दुनिया के ऐप्लिकेशन में, एक वीडियो एलिमेंट लोकल स्ट्रीम दिखाएगा और दूसरा रिमोट स्ट्रीम.)

adapter.js शिम जोड़ना

main.js के लिंक के ऊपर, adapter.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. इसका ज़्यादा इस्तेमाल नहीं किया जाता है. हालांकि, एपीआई के काम करने का तरीका दिखाने के लिए यह अच्छा है.

WebRTC पीयर के बीच कॉल सेट अप करने के लिए, ये तीन टास्क पूरे करने होते हैं:

  • कॉल के हर एंड के लिए एक RTCPeerConnection बनाएं. साथ ही, हर एंड पर getUserMedia() से लोकल स्ट्रीम जोड़ें.
  • नेटवर्क की जानकारी पाना और शेयर करना: संभावित कनेक्शन एंडपॉइंट को ICE कैंडिडेट कहा जाता है.
  • लोकल और रिमोट ब्यौरे पाना और शेयर करना: एसडीपी फ़ॉर्मैट में लोकल मीडिया का मेटाडेटा.

मान लें कि ऐलिस और बॉब को वीडियो चैट सेट अप करने के लिए, RTCPeerConnection का इस्तेमाल करना है.

सबसे पहले, Alice और Bob नेटवर्क की जानकारी शेयर करते हैं. 'उम्मीदवारों को ढूंढना' वाक्यांश का मतलब, ICE फ़्रेमवर्क का इस्तेमाल करके नेटवर्क इंटरफ़ेस और पोर्ट ढूंढने की प्रोसेस से है.

  1. ऐलिस, onicecandidate (addEventListener('icecandidate')) हैंडलर की मदद से RTCPeerConnection ऑब्जेक्ट बनाती है. यह main.js के इस कोड से मेल खाता है:
let localPeerConnection;
localPeerConnection = new RTCPeerConnection(servers);
localPeerConnection.addEventListener('icecandidate', handleConnection);
localPeerConnection.addEventListener(
    'iceconnectionstatechange', handleConnectionChange);
  1. ऐलिस, 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 हैंडलर को कॉल किया जाता है.
  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 पीयर को लोकल और रिमोट ऑडियो और वीडियो मीडिया की जानकारी का पता लगाने और उसे शेयर करने की भी ज़रूरत होती है. जैसे, रिज़ॉल्यूशन और कोडेक की क्षमताएं. मीडिया कॉन्फ़िगरेशन की जानकारी को एक्सचेंज करने के लिए सिग्नल भेजने की प्रोसेस, मेटाडेटा के ब्लॉब को एक्सचेंज करके पूरी की जाती है. इन्हें ऑफ़र और जवाब कहा जाता है. इसके लिए, सेशन डिस्क्रिप्शन प्रोटोकॉल फ़ॉर्मैट का इस्तेमाल किया जाता है, जिसे एसडीपी कहा जाता है:

  1. मयंक, RTCPeerConnection createOffer() तरीके का इस्तेमाल करता है. वापस किया गया प्रॉमिस, RTCSessionDescription उपलब्ध कराता है: ऐलिस के लोकल सेशन की जानकारी:
trace('localPeerConnection createOffer start.');
localPeerConnection.createOffer(offerOptions)
  .then(createdOffer).catch(setSessionDescriptionError);
  1. अगर यह प्रोसेस पूरी हो जाती है, तो Alice setLocalDescription() का इस्तेमाल करके लोकल ब्यौरा सेट करती है. इसके बाद, वह अपने सिग्नलिंग चैनल का इस्तेमाल करके, Bob को सेशन का यह ब्यौरा भेजती है.
  2. ऋतिक, setRemoteDescription() का इस्तेमाल करके, मयंक से मिले ब्यौरे को रिमोट ब्यौरे के तौर पर सेट करता है.
  3. बॉब, RTCPeerConnection createAnswer() तरीके का इस्तेमाल करता है. इसमें वह ऐलिस से मिली रिमोट जानकारी को पास करता है, ताकि ऐलिस के सेशन के साथ काम करने वाला लोकल सेशन जनरेट किया जा सके. 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 के आंकड़े और डीबग करने का डेटा मिलता है. (Chrome के यूआरएल की पूरी सूची chrome://about पर मौजूद है.)
  2. सीएसएस की मदद से पेज को स्टाइल करें:
  • वीडियो को अगल-बगल रखें.
  • बटन की चौड़ाई एक जैसी रखें और टेक्स्ट का साइज़ बड़ा करें.
  • पक्का करें कि लेआउट, मोबाइल पर काम करता हो.
  1. Chrome DevTools कंसोल में, localStream, localPeerConnection, और remotePeerConnection देखें.
  2. कंसोल में, localPeerConnectionpc1.localDescription देखें. एसडीपी फ़ॉर्मैट कैसा दिखता है?

आपको क्या सीखने को मिला

इस चरण में आपने यह सीखा:

  • WebRTC शिम, adapter.js की मदद से, ब्राउज़र के बीच के अंतर को कम करें.
  • वीडियो स्ट्रीम करने के लिए, RTCPeerConnection API का इस्तेमाल करना.
  • मीडिया कैप्चर और स्ट्रीमिंग को कंट्रोल करना.
  • WebRTC कॉल की सुविधा चालू करने के लिए, पीयर के बीच मीडिया और नेटवर्क की जानकारी शेयर करना.

इस चरण का पूरा वर्शन, step-2 फ़ोल्डर में मौजूद है.

सलाह

  • इस चरण में सीखने के लिए बहुत कुछ है! RTCPeerConnection के बारे में ज़्यादा जानकारी देने वाले अन्य संसाधन ढूंढने के लिए, webrtc.org पर जाएं. इस पेज पर JavaScript फ़्रेमवर्क के लिए सुझाव दिए गए हैं. अगर आपको WebRTC का इस्तेमाल करना है, लेकिन एपीआई को मैनेज नहीं करना है, तो ये सुझाव आपके काम आ सकते हैं.
  • adapter.js GitHub रिपॉज़िटरी से, adapter.js शिम के बारे में ज़्यादा जानें.
  • क्या आपको दुनिया का सबसे बेहतरीन वीडियो चैट ऐप्लिकेशन देखना है? WebRTC कॉल के लिए, WebRTC प्रोजेक्ट के कैननिकल ऐप्लिकेशन, AppRTC को देखें: ऐप्लिकेशन, कोड. कॉल सेटअप करने में 500 मिलीसेकंड से कम समय लगता है.

सबसे सही तरीका

  • अपने कोड को आने वाले समय के लिए तैयार करने के लिए, Promise पर आधारित नए एपीआई का इस्तेमाल करें. साथ ही, adapter.js का इस्तेमाल करके, उन ब्राउज़र के साथ काम करने की सुविधा चालू करें जो इन एपीआई के साथ काम नहीं करते.

अगला सेक्शन

इस चरण में, पीयर के बीच वीडियो स्ट्रीम करने के लिए WebRTC का इस्तेमाल करने का तरीका बताया गया है. हालांकि, यह कोडलैब डेटा के बारे में भी है!

अगले चरण में, RTCDataChannel का इस्तेमाल करके आर्बिट्रेरी डेटा स्ट्रीम करने का तरीका जानें.

6. डेटा शेयर करने के लिए RTCDataChannel का इस्तेमाल करना

आपको क्या सीखने को मिलेगा

  • WebRTC एंडपॉइंट (पीयर) के बीच डेटा एक्सचेंज करने का तरीका.

इस चरण का पूरा वर्शन, step-03 फ़ोल्डर में मौजूद है.

एचटीएमएल अपडेट करना

इस चरण के लिए, आपको WebRTC डेटा चैनलों का इस्तेमाल करना होगा, ताकि एक ही पेज पर मौजूद दो textarea एलिमेंट के बीच टेक्स्ट भेजा जा सके. यह बहुत काम का नहीं है, लेकिन इससे पता चलता है कि WebRTC का इस्तेमाल, डेटा शेयर करने के साथ-साथ वीडियो स्ट्रीम करने के लिए कैसे किया जा सकता है.

index.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 में कुछ टेक्स्ट डालें. इसके बाद, WebRTC डेटा चैनलों का इस्तेमाल करके टेक्स्ट ट्रांसफ़र करने के लिए, Send पर क्लिक करें.

यह कैसे काम करता है

यह कोड, टेक्स्ट मैसेज शेयर करने के लिए 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. WebRTC डेटा चैनलों में इस्तेमाल होने वाले प्रोटोकॉल SCTP में, भरोसेमंद और क्रम से डेटा डिलीवर करने की सुविधा डिफ़ॉल्ट रूप से चालू होती है. RTCDataChannel को डेटा की भरोसेमंद डिलीवरी की ज़रूरत कब पड़ सकती है? साथ ही, परफ़ॉर्मेंस ज़्यादा अहम कब हो सकती है — भले ही, इसके लिए कुछ डेटा खोना पड़े?
  2. पेज के लेआउट को बेहतर बनाने के लिए, सीएसएस का इस्तेमाल करें. साथ ही, "dataChannelReceive" टेक्स्टएरिया में प्लेसहोल्डर एट्रिब्यूट जोड़ें.
  3. पेज को किसी मोबाइल डिवाइस पर टेस्ट करें.

आपको क्या सीखने को मिला

इस चरण में आपने यह सीखा:

  • दो WebRTC पीयर के बीच कनेक्शन बनाना.
  • पीयर के बीच टेक्स्ट डेटा शेयर करना.

इस चरण का पूरा वर्शन, step-03 फ़ोल्डर में मौजूद है.

ज़्यादा जानें

अगला सेक्शन

आपने एक ही पेज पर मौजूद पीयर के बीच डेटा शेयर करने का तरीका सीख लिया है. हालांकि, अलग-अलग मशीनों के बीच ऐसा कैसे किया जाता है? सबसे पहले, आपको मेटाडेटा मैसेज को एक्सचेंज करने के लिए, एक सिग्नलिंग चैनल सेट अप करना होगा. अगले चरण में इसका तरीका जानें!

7. मैसेज भेजने और पाने के लिए, सिग्नलिंग सेवा सेट अप करना

आपको क्या सीखने को मिलेगा

इस चरण में, आपको इनके बारे में जानकारी मिलेगी:

  • package.json में बताई गई प्रोजेक्ट डिपेंडेंसी इंस्टॉल करने के लिए, npm का इस्तेमाल करें
  • Node.js सर्वर चलाएं और स्टैटिक फ़ाइलें दिखाने के लिए, node-static का इस्तेमाल करें.
  • Socket.IO का इस्तेमाल करके, Node.js पर मैसेज सेवा सेट अप करना.
  • इसका इस्तेमाल करके, ‘रूम' बनाए जा सकते हैं और मैसेज भेजे जा सकते हैं.

इस चरण का पूरा वर्शन, step-04 फ़ोल्डर में है.

कॉन्सेप्ट

WebRTC कॉल को सेट अप करने और उसे बनाए रखने के लिए, WebRTC क्लाइंट (पीयर) को मेटाडेटा शेयर करना ज़रूरी है:

  • उम्मीदवार (नेटवर्क) की जानकारी.
  • ऑफ़र और जवाब वाले मैसेज, जो मीडिया के बारे में जानकारी देते हैं. जैसे, रिज़ॉल्यूशन और कोडेक.

दूसरे शब्दों में, ऑडियो, वीडियो या डेटा की पीयर-टू-पीयर स्ट्रीमिंग से पहले, मेटाडेटा को शेयर करना ज़रूरी है. इस प्रोसेस को सिग्नलिंग कहा जाता है.

पिछले चरणों में, भेजने वाले और पाने वाले के RTCPeerConnection ऑब्जेक्ट एक ही पेज पर होते हैं. इसलिए, ‘सिग्नलिंग' का मतलब ऑब्जेक्ट के बीच मेटाडेटा पास करना है.

असल दुनिया में, भेजने वाले और पाने वाले का RTCPeerConnection, अलग-अलग डिवाइसों पर वेब पेजों में चलता है. साथ ही, आपको मेटाडेटा कम्यूनिकेट करने के लिए कोई तरीका चाहिए.

इसके लिए, सिग्नलिंग सर्वर का इस्तेमाल किया जाता है: यह एक ऐसा सर्वर है जो WebRTC क्लाइंट (पीयर) के बीच मैसेज भेज सकता है. असल मैसेज, सादे टेक्स्ट होते हैं: स्ट्रिंगिफ़ाइड JavaScript ऑब्जेक्ट.

ज़रूरी शर्त: Node.js इंस्टॉल करें

इस कोडलैब के अगले चरणों (फ़ोल्डर step-04 से step-06) को पूरा करने के लिए, आपको Node.js का इस्तेमाल करके लोकलहोस्ट पर सर्वर चलाना होगा.

Node.js को सीधे Node.js की वेबसाइट से या अपने पसंदीदा पैकेज मैनेजर का इस्तेमाल करके डाउनलोड और इंस्टॉल किया जा सकता है.

इंस्टॉल होने के बाद, अगले चरणों के लिए ज़रूरी डिपेंडेंसी इंपोर्ट की जा सकेंगी (npm install चलाकर). साथ ही, कोड लैब को चलाने के लिए एक छोटा लोकलहोस्ट सर्वर चलाया जा सकेगा (node index.js चलाकर). ये कमांड बाद में बताए जाएंगे, जब इनकी ज़रूरत होगी.

ऐप्लिकेशन के बारे में जानकारी

WebRTC, क्लाइंट-साइड JavaScript API का इस्तेमाल करता है. हालांकि, असल दुनिया में इस्तेमाल के लिए, इसे सिग्नल (मैसेज सेवा) सर्वर के साथ-साथ STUN और TURN सर्वर की भी ज़रूरत होती है. WebRTC इन्फ़्रास्ट्रक्चर के बारे में ज़्यादा जानें.

इस चरण में, आपको Socket.IO Node.js मॉड्यूल और मैसेज सेवा के लिए JavaScript लाइब्रेरी का इस्तेमाल करके, एक आसान Node.js सिग्नलिंग सर्वर बनाना होगा. 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 ऐप्लिकेशन में, एक रूम में ज़्यादा से ज़्यादा दो लोग शामिल हो सकते हैं.

एचटीएमएल और 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 दबाएं. अगर Mac का इस्तेमाल किया जा रहा है, तो Command-Option-J दबाएं.)

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

Node.js पर चलाने के लिए, Socket.IO को सेट अप करना

एचटीएमएल फ़ाइल में, आपको Socket.IO फ़ाइल का इस्तेमाल करते हुए देखा जा सकता है:

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

अपनी वर्क डायरेक्ट्री के टॉप लेवल पर, package.json नाम की एक फ़ाइल बनाएं. इसमें यह कॉन्टेंट शामिल करें:

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

यह एक ऐप्लिकेशन मेनिफ़ेस्ट है, जो Node Package Manager (npm) को बताता है कि कौनसी प्रोजेक्ट डिपेंडेंसी इंस्टॉल करनी हैं.

/socket.io/socket.io.js जैसे डिपेंडेंसी इंस्टॉल करने के लिए, अपनी वर्क डायरेक्ट्री में, कमांड लाइन टर्मिनल से यह कमांड चलाएं:

npm install

आपको इंस्टॉलेशन लॉग दिखना चाहिए, जो कुछ इस तरह खत्म होता है:

जैसा कि आप देख सकते हैं, npm ने package.json में तय की गई डिपेंडेंसी इंस्टॉल कर ली हैं.

अपनी work डायरेक्ट्री के टॉप लेवल पर, एक नई फ़ाइल index.js बनाएं. इसे 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 खोलें.

इस यूआरएल को खोलने पर, हर बार आपसे कमरे का नाम डालने के लिए कहा जाएगा. एक ही रूम में शामिल होने के लिए, हर बार एक ही रूम का नाम चुनें. जैसे, ‘foo'.

नया टैब पेज खोलें और localhost:8080 को फिर से खोलें. कमरे का वही नाम चुनें.

तीसरे टैब या विंडो में localhost:8080 खोलें. रूम का वही नाम फिर से चुनें.

हर टैब में कंसोल देखें: आपको पिछले JavaScript कोड से लॉगिंग दिखनी चाहिए.

बोनस पॉइंट

  1. मैसेज भेजने के लिए, अन्य कौनसे तरीके इस्तेमाल किए जा सकते हैं? ‘प्योर' WebSocket का इस्तेमाल करने पर, आपको कौनसी समस्याएं आ सकती हैं?
  2. इस ऐप्लिकेशन को बड़े पैमाने पर इस्तेमाल करने में क्या समस्याएं आ सकती हैं? क्या आपके पास एक साथ हज़ारों या लाखों रूम के अनुरोधों को टेस्ट करने का कोई तरीका है?
  3. यह ऐप्लिकेशन, रूम का नाम पाने के लिए JavaScript प्रॉम्प्ट का इस्तेमाल करता है. यूआरएल से रूम का नाम पाने का तरीका ढूंढें. उदाहरण के लिए, localhost:8080/foo से रूम का नाम foo मिलेगा.

आपको क्या सीखने को मिला

इस चरण में, आपने इनके बारे में जाना:

  • package.json में बताई गई प्रोजेक्ट डिपेंडेंसी इंस्टॉल करने के लिए, npm का इस्तेमाल करें.
  • स्टैटिक फ़ाइलों को सर्व करने के लिए, Node.js सर्वर चलाएं.
  • socket.io का इस्तेमाल करके, Node.js पर मैसेज सेवा सेट अप करना.
  • इसका इस्तेमाल करके, ‘रूम' बनाए जा सकते हैं और मैसेज भेजे जा सकते हैं.

इस चरण का पूरा वर्शन, step-04 फ़ोल्डर में है.

ज़्यादा जानें

अगला सेक्शन

सिग्नलिंग का इस्तेमाल करके, दो उपयोगकर्ताओं को पीयर कनेक्शन बनाने की सुविधा देने का तरीका जानें.

8. पीयर कनेक्शन और सिग्नलिंग को जोड़ना

आपको क्या सीखने को मिलेगा

इस चरण में आपको इनके बारे में जानकारी मिलेगी:

  • Node.js पर चल रहे Socket.IO का इस्तेमाल करके, WebRTC सिग्नलिंग सेवा चलाना
  • इस सेवा का इस्तेमाल, पीयर के बीच WebRTC मेटाडेटा को एक्सचेंज करने के लिए करें.

इस चरण का पूरा वर्शन, step-05 फ़ोल्डर में मौजूद है.

एचटीएमएल और 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 सर्वर को चलाना

अगर आपने इस कोडलैब को अपनी वर्क डायरेक्ट्री से फ़ॉलो नहीं किया है, तो आपको 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 के कॉन्टेंट से बदलें. work में मौजूद आपकी 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>

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

अगर आपने अपनी वर्क डायरेक्ट्री से इस कोडलैब को फ़ॉलो नहीं किया है, तो आपको step-06 फ़ोल्डर या अपने मौजूदा वर्किंग फ़ोल्डर के लिए डिपेंडेंसी इंस्टॉल करनी पड़ सकती हैं. अपनी वर्किंग डायरेक्ट्री से यह कमांड चलाएं:

npm install

इंस्टॉल होने के बाद, अगर आपका Node.js सर्वर नहीं चल रहा है, तो अपनी work डायरेक्ट्री से यह कमांड देकर इसे चालू करें:

node index.js

पक्का करें कि आपने index.js के उस वर्शन का इस्तेमाल किया हो जो Socket.IO को लागू करता है. साथ ही, अगर आपने कोई बदलाव किया है, तो अपने Node.js सर्वर को रीस्टार्ट करना न भूलें. Node और Socket IO के बारे में ज़्यादा जानने के लिए, "मैसेज एक्सचेंज करने के लिए सिग्नल सेवा सेट अप करना" सेक्शन देखें.

अगर ज़रूरी हो, तो ऐप्लिकेशन को वेबकैम इस्तेमाल करने की अनुमति देने के लिए, अनुमति दें बटन पर क्लिक करें.

ऐप्लिकेशन, रैंडम रूम आईडी बनाएगा और उसे यूआरएल में जोड़ देगा. पता बार में मौजूद यूआरएल को नए ब्राउज़र टैब या विंडो में खोलें.

Snap & Send बटन पर क्लिक करें. इसके बाद, पेज पर सबसे नीचे मौजूद दूसरे टैब में, Incoming सेक्शन पर जाएं. ऐप्लिकेशन, टैब के बीच फ़ोटो ट्रांसफ़र करता है.

आपको कुछ ऐसा दिखेगा:

बोनस पॉइंट

  1. किसी भी फ़ाइल टाइप को शेयर करने के लिए, कोड में कैसे बदलाव किया जा सकता है?

ज़्यादा जानें

  • MediaStream Image Capture API: यह फ़ोटो लेने और कैमरे को कंट्रोल करने के लिए एक एपीआई है. यह जल्द आ रहा है!
  • ऑडियो और वीडियो रिकॉर्ड करने के लिए, MediaRecorder API: डेमो, दस्तावेज़.

आपको क्या सीखने को मिला

  • फ़ोटो लेने और कैनवस एलिमेंट का इस्तेमाल करके, उससे डेटा पाने का तरीका.
  • उस डेटा को किसी रिमोट उपयोगकर्ता के साथ कैसे शेयर किया जाए.

इस चरण का पूरा वर्शन, step-06 फ़ोल्डर में मौजूद है.

9. बधाई हो

आपने रीयल टाइम में वीडियो स्ट्रीम करने और डेटा शेयर करने के लिए एक ऐप्लिकेशन बनाया है!

आपको क्या सीखने को मिला

इस कोडलैब में आपने ये बातें सीखीं:

  • अपने वेबकैम से वीडियो कैप्चर करें.
  • RTCPeerConnection की मदद से वीडियो स्ट्रीम करना.
  • RTCDataChannel की मदद से डेटा स्ट्रीम करना.
  • मैसेज भेजने और पाने के लिए, सिग्नलिंग सेवा सेट अप करें.
  • पीयर कनेक्शन और सिग्नलिंग को जोड़ें.
  • फ़ोटो लेना और उसे डेटा चैनल का इस्तेमाल करके शेयर करना.

अगले चरण

ज़्यादा जानें

  • WebRTC का इस्तेमाल शुरू करने के लिए, webrtc.org पर कई संसाधन उपलब्ध हैं.