@babblevoice/babble-drachtio-callmanager 1.4.3 → 1.5.0

package/lib/call.js

@@ -90,6 +90,7 @@ class call {
     /**
       @typedef { Object } callstate
       @property { boolean } trying
+      @property { boolean } early
       @property { boolean } ringing
       @property { boolean } established
       @property { boolean } canceled
@@ -103,6 +104,7 @@ class call {
     /** @member { callstate } */
     this.state = {
       "trying": false,
+      "early": false,
       "ringing": false,
       "established": false,
       "canceled": false,
@@ -694,6 +696,12 @@ class call {
   Emitted when a call is ringing
   @event call.ringing
   @type {call}
+  */
+
+    /**
+  Emitted when a call is receives early
+  @event call.early
+  @type {call}
   */
 
   /**
@@ -812,6 +820,33 @@ class call {
     callmanager.options.em.emit( "call.ringing", this )
   }
 
+  /**
+    Called from newuac when we receive a 183
+    @private
+  */
+  async _onearly() {
+
+    if( this.state.established ) return
+    if( !this._res || !this._res.msg || !this._res.msg.body ) return
+
+    /* we have this._res */
+    this.sdp.remote = sdpgen.create( this._res.msg.body )
+    await this.answer( { "early": true } )
+
+    if( !this.parent || this.parent.state.established ) return
+
+    await this.parent.answer( { "early": true } )
+    await this.channels.audio.mix( this.parent.channels.audio )
+
+    this.parent._res.send( 183, {
+      headers: {
+          "User-Agent": "project",
+          "Supported": "replaces"
+        },
+        "body": this.sdp.local.toString()
+    } )
+  }
+
   /**
     Called from newuac when we are answered and we have a dialog,
     this = child call (the new call - the bleg)
@@ -1303,80 +1338,96 @@ class call {
   }
 
   /**
-    Answer this (inbound) call and store a channel which can be used.
-    @return {Promise} Returns a promise which resolves if the call is answered, otherwise rejects the promise.
-    This framework will catch and cleanup this call if this is rejected.
+   * Answer this (inbound) call and store a channel which can be used. This framework will catch and cleanup this call if this is rejected.
+   * @param { object } options
+   * @param { boolean } options.early - don't answer the channel (establish) but establish early media (respond to 183).
+   *
+   * @return {Promise} Returns a promise which resolves if the call is answered, otherwise rejects the promise.
   */
   async answer( options = {} ) {
 
     if( this.canceled || this.established ) return
 
     options = { ...callmanager.options, ...this.options, ...options }
-    this.sdp.remote = sdpgen.create( this._req.msg.body )
-
-    /* options.preferedcodecs may have been narrowed down so we still check callmanager as well */
-    this.selectedcodec = this.sdp.remote.intersection( options.preferedcodecs, true )
-    if( false === this.selectedcodec ) {
-      this.selectedcodec = this.sdp.remote.intersection( callmanager.options.preferedcodecs, true )
-    }
 
-    let remoteaudio = this.sdp.remote.getaudio()
-    if( !remoteaudio ) return
+    let channeldef
+    if( this._req.msg && this._req.msg.body ) {
+      this.sdp.remote = sdpgen.create( this._req.msg.body )
+      /* options.preferedcodecs may have been narrowed down so we still check callmanager as well */
+      this.selectedcodec = this.sdp.remote.intersection( options.preferedcodecs, true )
+      if( false === this.selectedcodec ) {
+        this.selectedcodec = this.sdp.remote.intersection( callmanager.options.preferedcodecs, true )
+      }
+      let remoteaudio = this.sdp.remote.getaudio()
+      if( !remoteaudio ) return
 
-    this.sdp.remote.select( this.selectedcodec )
-    
-    await call._parsesdpcandidates( remoteaudio, this.sdp.remote.sdp )
+      this.sdp.remote.select( this.selectedcodec )
+      
+      await call._parsesdpcandidates( remoteaudio, this.sdp.remote.sdp )
 
-    let channeldef = call._createchannelremotedef( remoteaudio.address, remoteaudio.port, remoteaudio.audio.payloads[ 0 ] )
+      channeldef = call._createchannelremotedef( remoteaudio.address, remoteaudio.port, remoteaudio.audio.payloads[ 0 ] )
 
-    let iswebrtc = this._iswebrtc
+      if( this._iswebrtc ) {
+        channeldef.remote.dtls = {
+          "fingerprint": this.sdp.remote.sdp.media[ 0 ].fingerprint,
+          "mode": this.sdp.remote.sdp.media[ 0 ].setup==="passive"?"active":"passive" /* prefer passive for us */
+        }
 
-    if( iswebrtc ) {
-      channeldef.remote.dtls = {
-        "fingerprint": this.sdp.remote.sdp.media[ 0 ].fingerprint,
-        "mode": this.sdp.remote.sdp.media[ 0 ].setup==="passive"?"active":"passive" /* prefer passive for us */
+        channeldef.remote.icepwd = this.sdp.remote.sdp.media[ 0 ].icePwd
       }
-
-      channeldef.remote.icepwd = this.sdp.remote.sdp.media[ 0 ].icePwd
     }
 
-    let ch = await projectrtp.openchannel( channeldef, this._handlechannelevents.bind( this ) )
-    this.channels.audio = ch
-    this.sdp.local = sdpgen.create()
-              .addcodecs( this.selectedcodec )
-              .setconnectionaddress( ch.local.address )
-              .setaudioport( ch.local.port )
+    /* 
+      We might have already opened our audio when we received 183 (early).
+    */
+    if( this.channels.audio ) {
+      this.channels.audio.remote( channeldef.remote )
+    } else {
+      let ch = await projectrtp.openchannel( channeldef, this._handlechannelevents.bind( this ) )
+      this.channels.audio = ch
+      this.sdp.local = sdpgen.create()
+                .addcodecs( this.selectedcodec )
+                .setconnectionaddress( ch.local.address )
+                .setaudioport( ch.local.port )
+
+      if( callmanager.options.rfc2833 ) {
+        this.sdp.local.addcodecs( "2833" )
+      }
 
-    if( this.canceled ) return
+      if( this._iswebrtc ) {
+        this.sdp.local.addssrc( ch.local.ssrc )
+                      .secure( ch.local.dtls.fingerprint, channeldef.remote.dtls.mode )
+                      .addicecandidates( ch.local.address, ch.local.port, ch.local.icepwd )
+                      .rtcpmux()
+      }
 
-    if( true === callmanager.options.rfc2833 ) {
-      this.sdp.local.addcodecs( "2833" )
+      if( this.canceled ) return
     }
 
-    if( iswebrtc ) {
-      this.sdp.local.addssrc( ch.local.ssrc )
-                    .secure( ch.local.dtls.fingerprint, channeldef.remote.dtls.mode )
-                    .addicecandidates( ch.local.address, ch.local.port, ch.local.icepwd )
-                    .rtcpmux()
-    }
+    if( options.early ) {
+      this.state.early = true
+      this._em.emit( "call.early", this )
+      callmanager.options.em.emit( "call.early", this )
 
-    let dialog = await callmanager.options.srf.createUAS( this._req, this._res, {
-      localSdp: this.sdp.local.toString(),
-      headers: {
-         "User-Agent": "project",
-         "Supported": "replaces"
-       }
-    } )
+    } else {
+      let dialog = await callmanager.options.srf.createUAS( this._req, this._res, {
+        localSdp: this.sdp.local.toString(),
+        headers: {
+          "User-Agent": "project",
+          "Supported": "replaces"
+        }
+      } )
 
-    this.established = true
-    this._dialog = dialog
-    this.sip.tags.local = dialog.sip.localTag
-    callstore.set( this )
+      this.established = true
+      this._dialog = dialog
+      this.sip.tags.local = dialog.sip.localTag
+      callstore.set( this )
 
-    this._addevents( this._dialog )
+      this._addevents( this._dialog )
+      this._em.emit( "call.answered", this )
+      callmanager.options.em.emit( "call.answered", this )
 
-    this._em.emit( "call.answered", this )
-    callmanager.options.em.emit( "call.answered", this )
+    }
   }
 
   /**
@@ -1940,7 +1991,7 @@ class call {
     let target = a_1.sdp.remote.getaudio()
     if( target ) {
       /* we should always get in here */
-      a_1.channels.audio.remote( call._createchannelremotedef( target.address, target.port, a_1.selectedcodec ) )
+      a_1.channels.audio.remote( call._createchannelremotedef( target.address, target.port, a_1.selectedcodec ).remote )
 
       /* there might be situations where mix is not the correct thing - perhaps a pop push application? */
       a_1.channels.audio.mix( c_1.channels.audio )
@@ -2472,10 +2523,12 @@ class call {
         if( callbacks && callbacks.early ) callbacks.early( newcall )
         callmanager.options.em.emit( "call.new", newcall )
       },
-      cbProvisional: ( res ) => {
+      cbProvisional: async ( res ) => {
         newcall._res = res
         if( 180 === res.status ) {
           newcall._onring()
+        } else if( 183 === res.status ) {
+          await newcall._onearly()
         }
 
         if( newcall.canceled ) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@babblevoice/babble-drachtio-callmanager",
-  "version": "1.4.3",
+  "version": "1.5.0",
   "description": "Call processing to create a PBX",
   "main": "index.js",
   "scripts": {

package/test/interface/early.js

@@ -0,0 +1,102 @@
+
+
+const { v4: uuidv4 } = require( "uuid" )
+const expect = require( "chai" ).expect
+const callmanager = require( "../../index.js" )
+const call = require( "../../lib/call.js" )
+const srf = require( "../mock/srf.js" )
+
+const projectrtpmessage = require( "@babblevoice/projectrtp/lib/message.js" )
+const net = require( "net" )
+
+const clearcallmanager = require( "../../lib/callmanager.js" )._clear
+
+describe( "call early", function() {
+
+  afterEach( function() {
+    clearcallmanager()
+  } )
+
+  beforeEach( function() {
+    clearcallmanager()
+  } )
+
+
+  it( `Create call and send 183 - early`, async () => {
+    let srfscenario = new srf.srfscenario()
+
+    let rtpserver = callmanager.projectrtp.proxy.listen()
+
+    let connection = net.createConnection( 9002, "127.0.0.1" )
+      .on( "error", ( e ) => {
+        console.error( e )
+      } )
+
+    connection.on( "connect", () => {
+      /* announce our node */
+      connection.write( projectrtpmessage.createmessage( {"status":{"channel":{"available":5000,"current":0},"workercount":12,"instance":"ca0ef6a9-9174-444d-bdeb-4c9eb54d4566"}} ) )
+    } )
+
+    let msgid
+    let mixing
+    let messagestate = projectrtpmessage.newstate()
+    connection.on( "data", ( data ) => {
+      projectrtpmessage.parsemessage( messagestate, data, ( msg ) => {
+        if( "open" === msg.channel ) {
+          msgid = msg.id
+          setTimeout( () => connection.write( projectrtpmessage.createmessage( {"local":{"port":10008,"dtls":{"fingerprint":"Some fingerprint","enabled":false},"address":"192.168.0.141"},"id": msg.id, "uuid": uuidv4(),"action":"open","status":{"channel":{"available":4995,"current":5},"workercount":12,"instance":"ca0ef6a9-9174-444d-bdeb-4c9eb54d4566"}} ) ), 2 )
+        } else if ( "close" === msg.channel ) {
+          connection.write( projectrtpmessage.createmessage( {"id": msg.id,"uuid":msg.uuid,"action":"close","reason":"requested","stats":{"in":{"mos":4.5,"count":586,"dropped":0,"skip":0},"out":{"count":303,"skip":0},"tick":{"meanus":124,"maxus":508,"count":597}}} ) )
+        } else if ( "mix" === msg.channel ) {
+          mixing = true
+        }
+      } )
+    } )
+
+    /* ensure we are connected */
+    await new Promise( ( r ) => setTimeout( () => r(), 100 ) )
+
+    srfscenario.oncreateUAC( async ( contact, options, callbacks ) => {
+      callbacks.cbProvisional( {
+        "status": 183,
+        "msg": {
+          "body": `v=0
+o=- 1608235282228 0 IN IP4 127.0.0.1
+s=
+c=IN IP4 192.168.0.141
+t=0 0
+m=audio 20000 RTP/AVP 0 101
+a=rtpmap:101 telephone-event/8000
+a=fmtp:101 0-16
+a=sendrecv`.replace(/(\r\n|\n|\r)/gm, "\r\n")
+        }
+      } )
+
+      await new Promise( ( r ) => setTimeout( () => r(), 100 ) )
+      throw { "status": 503 }
+    } )
+
+    let msgsent
+    let call = await new Promise( ( resolve ) => {
+      srfscenario.oncall( async ( call ) => { resolve( call ) } )
+      srfscenario.inbound()
+      srfscenario.res.onsend( (c) => {
+        msgsent = c
+      })
+    } )
+
+
+    let newcall = await call.newuac( { "contact": "callto" } )
+    
+    await call._onhangup( "wire" )
+    
+    expect( newcall.state.early ).to.be.true
+    expect( call.state.early ).to.be.true
+    expect( mixing ).to.be.true
+    expect( msgsent ).to.equal( 183 )
+
+    connection.destroy()
+    rtpserver.destroy()
+  } )
+
+} )

package/test/mock/srf.js

@@ -165,6 +165,11 @@ class res {
     this.callbacks = {
       "onsend": false
     }
+
+    this.msg = {
+      "body": possiblesdp[ sdpid % possiblesdp.length ],
+      method: "INVITE"
+    }
   }
 
   /* returns undefined - https://drachtio.org/api#sip-request */