@subiz/wsclient 3.1.8 → 4.0.0

package/common.js

@@ -0,0 +1,66 @@
+function dofetch(method, url, body, cb) {
+	let headers = {}
+	if (body) headers['content-type'] = 'text/plain'
+	fetch(url, {method: method, headers: headers, body: body})
+		.then((res) => res.text().then((text) => cb && cb(text, res.status)))
+		.catch((err) => cb && cb(err, -1))
+}
+
+// xhrsend sends an HTTP request
+var xhrsend = function (method, url, body, cb) {
+	if (typeof XMLHttpRequest === 'undefined') return dofetch(method, url, body, cb)
+	var request = new XMLHttpRequest()
+	request.onreadystatechange = function (e) {
+		if (request.readyState !== 4) return
+		cb && cb(request.responseText, request.status)
+		cb = undefined // dont call cb anymore
+	}
+
+	request.onerror = function () {
+		cb && cb(request.responseText, -1) // network error
+		cb = undefined // dont call cb anymore
+	}
+
+	request.open(method, url)
+	if (body) request.setRequestHeader('content-type', 'text/plain')
+	request.send(body)
+}
+
+// JSON.parse without exeption
+// return undefined when parsing invalid JSON string
+function parseJSON(str) {
+	try {
+		return JSON.parse(str)
+	} catch (e) {}
+}
+
+function Pubsub() {
+	// holds all subscriptions for all topics
+	// example {
+	//   topic1: [cb1, cb2],
+	//   topic2: [cb3, cb4],
+	// }
+	var listeners = {}
+
+	// emit notifies any callback functions that previously
+	// subscribed to the topic (by the on function)
+	this.emit = function (topic) {
+		// skip the first item in arguments, which is the topic
+		var args = []
+		for (var i = 1; i < arguments.length; i++) args.push(arguments[i])
+
+		var cbs = listeners[topic]
+		if (!cbs) return
+		for (var i = 0; i < cbs.length; i++) cbs[i].apply(undefined, args)
+	}
+
+	// register a callback function for a topic
+	// when something is sent to the topic (by the emit function),
+	// the callback function will be called
+	this.on = function (topic, cb) {
+		if (!listeners[topic]) listeners[topic] = []
+		listeners[topic].push(cb)
+	}
+}
+
+module.exports = {xhrsend, parseJSON, Pubsub}

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@subiz/wsclient",
-	"version": "3.1.8",
-	"main": "index.js",
+	"version": "4.0.0",
+	"main": "realtime.js",
 	"scripts": {
 		"test": "node realtime.test.js"
 	},

package/realtime.js

@@ -1,4 +1,5 @@
 var flow = require('@subiz/flow')
+var {xhrsend, parseJSON, Pubsub} = require('./common.js')
 
 // Conn represents a realtime connection between an user and the realtime
 // server (https://rt-0.subiz.com)
@@ -22,7 +23,7 @@ function Conn(apiUrl, credential, onDead, onEvents, callAPI) {
 	var lastToken = ''
 
 	// kill force the connection to dead state
-	this.kill = function() {
+	this.kill = function () {
 		dead = true
 	}
 
@@ -31,9 +32,9 @@ function Conn(apiUrl, credential, onDead, onEvents, callAPI) {
 	// exponential backoff algorithm. Polling loop will terminate if it encounter an
 	// un-retryable error
 	// the polling loop starts after the first subscribe call finished successfully
-	var polling = function(backoff) {
+	var polling = function (backoff) {
 		if (dead) return
-		callAPI('get', apiUrl + 'poll?token=' + lastToken, undefined, function(body, code) {
+		callAPI('get', apiUrl + 'poll?token=' + lastToken, undefined, function (body, code) {
 			if (dead) return
 			if (retryable(code)) return setTimeout(polling, calcNextBackoff(backoff), backoff + 1)
 			if (code !== 200) {
@@ -55,21 +56,26 @@ function Conn(apiUrl, credential, onDead, onEvents, callAPI) {
 		})
 	}
 
-	var subQueue = flow.batch(50, 100, function(events) {
+	var subQueue = flow.batch(50, 100, function (events) {
 		if (dead) return ['dead']
 		if (events.length <= 0) return []
 
 		var out = []
 		return flow
-			.loop(function() {
-				return new Promise(function(rs) {
+			.loop(function () {
+				return new Promise(function (rs) {
 					var query = '?token=' + lastToken
-					credential.getAccessToken().then(function(access_token) {
-						if (credential.user_ref) query += '&user-ref=' + encodeURIComponent(credential.user_ref)
+					credential.getAccessToken().then(function (access_token) {
+						if (credential.user_ref)
+							query +=
+								'&user_ref=' +
+								encodeURIComponent(credential.user_ref) +
+								'&account_id=' +
+								encodeURIComponent(credential.account_id)
 						else if (credential.user_mask) query += '&user-mask=' + encodeURIComponent(credential.user_mask)
 						else if (access_token) query += '&access-token=' + access_token
 
-						callAPI('post', apiUrl + 'subs' + query, JSON.stringify({events: events}), function(body, code) {
+						callAPI('post', apiUrl + 'subs' + query, JSON.stringify({events: events}), function (body, code) {
 							if (dead) {
 								out = repeat('dead', events.length)
 								return rs(false) // break loop
@@ -102,7 +108,7 @@ function Conn(apiUrl, credential, onDead, onEvents, callAPI) {
 					})
 				})
 			})
-			.then(function() {
+			.then(function () {
 				return out
 			})
 	})
@@ -124,7 +130,7 @@ function Realtime(apiUrls, credential, callAPI) {
 	if (typeof apiUrls === 'string' || apiUrls instanceof String) apiUrls = [apiUrls]
 	credential = credential || {}
 	if (!credential.getAccessToken) {
-		credential.getAccessToken = function() {
+		credential.getAccessToken = function () {
 			return Promise.resolve('')
 		}
 	}
@@ -141,22 +147,22 @@ function Realtime(apiUrls, credential, callAPI) {
 
 	// stop the connection
 	var stop = false
-	this.stop = function() {
+	this.stop = function () {
 		if (stop) return
 		stop = true
 		conn.kill()
 	}
 
-	this.onEvent = function(cb) {
+	this.onEvent = function (cb) {
 		return pubsub.on('event', cb)
 	}
 
-	this.onInterrupted = function(cb) {
+	this.onInterrupted = function (cb) {
 		return pubsub.on('interrupted', cb)
 	}
 
 	var conn
-	this.subscribe = function(events) {
+	this.subscribe = function (events) {
 		if (stop) return Promise.resolve({})
 		if (typeof events === 'string') events = [events]
 		if (!Array.isArray(events)) return Promise.resolve({error: 'param should be an array or string'})
@@ -169,7 +175,7 @@ function Realtime(apiUrls, credential, callAPI) {
 			if (!topics[topic]) all.push(conn.subscribe(topic))
 		}
 		if (all.length === 0) return Promise.resolve({})
-		return Promise.all(all).then(function(errs) {
+		return Promise.all(all).then(function (errs) {
 			for (var i = 0; i < errs.length; i++) if (errs[i]) return {error: errs[i]}
 			for (var j = 0; j < events.length; j++) topics[events[j]] = true
 			return {}
@@ -178,7 +184,7 @@ function Realtime(apiUrls, credential, callAPI) {
 
 	// reconnect make sure there is alway a Conn running in the background
 	// if the Conn is dead, it recreate a new one
-	var reconnect = function() {
+	var reconnect = function () {
 		if (stop) return
 		// reset subscribed topic
 		var allTopics = Object.keys(topics)
@@ -188,12 +194,12 @@ function Realtime(apiUrls, credential, callAPI) {
 		conn = new Conn(
 			randomUrl,
 			credential,
-			function(code, body, status) {
+			function (code, body, status) {
 				if (stop) return
 				pubsub.emit('interrupted', code, body, status)
 				setTimeout(reconnect, 2000) // reconnect and resubscribe after 2 sec
 			},
-			function(topics) {
+			function (topics) {
 				if (stop) return
 				for (var i = 0; i < topics.length; i++) pubsub.emit('event', topics[i])
 			},
@@ -207,74 +213,6 @@ function Realtime(apiUrls, credential, callAPI) {
 	reconnect()
 }
 
-var dofetch = function(method, url, body, cb) {
-	let headers = {}
-	if (body) headers['content-type'] = 'text/plain'
-	fetch(url, {
-		method: method,
-		headers: headers,
-		body: body,
-	})
-		.then((res) => res.text().then((text) => cb && cb(text, res.status)))
-		.catch((err) => cb && cb(err, -1))
-}
-// xhrsend sends an HTTP request
-var xhrsend = function(method, url, body, cb) {
-	if (typeof XMLHttpRequest === 'undefined') return dofetch(method, url, body, cb)
-	var request = new XMLHttpRequest()
-	request.onreadystatechange = function(e) {
-		if (request.readyState !== 4) return
-		cb && cb(request.responseText, request.status)
-		cb = undefined // dont call cb anymore
-	}
-
-	request.onerror = function() {
-		cb && cb(request.responseText, -1) // network error
-		cb = undefined // dont call cb anymore
-	}
-
-	request.open(method, url)
-	if (body) request.setRequestHeader('content-type', 'text/plain')
-	request.send(body)
-}
-
-// JSON.parse without exeption
-// return undefined when parsing invalid JSON string
-function parseJSON(str) {
-	try {
-		return JSON.parse(str)
-	} catch (e) {}
-}
-
-function Pubsub() {
-	// holds all subscriptions for all topics
-	// example {
-	//   topic1: [cb1, cb2],
-	//   topic2: [cb3, cb4],
-	// }
-	var listeners = {}
-
-	// emit notifies any callback functions that previously
-	// subscribed to the topic (by the on function)
-	this.emit = function(topic) {
-		// skip the first item in arguments, which is the topic
-		var args = []
-		for (var i = 1; i < arguments.length; i++) args.push(arguments[i])
-
-		var cbs = listeners[topic]
-		if (!cbs) return
-		for (var i = 0; i < cbs.length; i++) cbs[i].apply(undefined, args)
-	}
-
-	// register a callback function for a topic
-	// when something is sent to the topic (by the emit function),
-	// the callback function will be called
-	this.on = function(topic, cb) {
-		if (!listeners[topic]) listeners[topic] = []
-		listeners[topic].push(cb)
-	}
-}
-
 // calcNextBackoff returns number of seconds we must wait
 // before sending a next request
 // the results is determind based on exponential backoff algorithm

package/webrtc.js

@@ -0,0 +1,302 @@
+var flow = require('@subiz/flow')
+var {xhrsend} = require('./common.js')
+const servers = {
+	iceServers: [{urls: ['stun:stun.l.google.com:19302?transport=tcp']}],
+}
+
+// import {RTCPeerConnection, RTCIceCandidate, RTCSessionDescription, mediaDevices} from 'react-native-webrtc'
+// let connId = 'webrtc' + sb.randomString(20)
+// env = {RTCPeerConnection, RTCIceCandidate, RTCSessionDescription, setTimeout, setInterval, jsonify, parseJSON}
+// setting env._is_webrtc_local to true for local testing
+function WebRTCConn(options) {
+	let {apiUrl, access_token, accid, agid, connId, realtime, callAPI, env, onTrack, onEvent} = options
+	if (!apiUrl) {
+		apiUrl = 'https://callcenter.subiz.com.vn/wc/'
+		if (env._is_webrtc_local) apiUrl = 'http://localhost:8008/'
+	}
+
+	callAPI = callAPI || xhrsend // allow hook
+
+	let parseJSON = (str) => {
+		try {
+			return env.JSON.parse(str)
+		} catch (e) {}
+	}
+	let jsonify = (str) => {
+		try {
+			return env.JSON.stringify(str)
+		} catch (e) {}
+	}
+	let currentStream
+	let pendingStream
+	let activeCalls = {}
+
+	let subscribe = realtime.subscribe([
+		`webrtc.account.${accid}.agent.${agid}`,
+		`webrtc.account.${accid}.agent.${agid}.webrtc_connection.${connId}`,
+	])
+
+	let peer
+	// makeSure only returns when stream is added and negotiation is finished
+	// its safe to call this function multiple times at once
+	let makeSure = (cb) => {
+		initConnection()
+		subscribe.then(cb)
+	}
+
+	let checkIceConnected = (cb) =>
+		flow.loop(
+			() =>
+				new env.Promise((rs) => {
+					let pass = peer && (peer.iceConnectionState == 'connected' || peer.iceConnectionState == 'completed')
+					if (!pass) return env.setTimeout((_) => rs(true), 100) // keep looping ultil connected
+					cb && cb()
+					rs(false)
+				}),
+		)
+
+	let readyToSendCandidateResolve
+	let readyToSendCandidate = new env.Promise((rs) => (readyToSendCandidateResolve = rs))
+
+	let initConnection = () => {
+		let needConnect =
+			!peer ||
+			peer.connectionState === 'disconnected' ||
+			peer.connectionState === 'closed' ||
+			peer.connectionState === 'failed'
+
+		if (!needConnect) return
+		peer = new env.RTCPeerConnection(servers)
+		let mypeer = peer
+		window.peer = peer
+
+		readyToSendCandidate = new env.Promise((rs) => (readyToSendCandidateResolve = rs))
+
+		peer.ontrack = (event) => {
+			if (peer != mypeer) return // outdated
+			onTrack && onTrack(event)
+		}
+
+		peer.onicecandidate = (event) => {
+			if (!event.candidate) return
+			if (peer != mypeer) return // outdated
+			let url = `${apiUrl}ice-candidates?x-access-token=${access_token}&connection_id=${connId}`
+			callAPI('post', url, jsonify(event.candidate))
+		}
+
+		peer.onnegotiationneeded = (ev) => console.log('NNNEED RE-NEGOTIATION', ev)
+		console.log('NEW PERR')
+	}
+
+	let stopMic = () => {
+		console.log('00000000STOP TRACK', currentStream)
+		return
+		currentStream &&
+			currentStream.getTracks().forEach((track) => {
+				track.enabled = false
+			})
+	}
+
+	// auto tear down when byte received is zero
+	// use to clear peer when there's no byte sent around 100 seconds
+	let receivedBytes = []
+	let check = () => {
+		let url = `${apiUrl}calls?x-access-token=${access_token}&connection_id=${connId}`
+		callAPI('get', url, undefined, function (body, code) {
+			if (code == 200) {
+				body = parseJSON(body) || []
+				activeCalls = {}
+				body.map && body.map((call) => (activeCalls[call.call_id] = call))
+			}
+
+			if (!peer) return
+			peer.getStats(null).then((stats) => {
+				let statsOutput = ''
+				let receivedByte = 0
+				stats.forEach((report) => {
+					if (report.type === 'inbound-rtp' && report.kind === 'audio') {
+						receivedByte += report.bytesReceived || 0
+					}
+					if (report.type === 'inbound-rtp' && report.kind === 'video') {
+						receivedByte += report.bytesReceived || 0
+					}
+				})
+				receivedBytes.push(receivedByte)
+				while (receivedBytes.length > 10) receivedBytes.shift()
+				let diff = receivedBytes.filter((n) => n != receivedByte)
+				if (diff.length == 0 && receivedBytes.length >= 10 && Object.keys(activeCalls).length == 0) {
+					if (Object.keys(activeCalls).length == 0) stopMic()
+					// could tear down
+					peer.close()
+					peer = undefined
+				}
+			})
+		})
+	}
+	check()
+	env.setInterval(check, 30000)
+
+	let publish = (ev) => onEvent && onEvent(ev)
+
+	this.matchCall = (callid) => (!callid ? activeCalls : activeCalls[callid])
+
+	realtime.onEvent((ev) => {
+		if (!ev || !ev.type || !ev.data) return
+		// if (ev.type.startsWith('call')) console.log('EEEEEEE', ev)
+		if (env._is_webrtc_local && ev.user_id != '8') return // local
+		if (!env._is_webrtc_local && ev.user_id != '9') return // prod
+
+		if (ev.type == 'webrtc_candidate_added') {
+			let ice_candidate = ev.data.ice_candidate
+			if (!ice_candidate) return
+			return readyToSendCandidate.then(() => peer && peer.addIceCandidate(parseJSON(ice_candidate)))
+		}
+
+		if (ev.type == 'webrtc_negotiation_offered') {
+			console.log('RT/RECEIVE OFFERED NEGOTIATION', ev)
+			if (!peer) return
+			let negid = ev.id
+			if (!ev.data.ice_candidate) return
+			let offer = parseJSON(ev.data.ice_candidate)
+
+			peer
+				.setRemoteDescription(offer)
+				.then(() => {
+					readyToSendCandidateResolve()
+					if (pendingStream && pendingStream != currentStream) {
+						currentStream = pendingStream
+						currentStream.getTracks().forEach((track) => peer.addTrack(track, currentStream))
+					}
+					pendingStream = undefined
+					return peer.createAnswer()
+				})
+				.then((answer) =>
+					peer.setLocalDescription(answer).then(() => {
+						let url = `${apiUrl}finish?x-access-token=${access_token}&connection_id=${connId}&version=2&negotiation_id=${negid}`
+						callAPI('post', url, jsonify(answer), function (body, code) {
+							if (code !== 200) return console.error('CANNOT FINISH', body)
+							return
+						})
+					}),
+				)
+		}
+
+		let call_info = ev.data.call_info || {}
+		let callid = call_info.call_id
+		if (!callid) return
+
+		if (ev.type === 'call_invite_expired') {
+			activeCalls[callid] = call_info
+			let device_id = call_info.device_id
+			if (device_id == connId) return // ignore since we have accepted the call
+
+			publish(Object.assign({}, ev, {type: 'call_ended'})) // fake ended call
+			delete activeCalls[callid]
+		}
+		let type = ev.type
+		if (type == 'call_ended' || type == 'call_ringing' || type == 'call_joined' || type === 'call_invited') {
+			if (ev.type === 'call_invited' && agid == call_info.from_number) return // ignore our own invite
+			activeCalls[callid] = ev.data.call_info
+			return publish(ev)
+		}
+	})
+
+	this.makeCall = (number, fromnumber, stream) =>
+		new env.Promise((rs) => {
+			let callid = 'webcall-' + randomString(20)
+			this.joinCall(callid, stream, (err) => {
+				if (err) return rs({error: err})
+				let url = `${apiUrl}call?x-access-token=${access_token}&connection_id=${connId}&call_id=${callid}&number=${number}&from_number=${fromnumber}`
+				callAPI('post', url, undefined, (body, code) => {
+					if (code != 200) return rs({error: body})
+					body = parseJSON(body)
+					if (body) activeCalls[callid] = body
+					rs({body})
+				})
+			})
+		})
+
+	this.hangupCall = (callid) => {
+		if (!callid) return
+		let call = activeCalls[callid]
+		if (!call) {
+			call = {call_id: callid}
+			activeCalls[callid] = call
+		}
+		call.status = 'ended'
+		call.ended = env.Date.now()
+		callAPI('post', `${apiUrl}hangup?x-access-token=${access_token}&connection_id=${connId}&call_id=${callid}`)
+		publish({type: 'call_ended', data: {call_info: call}})
+	}
+
+	this.listenCall = (callid, cb) => {
+		let url = `${apiUrl}listen?x-access-token=${access_token}&connection_id=${connId}&call_id=${callid}`
+		makeSure(() => callAPI('post', url, undefined, (body, code) => (code != 200 ? cb(body) : cb())))
+	}
+
+	this.joinCall = (callid, stream, cb) => {
+		console.time('makecall' + callid)
+		makeSure(() => {
+			pendingStream = stream
+			let url = `${apiUrl}listen?x-access-token=${access_token}&connection_id=${connId}&call_id=${callid}`
+			callAPI('post', url, undefined, (body, code) => {
+				if (code != 200) return cb(body)
+				let url = `${apiUrl}join?x-access-token=${access_token}&connection_id=${connId}&call_id=${callid}`
+				callAPI('post', url, undefined, (body, code) => {
+					console.timeEnd('makecall' + callid)
+					if (code != 200) return cb(body)
+					checkIceConnected(() => cb())
+				})
+			})
+		})
+	}
+
+	this.answerCall = (callid, stream) =>
+		new env.Promise((rs) => {
+			this.joinCall(callid, stream, (err) => {
+				if (err) return rs({error: err})
+				let url = `${apiUrl}answer?x-access-token=${access_token}&connection_id=${connId}&call_id=${callid}`
+				callAPI('post', url, undefined, (body, code) => {
+					body = parseJSON(body)
+					return code != 200 ? rs({error: body}) : rs({body})
+				})
+			})
+		})
+
+	this.sendDtmf = (key, callid) =>
+		new env.Promise((rs) => {
+			if (!callid) return rs({body: {}})
+			let url = `${apiUrl}dtml?x-access-token=${access_token}&connection_id=${connId}&call_id=${callid}&key={key}`
+			makeSure(() =>
+				callAPI('post', url, undefined, (body, bode) => {
+					body = parseJSON(body)
+					return code != 200 ? rs({error: body}) : rs({body})
+				}),
+			)
+		})
+
+	this.transferCall = (tonumber, callid) =>
+		new env.Promise((rs) => {
+			if (!callid) return rs({})
+			let url = `${apiUrl}refer?x-access-token=${access_token}&connection_id=${connId}&call_id=${callid}&number={tonumber}`
+			makeSure(() =>
+				callAPI('post', url, undefined, (body, code) => {
+					body = parseJSON(body)
+					return code != 200 ? rs({error: body}) : rs({body})
+				}),
+			)
+		})
+}
+
+function randomString(len) {
+	var str = ''
+	if (!len || len < 1) len = 10
+	var asciiKey
+	for (var i = 0; i < len; i++) {
+		asciiKey = Math.floor(Math.random() * 25 + 97)
+		str += String.fromCharCode(asciiKey)
+	}
+	return str
+}
+
+module.exports = WebRTCConn

package/index.js

@@ -1 +0,0 @@
-module.exports = require('./realtime.js')