I want to create a Peer to Peer connection with two browsers without using existing code (mostly). I want to implement the server infrastructure by myself, as well as the client code.
There is just one issue, WebRTC seems to be everywhere.
Don't get me wrong, I'd use it, but since this is for a school project I have to implement almost everything by myself.
Looking at the WebRTC source code, I expected some Javascript implementations of existing components, however, all I ended up seeing is very complex C++ code that is intended for web browser developers.
Is it possible to implement a Peer to Peer connection between two browsers without using WebRTC?
For security reasons browsers do not allow you to make UDP and TCP requests yourself. You need to use one of the 3 protocols provided by browsers
HTTP
WebSockets
WebRTC
The C++ code you saw is the underlying implementation that browsers can use for WebRTC
Related
So, I have a web app that generates large buffers of color information that I want to send to a node application running on another machine in my local network. Web Sockets doesn't seem to be fast enough for me. I was looking to use UDP and it seems WebRTC is the only way to do that from a browser. The caveat, it seems, is WebRTC is only PEER to PEER (browser to browser). I figured, I could use node webkit to emulate being my other "PEER". In my node app I could handle the "signaling" and have it set itself up in a RTCPeerConnection to my web app. Therefore, I could send my data from my web app to my node app (local network). For some context, I have one computer running native software to drive a light fixture and I want to use a web app to control the lights.
To boil the question down, how can I make a RTCPeerConnection from a browser to a node webkit app?
Any help would greatly appreciated.
Thank you!
-Jake
Node-RTCPeerConnection is an attempt (current WIP) to create a spec compliant implementation of RTCPeerConnection for Node.js entirely in JavaScript with no native C or C++ code. This enables browser-peers to speak to non-browser (Node.js) peers.
But you can not use it for production yet.
Then we also have wrtc (node-webrtc) that provides a native module for NodeJS that supports a subset of standards-compliant WebRTC features. Specifically, the PeerConnection and DataChannel APIs.
Too many people are having problems with wrtc. Since it has to download lots of source and build it only to find out that it fails after a long while on certain platforms. Unfortunately it doesn't come with any prebuilt packages described in this issue
You can use either the google implementation of webrtc or a more recent implementation (by Ericsson) called openWebrtc. The developers of openWebRTC are very proud of running their implementation on various pieces of hardware like raspberry pi and iOS devices.
The one that worked best for me was electron-webrtc (which in turn uses electron-prebuilt) for better compatibility. It creates a hidden Electron process (which is based on Chromium, so WebRTC support is great!) and communicates with that process to enable WebRTC in Node.js. This adds a lot of overhead.
It is intended for use with RTCDataChannels, so the MediaStream API is not supported.
Other resources:
https://github.com/webrtcftw/goals/issues/1
Update 2019
Currently, the best and easiest way to solve this problem is to use webrtc module. Check samples for inspiration. This module does what you were looking for, implemented with N-API and using Canvas module to compose new video from the client stream. Hopefully this will help those who face this problem in the future.
Signaling plays an important role in WebRTC but is not standardized, allowing the developer to choose. This lack of standardization and multiple options has resulted in some confusion. A number of different signaling approaches have been proposed and used, and an understanding of the differences between the approaches is useful in selecting the right one for a given WebRTC application. So the questions arrise
How to select a protocol for signaling between the server and end-points in a
P2P media intensive app like video chat app?
WebRTC DataChannel vs XMLHttpRequest vs WebSockets ? Maybe something else?
How and when to choose one over another?
Signaling is the process of setting up a session between two parties. Because DataChannel depends on having a peer connection already established, you cannot use it for signaling (at least not for the initial setup). Although if you really wanted to, you could implement a DataChannel signaling solution to handle any later changes in configuration, like if one client wants to add another video stream. This post discusses this more in-depth. Whether or not the effort involved to build and maintain this is up to you to decide.
HTTP and WebSockets will both work fine in this scenario, and I don't think one would offer any significant advantage over the other. WebSockets is technically lighter, but the signaling process is brief and doesn't involve much data transfer.
I'd recommend using something like socket.io, which abstracts away the differences between the two protocols and automatically handles upgrading and downgrading.
What modules are in existence to use node.js as a peer in WebRTC? I'd like to use WebRTC in a more client/server fashion than P2P for its apparent ability to send packets unreliably. (AKA, I don't want the huge delay TCP makes by guaranteeing packet arrival with data in order)
If I have to use a stripped-down browser page as a server, that would perhaps work... however, it would really be sub-optimal. Node.js would make things much smoother, and probably more reliable too.
Thanks!
Have a look at the Erizo component of Licode (WebRTC MCU). It has a stream controller and webrtc controller written in c++ with a js interface. It might help you getting a idea or two.
There is now a Node implementation of WebRTC, with the exception of MediaStreams.
https://github.com/js-platform/node-webrtc
There is a c++ interface for WebRTC. WebRTC is based on the libjingle project but uses the JSEP (Javascript Session Establishment Protocol) instead of XMPP for sending STUN/TURN information for NAT tunneling. The two projects were in the process of being merged when I looked at this a while back so compiling/linking it was a PITA. This may have been improved last year.
The goal would be to expose the native API for WebRTC as a node module with the node addon api and package it as an npm module that works like the in-browser API. The cross-browser polyfill will show you how it should look.
There's a lot of cool stuff you could do with this (call recording, SIP connectors, .torrent extensions to the browser, etc.) I really encourage you to try this!
The most relevant package i've found was http://js-platform.github.io/node-webrtc/ i managed to build it and play with it a little bit... The developer is very helpful, i think it's your best bet right now
The solution is to use libjingle or licode/erizo. Both of them require compilation but erizo provides a NodeJS interface. Libjingle was created by Google.
Unfortunately, you have to compile each library and there are no binary packages for Debian, Ubuntu or other platforms.
Take a look at PeerJS: Simple peer-to-peer with WebRTC.
You need PeerJS-server for signaling.
The guide: http://peerjs.com/
I used Node js with socket io and have success with it
There are many tutorials online
There is a javascript code residing in my Android app's webkit container. This code makes use of WebSockets to communicate with the server. The same JS code works in other platforms such as iOS, but in Android 2.3, it doesn't. I read somewhere that the webkit in Android does not support WebSockets, and support will come only in Jelly Bean onwards.
In view of this, I need to provide a wrapper from the native layer (in Java) making use of plain sockets. From the little I know about sockets, it seems straightforward to support the usual APIs such as open(), send(), receive(), etc.
Is there anything else I need to know that the WebSocket protocol needs, which I will need to provide from the wrapper code? After all, the server talks to the client (my android app) as if it is a WebSocket, and not a native socket.
Some notes to consider: a) I cannot make use of any third-party library - it will have to be developed in-house. b) There will not be any binary data transferred; only text.
Thanks,
Rajath
Websockets are not raw sockets, they require an initial handshake then simple per-message framing. See the protocol spec for details. The sections on handshake and data framing will be most relevant.
I know you said you can't use third party libraries but be aware that projects like Java-Websocket might be interesting to you. It's liberally licensed so suitable for inclusion in any closed source app. Or you might find it useful as a reference while debugging your own code.
I need to deal with breaking connections and other standard things which are not handled by WebSockets yet. Something tells me that there must be plenty of plugins to do this. Do you use anything like that or write your own routines?
I need it for the client side, since I use Sinatra on the server side.
There are two common issues at hand: supporting older browsers that don't natively support WebSockets and automatic reconnect (in case of breaking connections).
Older browsers are supported by several vendors and products through emulation using different transports - what you need to look at is how good the emulation is. Here's a brief article on the topic describing the problem and Kaazing's solution [disclaimer: I work for Kaazing].
The Kaazing WebSocket Gateway also provides automatic reconnect - in case the connection breaks.
You can download the free developer version of the Kaazing Gateway - to give it a try.