Packt Video player

1.1 The Course Overview
Introducing the full outline from the course.
- Explain what WebRTC is and what makes it different, and give a further view of how it works
- Learn how to actually share your media with other people at any instance on the Web
- Using all the previous concepts, we’ll design and debug our first WebRTC application
Watch Video
Download
Last Viewed
1.2 What’s WebRTC?
A short introduction to WebRTC, its chronology, and some things we can do with it.
- Understanding what WebRTC is
- Going through some WebRTC applications
- Introducing the concept of DataChannel
Watch Video
Download
Last Viewed
1.3 WebRTC Versus Existing Technologies
We will analyze how WebRTC is different from older technologies such as Flash and Java, and the pros and cons of web apps versus desktop apps.
- Introduction to WebRTC and comparing it with Flash
- Understanding how webRTC is different from Java
- Comparing webRTC with desktop applications
Watch Video
Download
Last Viewed
1.4 Getting Your Programming Environment Ready
WebRTC requires a compatible web browser. A nice source code editor is recommended.
- Looking for a source code editor alternative
- Choosing a browser that has already implemented the main methods of WebRTC
- Understanding consideration servers if needed and signaling
Watch Video
Download
Last Viewed

2.1 The WebRTC Browser API
Introducing the basic elements of the API that will make communication using WebRTC possible.
- Introducing getUserMedia, the method for reaching media streams from your computer
- Understanding the PeerConnection object, the createOffer and createAnswer methods, and negotiation between the peers
- Going through ICE, TURN, STUN—because a P2P connection won't be enough for going through some Internet barriers
Watch Video
Download
Last Viewed
2.2 Using the getUserMedia API
Checking a basic example of calling the GetUserMedia method on Chrome, keeping in mind that some browsers may not have the functionality or the standard notation.
- Understanding the differences between namespaces in browsers
- Writing an HTML document with a JavaScript, calling the getUserMedia method, and putting the streams on an HTML5 video element
- Understanding why this won’t work by itself, as Chrome requires it to be launched on a server(NodeJS, for instance)
Watch Video
Download
Last Viewed
2.3 Using the PeerConnection Method
Another example referring to the way the implied peers tell each other which capabilities, parameters, and other sets can be used.
- Introduction to SDP and how it adapts to WebRTC necessities
- createOffer, the SDP being created, and negotiation between peers
- createAnswer, the SDP being created, and negotiation between peers
Watch Video
Download
Last Viewed
2.4 Using the Session Description Protocol
SDPs and other pieces of information about sessions are needed to go through firewalls and NAT routers, which translate between private and public IPs.
- ICE is used to find out which network interfaces from each peer are available for sending offers and answers
- Since private IP addresses and firewalls have to be avoided, TURN and STUN have to be used to make a link between peers properly
- Using a signaling server in order to start all the mentioned processes
Watch Video
Download
Last Viewed

3.1 Understanding the Need for a Signaling Protocol
WebRTC doesn’t provide signaling by itself—is this a good thing or a bad one?
- Going through the arguments for standardizing a signaling protocol with WebRTC
- Debating against standardizing a signaling protocol with WebRTC
- Conclusions
Watch Video
Download
Last Viewed
3.2 Knowing the Various Signaling Approaches
SIPoWS, XMPPoWS, and JSONoWS are the different protocols that can work with WebRTC, providing signaling.
- Incorporating SIPoWS using SIP, a protocol for exchanging information related to establishing a multimedia exchange session
- Incorporating XMPPoWS using XMPP, the popular instant messaging protocol
- Incorporating JSONoWS based on JSON, the usual JavaScript object notation
Watch Video
Download
Last Viewed
3.3 Need of Signaling Protocol
We come back to the reasons we gave for using signaling (connecting the peers before negotiation), and we explain how signaling solves the problem.
- Understanding bi-directional, HTTPS, Delegated to the app
- Learning about IP exchange, session control, and keys for secure connections
- Discussing events in general related to calls, registering calling events, and registering into a signaling server where our information will be saved
Watch Video
Download
Last Viewed
3.4 Programming a Very Simple Node.js Signaling Server
We will use an example called signalmaster, available at the GitHub repository: https://github.com/andyet/signalmaster/.
- Analyzing the code and looking for the functionalities mentioned before
- Testing the code
- Putting the pieces together and programming a full WebRTC application
Watch Video
Download
Last Viewed

4.1 Initiating a WebRTC Session
Introducing the example. Node.js and socket.io as tools for the example. Getting our media and creating a room.
- Introducing the codelab example — a WebRTC git repository with progressive examples
- Talking about Node.js as an application server and socket.io as a provider of signaling methods
- Taking a look in the code where the local media is asked for and the room is created
Watch Video
Download
Last Viewed
4.2 Receiving a WebRTC Session
Joining a room. Sending SDPs as offer and answer. Then, negotiating ICE candidates.
- Looking into the code, we go back to where the last video ended, to continue the signaling process
- Diving into SDP negotiation, createOffer, and the createAnswer code
- Discussing ICE candidates and how they’re handled, and analyzing the SDP
Watch Video
Download
Last Viewed
4.3 Establishing Our First Session
We will establish a connection and discuss changes for a generic solution, and introducing DataChannels along the way.
- Testing the example to see that it currently works
- Enumerating some changes that our app needs to be reachable through the Web
Watch Video
Download
Last Viewed

5.1 Introducing the Debugging Tools
Introducing the main tools available for debugging WebRTC apps.
- Taking a look at Developer’s tool—a console inside the browser
- Understanding WebRTC internals and the Chrome and Firefox tabs for monitoring streams
- Taking a look at WebRTC internals in our app, before we focus on how to use each of them
Watch Video
Download
Last Viewed
5.2 The Developer Tools
Exploring the JavaScript console inside your browser
- Reading errors, warnings, logs, or any message that our app or the browser can transmit
- Surfing the HTML elements and changing the style and dynamic code
- Going through the recording of events and accessing the code and breakpoints
Watch Video
Download
Last Viewed
5.3 Using WebRTC Internals
Using the Chrome and Firefox internal tabs to monitor WebRTC streams
- Peeking into the Chrome WebRTC internals
- Checking out about:WebRTC in Firefox
Watch Video
Download
Last Viewed

Developing Real Time Applications with WebRTC

Section 1: Introduction to WebRTC

Section 2: The WebRTC API

Section 3: Signaling

Section 4: Putting It All Together — Your First Application

Section 5: Debugging and Improving Our Application

1.1 The Course Overview

1.2 What’s WebRTC?

1.3 WebRTC Versus Existing Technologies

1.4 Getting Your Programming Environment Ready

2.1 The WebRTC Browser API

2.2 Using the getUserMedia API

2.3 Using the PeerConnection Method

2.4 Using the Session Description Protocol

3.1 Understanding the Need for a Signaling Protocol

3.2 Knowing the Various Signaling Approaches

3.3 Need of Signaling Protocol

3.4 Programming a Very Simple Node.js Signaling Server

4.1 Initiating a WebRTC Session

4.2 Receiving a WebRTC Session

4.3 Establishing Our First Session

5.1 Introducing the Debugging Tools

5.2 The Developer Tools

5.3 Using WebRTC Internals