@babblevoice/babble-drachtio-callmanager 3.5.8 → 3.6.0

package/index.js

@@ -14,7 +14,10 @@ const default_options = {
   "registrar": false, /* our registrar object or falsey */
   "referauthrequired": true,
   "ignoreipv6candidates": true, /* ipv6 does not work in projectrtp */
-  "privacy": false
+  "privacy": false,
+  "hangupchildrenonhangup": true,
+  "hangupparentonhangup": false,
+  "continueonotherhangup": false
 }
 
 /**

package/lib/call.js

@@ -1228,7 +1228,7 @@ class call {
       }
   
       /* are we still established? */
-      if( !this.established || this.state.destroyed ) return this
+      if( !this.established || this.state.destroyed || this.parent.destroyed ) return this
       if( !this.channels.audio ) {
         /* something bad has happened */
         this.hangup( hangupcodes.NOT_ACCEPTABLE )
@@ -2586,6 +2586,8 @@ class call {
 
     /* Link logically and mix */
     a_1.adopt( c_1, true )
+    /* update the caller id on the call */
+    await a_1.update()
 
     this._notifyrefercomplete()
 
@@ -2797,14 +2799,29 @@ class call {
     } ).catch( () => {} )
   }
 
+  /**
+   * @param { boolean } value - allow our relation (child or parent) to hang us up or not - set to true if this leg wants to continue
+   */
+  set continueonotherhangup( value ) {
+    this.options.continueonotherhangup = value
+  }
+
+  /**
+   * @returns { boolean }
+   */
+  get continueonotherhangup() {
+    return this.options.continueonotherhangup
+  }
+
   /**
    * Used by our frame to a) continue a hangup which has been initiated by either us or the network.
    * Complete the hangup, including hanging up all children and waiting for them to complete their
    * hangup.
-   * @param { string } [ src ] - "us"|"wire"
+   * @param { "us" | "wire" } [ src ] - "us"|"wire"
    * @param { object } [ reason ] - one of the reasons from the hangupcodes enum - only used if we havn't alread set our reason
    * @private
   */
+  // eslint-disable-next-line complexity
   async _onhangup( src = "us", reason ) {
 
     if( this._state._onhangup ) {
@@ -2813,18 +2830,33 @@ class call {
     }
     this._state._onhangup = true
 
-    /* hangup our children but, no other relations - i.e. children of our parent */
-    const hangups = []
-    for( const child of this.children ) {
-      hangups.push( child.hangup( this.hangup_cause ) )
-    }
+    this._sethangupcause( src, reason )
 
-    /* wait for all children to have completed their hangup */
-    if( 0 < hangups.length ) {
-      await Promise.all( hangups )
-    }
+    if( "wire" == src ) {
+      /* 
+      1. Hangup our children regardless of our state
+      2. If we are established and the only child child - hangup our parent (unless otherwise told not to: parent.continueonotherhangup)
+       */
+      const hangups = []
+      if( this.options.hangupchildrenonhangup ) {
+        for( const child of this.children ) {
+          if( !child.options.continueonotherhangup ) {
+            hangups.push( child.hangup( this.hangup_cause ) )
+          }
+        }
+      }
 
-    this._sethangupcause( src, reason )
+      if( this.established && this.options.hangupparentonhangup && this.parent ) {
+        if( !this.parent.options.continueonotherhangup && 2 > this.parent.children.size ) {
+          hangups.push( this.parent.hangup( this.hangup_cause ) )
+        }
+      }
+
+      /* wait for all relatives to complete their hangup */
+      if( 0 < hangups.length ) {
+        await Promise.all( hangups )
+      }
+    }
 
     /* flag destroyed so when we receive our close event we know what to do */
     this.destroyed = true
@@ -2844,19 +2876,21 @@ class call {
   /**
    * Hangup the call with reason. Public interface for callers to use.
    * @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
+   * @param { boolean } [ tone ] if true play the appropriate tone instead of actaully hanging up
+   * @param { "wire" | "us" } [ source ] - who initiated the hangup - typically us - but if the signal came from another network interface - then wire
+   * 
    */
-  async hangup( reason, tone = false ) {
+  async hangup( reason, tone = false, source = "us" ) {
 
     if( this._state._hangup || this._state._onhangup ) {
       await this.waitforhangup()
       return
     }
 
-    this._sethangupcause( "us", reason )
+    this._sethangupcause( source, reason )
 
     if( this.state.established ) {
-      if( await this.#hangupestablish( reason, tone ) ) return
+      if( this.#hangupestablish( reason, tone ) ) return
     } else if( "uac" === this.type && this.state.trying ) {
       this.#hangupnotestablish()
     } else if( this._res ) {
@@ -2864,29 +2898,29 @@ class call {
     }
 
     this._state._hangup = true
-    await this._onhangup( "us", reason )
+
+    try {
+      if( this._dialog ) await this._dialog.destroy()
+    } catch( e ) { console.trace( e ) }
+
+    await this._onhangup( source, reason )
   }
 
   /**
    * @param { object } reason - plays the apropropriate tone
    * @param { boolean } tone 
    */
-  async #hangupestablish( reason, tone ) {
+  #hangupestablish( reason, tone ) {
     if( undefined != reason && tone ) {
       switch( reason.sip ) {
       case 486:
         this.play( this.engagedsoup )
-        break
+        return true
       case 480:
         this.play( this.unobtainablesoup )
+        return true
       }
-      return true
     }
-    this._state._hangup = true
-
-    try {
-      await this._dialog.destroy()
-    } catch( e ) { console.trace( e ) }
     return false
   }
 
@@ -2920,6 +2954,7 @@ class call {
   /**
   * Send an UPDATE. Use to updated called id, caller id, sdp etc. Send in dialog - TODO look how to send
   * early as this is recomended in the RFC.
+  * @param { object } [ remote ]
   */
   async update( remote ) {
 
@@ -3224,7 +3259,7 @@ class call {
         if( err.status in inboundsiperros ) reason = inboundsiperros[ err.status ]
 
         this.state.destroyed = true
-        if( this ) this._onhangup( "wire", reason )
+        this._onhangup( "wire", reason )
       } else {
         console.trace( err )
       }
@@ -3362,6 +3397,9 @@ class call {
    * @property { object } [ calledid ]
    * @property { string } [ calledid.number ]
    * @property { string } [ calledid.name ]
+   * @property { boolean } [ continueonotherhangup ] - if true continue on other hangup 
+   * @property { boolean } [ hangupchildrenonhangup ]
+   * @property { boolean } [ hangupparentonhangup ]
    * @property { call  } [ bond ] - other channel to bond to for pottential channel pairing
    */
 
@@ -3504,6 +3542,7 @@ class call {
     if( earlypromise ) await earlypromise
 
     if( !newdialog ) {
+      callstore.delete( newcall )
       if( callbacks.fail ) callbacks.fail( newcall )
       return newcall
     }

package/package.json

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