vertojs

vertojs

Verto (VER-to) RTC is a FreeSWITCH endpoint that implements a subset of a JSON-RPC connection designed for use over secure websockets. The initial target is WebRTC to simplify coding and implementing calls from web browsers and devices to FreeSWITCH. This allows a web browser or other WebRTC client to originate a call using Verto into a FreeSWITCH installation and then out to the PSTN using SIP, SS7, or other supported protocol.

This is a zero-dependency implementation that is no need to include jquery as an in original one. It doesn't contain any html stuff inside or media handlers as well. You should take care of fetch media tracks yourself (I think it is better not to hide useful features of you, browser provides a great API to handle media)

Status

This is a work in progress code. However, it is stable enough to use basic functions (calls). I believe and I hope the source code is much better than my English :-)

Get started

Package directory content

/dist — contains a minified bundle exporting Verto symbol to a global namespace

/src — contains source Typescript files

To use this package you can either include dist/verto.js as a html <script> tag or import it using webpack like that

import { Verto } from 'vertojs'

Check index.html in the package directory to find out how to use this code with a html <script> tag

Create a client instance

let verto = new Verto(options: VertoOptions)

interface VertoOptions {
	transportConfig : JsonRpcClientParams 
	// Verto transport configuration, check below
	
	rtcConfig?      : RTCConfiguration    
    // RTCConfiguration object, as described here 
	// https://developer.mozilla.org/en-US/docs/Web/API/RTCConfiguration
	// The most important thing is iceServers item that should be set to go over NAT
	
	debug?          : boolean
	// Set true to get some useful debug info in browser console 
	
	ice_timeout?    : number
	// Milliseconds to stop waiting for ice candidates, default to 3000ms
}

interface JsonRpcClientParams {
	socketUrl       : string
	// The URL where the verto interface lives
	// wss://server.example.com:8082

	login           : string
	passwd          : string
}

Receive calls

You should register to verto to receive calls.

The following code is a simplified example of using the handler function to auto answer the first incoming call and add first received audio track to some <video> element.

try {
	let data = await verto.login()
} catch (error) {
	alert("Access denied")
	return
}

let local_stream = await navigator.mediaDevices.getUserMedia({audio:true})

verto.subscribeEvent('invite', call => {

	call.subscribeEvent('track', (track) => {
		if(track.kind!='audio') return
		
		let stream = new MediaStream()
		stream.addTrack(track)
		
		let el = document.getElementById('video')
		el.srcObject = stream
	})

	call.answer(local_stream.getTracks())
})

Place calls

let local_stream = await navigator.mediaDevices.getUserMedia({audio:true})

let call = verto.call(local_stream.getTracks(), "9664")

call.subscribeEvent('track', (track) => {
	if(track.kind!='audio') return
	
	let stream = new MediaStream()
	stream.addTrack(track)

	let el = document.getElementById('video')
	el.srcObject = stream
})

API description

There's a number (pretty small number) of Classes and Interfaces provided.

Verto

Methods

constructor

let verto = new Verto(options: VertoOptions)

interface VertoOptions {
	transportConfig : JsonRpcClientParams 
	// Verto transport configuration, check below
	
	rtcConfig?      : RTCConfiguration    
    // RTCConfiguration object, as described here 
	// https://developer.mozilla.org/en-US/docs/Web/API/RTCConfiguration
	// The most important thing is iceServers item that should be set to go over NAT
	
	debug?          : boolean
	// Set true to get some useful debug info in browser console 
	
	ice_timeout?    : number
	// Milliseconds to stop waiting for ice candidates, default to 3000ms
}

interface JsonRpcClientParams {
	socketUrl       : string
	// The URL where the verto interface lives
	// wss://server.example.com:8082

	login           : string
	passwd          : string
}

login

Parameters

• None

Returns

• Promise, that will be resolved if the login process succeed or threw an exception otherwise.

verto.login()

call

Parameters

• tracks: Array<MediaStreamTrack>
  represents tracks to be sent to the remote call side
• destination: string
  an extension to be dialed
• options?: VertoCallOptions
  call options

Returns

• VertoCall instance

let call = verto.call(tracks, destination, options)

Events

invite

Fires on incoming call. As a parameter handler will receive a VertoCall instance.

verto.subscribeEvent('invite', call => {

	call.subscribeEvent('track', (track) => {
		if(track.kind!='audio') return
		
		let stream = new MediaStream()
		stream.addTrack(track)
		
		let el = document.getElementById('video')
		el.srcObject = stream
	})

	call.answer(local_stream.getTracks())
})

VertoCall

This class instances should never be built manually, but using verto.call or incoming call handler.

Methods

answer

Parameters

• tracks: Array<MediaStreamTrack>
  represents tracks to be sent to the remote call side

Returns

• None

call.answer(tracks)

hangup

Parameters

• None

Returns

• None

call.hangup()

Instance variables

id

• String — the call id

options

• VertoCallOptions

direction

• CallDirection

Events

answer

Fires when the call is answered.

call.subscribeEvent('answer', () => {
    // Do something on answer
})

track

Fires when a MediaStreamTrack is received

verto.subscribeEvent('invite', call => {

	call.subscribeEvent('track', (track) => {
		if(track.kind!='audio') return
		
		let stream = new MediaStream()
		stream.addTrack(track)
		
		let el = document.getElementById('video')
		el.srcObject = stream
	})

	call.answer(local_stream.getTracks())
})

bye

Fires when the call is ended.

call.subscribeEvent('bye', cause => {
    // Do something on call end
})

Interfaces

VertoCallOptions

interface VertoCallOptions {
	caller_id_number?   : string
	caller_id_name?     : string
	callee_id_number?   : string
	callee_id_name?     : string
}

VertoOptions

interface VertoOptions {
	transportConfig : JsonRpcClientParams 
	// Verto transport configuration, check below
	
	rtcConfig?      : RTCConfiguration    
    // RTCConfiguration object, as described here 
	// https://developer.mozilla.org/en-US/docs/Web/API/RTCConfiguration
	// The most important thing is iceServers item that should be set to go over NAT
	
	debug?          : boolean
	// Set true to get some useful debug info in browser console 
	
	ice_timeout?    : number
	// Milliseconds to stop waiting for ice candidates, default to 3000ms
}

JsonRpcClientParams

interface JsonRpcClientParams {
	socketUrl       : string
	// The URL where the verto interface lives
	// wss://server.example.com:8082

	login           : string
	passwd          : string
}

CallDirection

enum CallDirection {
	Incoming,
	Outgoing
}

Event handling

Both Verto and VertoCall classes uses the same event handling system.

subscribeEvent

Parameters

• name : string
• handler : {(data:any):void}

Returns

• String identifies the handler

let handler_id = verto.subscribeEvent(name, handler)

unsubscribeEvent

Parameters

• name : string
• handler_id? : string
  if ommited, all the handlers for name event will be deleted

Returns

• None

verto.unsubscribeEvent(name, handler_id)

License

Copyright (c) 2019 Roman Yerin <[e-mail]>

Licensed under the 3-clause BSD license.