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.
Related
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
I need to communicate with an already connected (paired) device attached to my computer via JavaScript.
This is a Bluetooth device however it does NOT use 'low power technology' thus is currently inaccessible via WebBluetooth.
Is there any way to communicate with my device using a different method due to the fact that it is already paired with the computer? Maybe as some sort of serial connection?
Targeting support for Google Chrome.
Node.js or anything outside the realm of HTML5/JavaScript/Chrome Specific JavaScript will not be accepted as an answer. WebBluetooth already shows an example however my device does not use Low-Power-Bluetooth..
You will need to use something like NodeJS. Browsers cannot access hardware attached to the computer unless the browser provides an API for it or you have an app on the host machine that the browser communicates with.
I suggest learning NodeJS as it is a great language and considering you already know JS the syntax will be familiar.
There is a way. Look into pubnub IoT api for bi-dir nearby device communications:
https://www.pubnub.com/solutions/iot/
This is a solution for multiplayer gaming as well. JS api here:
https://www.pubnub.com/docs/web-javascript/pubnub-javascript-sdk
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've researched many node.js cloud hosts, yet I'm having trouble finding one that suits my needs. The host needs to have free service for as long as an application is in development (sandbox mode). It also needs to have a Windows client, and ease of use is a huge plus. If possible, I'd like the host to be out of beta.
Can anyone recommend a simple node.js host that meets my needs?
Have you checked out Azure hosting?
The host needs to have free service for as long as an application is in development (sandbox mode)
They're currently offering a 90-day free trial and they've spent some real effort making Node.js work with their platform.
It also needs to have a Windows client, and ease of use is a huge plus.
They have a socket.io example and an example of using their free Windows-based dev tools to get up and running.
If possible, I'd like the host to be out of beta.
Node.JS has yet to hit version 1.0. At some level the whole tool chain is beta. However, Windows Azure is paid for and supported. They have people actively working on both Node.JS and some drivers (such as SQL Server support). To me, that's as "non-beta" as you'll get right now.