@babblevoice/babble-drachtio-callmanager 3.4.0 → 3.4.1

package/lib/call.js

@@ -475,12 +475,13 @@ class call {
    * @returns { object }
    */
   #getremotefromheaders() {
-    let parsed
+    let parsed = {}
     if( this._req.has( "p-asserted-identity" ) ) {
       parsed = this._req.getParsedHeader( "p-asserted-identity" )
     } else if( this._req.has( "remote-party-id" ) ) {
       parsed = this._req.getParsedHeader( "remote-party-id" )
     }
+
     return parsed
   }
 
@@ -493,14 +494,14 @@ class call {
 
   #fixparseduriobj( parsed ) {
 
-    if( !parsed ) parsed = {}
+    if( !parsed ) parsed = { name: "" }
+    const name = parsed.name
+
     if( !parsed.uri && parsed.user && parsed.host ) parsed.uri = parsed.user + "@" + parsed.host
     if( parsed.uri && !parsed.user && !parsed.host ) parsed = parseuri( parsed.uri )
 
-    let parseduri = parseuri( parsed.uri )
-
-    if( !parseduri ) parseduri = { "user": parsed.user, "host": parsed.host }
     if( !parsed.params ) parsed.params = {}
+    if( name ) parsed.name = name
 
     return parsed
   }
@@ -550,6 +551,7 @@ class call {
     if( parsed.uri ) startingpoint.uri = parsed.uri
     if( parsed.user ) startingpoint.user = parsed.user
     if( parsed.host ) startingpoint.host = parsed.host
+    if( parsed.name ) startingpoint.name = parsed.name
   }
 
   #fromcontact( startingpoint ) {
@@ -594,15 +596,6 @@ class call {
     return false
   }
 
-  #fromentity( startingpoint ) {
-
-    if( this.#fromoutentity( startingpoint ) ) return true
-    if( this.#frominentity( startingpoint ) ) return true
-
-    return false
-  }
-
-
   /**
    * We have received an INVITE
    * @param { object } startingpoint 
@@ -1578,7 +1571,12 @@ class call {
     If we are not ringing - send ringing to the other end.
   */
   ring() {
-    if( !this.ringing && "uas" === this.type ) {
+
+    if( "uac" === this.type ) return
+
+    if ( this.established ) {
+      this.play( this.ringsoup )
+    } else if( !this.ringing ) {
       this.state.ringing = true
       this._res.send( 180, {
         headers: {
@@ -1592,6 +1590,20 @@ class call {
     }
   }
 
+  /**
+   * Play a sound soup
+   * @param { object } soup
+   * @returns { Boolean }
+  */
+  play( soup ) {
+    if( !this.channels.audio ) return false
+    if( !this.established && !this.state.early ) return false
+    if( !soup ) return false
+
+    this.channels.audio.play( soup )
+    return true
+  }
+
   /**true
     Shortcut to hangup with the reason busy.
   */
@@ -1706,7 +1718,7 @@ class call {
 
   #handlechannelevclose( e ) {
     /* keep a record */
-    if( this.channels.audio.history ) {
+    if( this.channels.audio && this.channels.audio.history ) {
       this.channels.closed.audio.push( this.channels.audio.history )
     } else {
       this.channels.closed.audio.push( e )
@@ -1862,6 +1874,44 @@ class call {
     return callmanager.options.moh
   }
 
+  /**
+  * Set the sound soup for music on ringing.
+  * @param { object } soup - sound soup as described in projectrtp
+  */
+  set ringsoup( soup ) {
+    this._ringsoup = soup 
+  }
+
+  /**
+   * Return the current ringsoup
+   * @returns { object } sound soup
+   */
+  get ringsoup() {
+    if( this._ringsoup ) {
+      return this._ringsoup
+    }
+    return callmanager.options.ringsoup
+  }
+
+  /**
+  * Set the sound soup for music on engaged.
+  * @param { object } soup - sound soup as described in projectrtp
+  */
+  set engagedsoup( soup ) {
+    this._engagedsoup = soup 
+  }
+  
+  /**
+   * Return the current engagedsoup
+   * @returns { object } sound soup
+   */
+  get engagedsoup() {
+    if( this._engagedsoup ) {
+      return this._engagedsoup
+    }
+    return callmanager.options.engagedsoup
+  }
+
   /**
    * If we have been placed on hold (and it has been neotiated) then configure audio to match.
    * @param { "inactive"|"recvonly" } direction - from the other end
@@ -2051,7 +2101,7 @@ class call {
       const channeldef = await othercall.#createchannelremotedef()
 
       const oldchannel = othercall.channels.audio
-      const newchannel = await this.#openchannel( channeldef, this )
+      const newchannel = await this.#openchannel( channeldef, othercall )
       await othercall.bond( this ).reinvite( channeldef, newchannel )
 
       await oldchannel.unmix()
@@ -2077,17 +2127,20 @@ class call {
   */
   async #openchannel( channeldef, bindcall ) {
 
-    if ( bindcall && bindcall.channels.audio ) {
-      const chan = await bindcall.channels.audio.openchannel(
-        channeldef, this._handlechannelevents.bind( this ) )
+    let chan = undefined
 
-      this.channels.count++
-      return chan
+    if ( !bindcall || !this.channels.audio ) {
+      chan = await projectrtp.openchannel(
+        channeldef, this._handlechannelevents.bind( this ) )
+    } else {
+      chan = await this.channels.audio.openchannel(
+        channeldef, bindcall._handlechannelevents.bind( bindcall ) )
     }
 
-    const chan = await projectrtp.openchannel(
-      channeldef, this._handlechannelevents.bind( this ) )
-    this.channels.count++
+    if ( bindcall )
+      bindcall.channels.count++
+    else
+      this.channels.count++
 
     return chan
   }
@@ -2702,39 +2755,59 @@ class call {
 
   /**
    * Hangup the call with reason. Public interface for callers to use.
-   * @param {object} reason - one of the reasons from the hangupcodes enum
-  */
-  async hangup( reason ) {
+   * @param { object } reason - one of the reasons from the hangupcodes enum
+   * @param { boolean } tone if true play teh appropriate tone instead of actaully hanging up
+   */
+  async hangup( reason, tone = false ) {
 
     if( this._state._hangup || this._state._onhangup ) {
       await this.waitforhangup()
       return
     }
-    this._state._hangup = true
+
     this._sethangupcause( "us", reason )
 
     if( this.state.established ) {
-      try {
-        await this._dialog.destroy()
-      } catch( e ) { console.trace( e ) }
-
-    } else if( "uac" === this.type && 
-               this.state.trying ) {
-      try {
-        this.canceled = true
-        if( this._req ) {
-          this._req.cancel( ( err /*, cancel */ ) => {
-            if( err ) console.trace( err )
-          } )
-        }
-      } catch( e ) { console.trace( e ) }
+      if( await this.#hangupestablish( reason, tone ) ) return
+    } else if( "uac" === this.type && this.state.trying ) {
+      this.#hangupnotestablish()
     } else if( this._res ) {
       this._res.send( this.hangup_cause.sip )
     }
 
+    this._state._hangup = true
     await this._onhangup( "us", reason )
   }
 
+  /**
+   * @param { object } reason - plays the apropropriate tone - TODO support other tone than USER_BUSY
+   * @param { boolean } tone 
+   */
+  async #hangupestablish( reason, tone ) {
+    if( tone && 486 == reason.sip ) {
+      this.play( this.engagedsoup )
+      return true
+    }
+
+    this._state._hangup = true
+
+    try {
+      await this._dialog.destroy()
+    } catch( e ) { console.trace( e ) }
+    return false
+  }
+
+  #hangupnotestablish() {
+    try {
+      this.canceled = true
+      if( this._req ) {
+        this._req.cancel( ( err /*, cancel */ ) => {
+          if( err ) console.trace( err )
+        } )
+      }
+    } catch( e ) { console.trace( e ) }
+  }
+
   /**
    * 
    * @returns { Promise }
@@ -2943,13 +3016,13 @@ class call {
     detect which mode the channel is in - but the channels property will exist on a connect
     style channel. projectrtp will getrelatives a rewrite to support only one. */
     if( othercall && othercall.channels.audio ) {
-      this.channels.audio = await this.#openchannel( channeldef, othercall )
+      this.channels.audio = await othercall.#openchannel( channeldef, this )
       return
     }
 
     for( const other of this.relatives ) {
       if( other.channels && other.channels.audio ) {
-        this.channels.audio = await this.#openchannel( channeldef, other )
+        this.channels.audio = await other.#openchannel( channeldef, this )
         return
       }
     }

package/package.json

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