peer-connector

A module to accept and request WebRTC multi connections by using WebSockets.
Simple WebRTC video/voice/screen and data channels.

Installing

$ npm install peer-connector

Demo(sample test)

• example page

$ git clone https://github.com/goldenthumb/peer-connector.git
$ cd peer-connector
$ npm install
$ npm run dev
 
Now open this URL in your browser: http://localhost:3000/

Usage (basic)

Please refer to the file. (example/src/index.js)

import { 
    PeerConnector, 
    getMediaStream, 
    connectWebsocket, 
    Signal,
} from 'peer-connector';
 
(async () => {
    const stream = await getMediaStream({ video: true, audio: true });
    const peerConnector = new PeerConnector({ stream });
    const websocket = await connectWebsocket('ws://localhost:1234');
    const signal = new Signal({ websocket });
 
    signal.autoSignal(peerConnector);
 
    peerConnector.on('connect', (peer) => {
        // peer is generated each time WebRTC is connected.
        console.log('stream', peer.remoteStream);
 
        peer.on('open', (data) => {
            peer.send('open data channel');
        });
      
        peer.on('data', (data) => {
            console.log('data channel message', data);
        });
 
        peer.on('close', (data) => {
            console.log('close', data);
        });
    });
})();

Usage (custom)

You can implement the signaling logic as you wish. (Using websocket and MQTT or other)

import { 
    PeerConnector, 
    Peer, 
    getMediaStream, 
    connectWebsocket, 
    Signal, 
    SIGNAL_EVENT 
} from 'peer-connector';
 
(async () => {
    const stream = await getMediaStream(mediaType);
    const peerConnector = new PeerConnector();
    const websocket = await connectWebsocket('ws://localhost:1234');
    const signal = new Signal({ websocket });
 
    signal.send(SIGNAL_EVENT.JOIN);
 
    signal.on(SIGNAL_EVENT.JOIN, ({ sender }) => {
        signal.send(SIGNAL_EVENT.REQUEST_CONNECT, { receiver: sender });
    });
 
    signal.on(SIGNAL_EVENT.REQUEST_CONNECT, async ({ sender }) => {
        const peer = new Peer({ id: sender, stream });
        peerConnector.addPeer(peer);
 
        peer.createDataChannel(peerConnector.channelName);
 
        peer.on('iceCandidate', (candidate) => {
            signal.send(SIGNAL_EVENT.CANDIDATE, { 
                receiver: peer.id, 
                candidate, 
            });
        });
 
        signal.send(SIGNAL_EVENT.SDP, { 
            receiver: peer.id, 
            sdp: await peer.createOfferSdp(), 
        });
    });
 
    signal.on(SIGNAL_EVENT.SDP, async ({ sender, sdp }) => {
        if (sdp.type === 'answer') {
            const peer = peerConnector.getPeer(sender);
            await peer.setRemoteDescription(sdp);
        } else {
            const peer = new Peer({ id: sender, stream });
            peerConnector.addPeer(peer);
 
            peer.on('iceCandidate', (candidate) => {
                signal.send(SIGNAL_EVENT.CANDIDATE, { 
                    receiver: peer.id, 
                    candidate, 
                });
            });
 
            await peer.setRemoteDescription(sdp);
            signal.send(SIGNAL_EVENT.SDP, { 
                receiver: peer.id, 
                sdp: await peer.createAnswerSdp() 
            });
        }
    });
 
    signal.on(SIGNAL_EVENT.CANDIDATE, ({ sender, candidate }) => {
        const peer = peerConnector.getPeer(sender);
        peer.addIceCandidate(candidate);
    });
 
    peerConnector.on('connect', (peer) => {
        peer.on('open', (data) => {
            peer.send('open data channel');
        });
      
        peer.on('data', (data) => {
            console.log('data channel message', data);
        });
 
        peer.on('close', (data) => {
            console.log('close', data);
        });
    });
})();

API

getMediaStream

/**
 * @param {{ screen?: boolean, video?: boolean, audio?: boolean  }} options
 * @return {Promise<MediaStream>} 
*/
const stream = await getMediaStream(options);
 
// Desktop screen sharing. 
const stream = await getMediaStream({ screen: true });
 
// Video and audio sharing.
const stream = await getMediaStream({ video: true, audio: true });

PeerConnector

/**
 * @param {object} [options] 
 * @param {MediaStream} [options.stream] 
 * @param {RTCConfiguration} [options.config] 
 * @param {boolean} [options.channel] 
 * @param {string} [options.channelName] 
 * @param {RTCDataChannelInit} [options.channelConfig] 
 */
const peerConnector = new PeerConnector();

If opts is specified, then the default options (shown below) will be overridden.

{   
    stream: false,
    config: { iceServers: [{ urls: 'stun:stun.l.google.com:19302' }] },
    channel: true,
    channelName: '<random string>',
    channelConfig: {},
}

Name	type	Description
stream	prop	media local stream
peers	prop	connected peers
addPeer	method	add peer
removePeer	method	remove peer
hasPeer	method	has peer
getPeer	method	get peer
close	method	close media local stream
destroy	method	removes all listeners
connect	event	triggers when connect WebRTC

Peer

/**
 * @param {object} props 
 * @param {string} [props.id] 
 * @param {MediaStream} [props.stream] 
 * @param {RTCConfiguration} [props.config] 
 * @param {boolean} [props.channel] 
 */
const peer = new Peer();

If opts is specified, then the default options (shown below) will be overridden.

{   
    id: '<random string>',
    stream: false,
    config: { iceServers: [{ urls: 'stun:stun.l.google.com:19302' }] },
    channel: true,
}

Name	type	Description
id	prop	peer id
localSdp	prop	local sdp
localStream	prop	local media stream
remoteSdp	prop	remote sdp
remoteStream	prop	remote media stream
createOfferSdp	method	create offer and set local sdp
createAnswerSdp	method	create answer and set local sdp
createDataChannel	method	create data channel
setRemoteDescription	method	set remote sdp
addIceCandidate	method	add ice candidate
send	method	send data using data channel
close	method	peer close
destroy	method	removes all listeners
iceCandidate	event	triggers when candidates occur
changeIceState	event	triggers when oniceconnectionstatechange occur
open	event	triggers when data channel open
data	event	data received by data channel
close	event	triggers when ICE connection or data channel close
error	event	triggers when data channel error

Signal

/**
 * @param {object} props 
 * @param {WebSocket} props.websocket 
 * @param {string} [props.id] 
 */
const signal = new Signal();

If opts is specified, then the default options (shown below) will be overridden.

{   
    id: '<random string>',
}

Name	type	Description
id	prop	signal id
send	method	send message
autoSignal	method	auto signaling
destroy	method	removes all listeners
join	event	triggers When user join
requestConnect	event	triggers when connect request
sdp	event	triggers when user sdp
candidate	event	triggers when user candidate

License

MIT