@babblevoice/babble-drachtio-callmanager 3.3.3 → 3.3.4

package/lib/call.js

@@ -218,7 +218,8 @@ class call {
       "audio": undefined,
       "closed": {
         "audio": []
-      }
+      },
+      "count": 0
     }
 
     /**
@@ -1717,13 +1718,20 @@ class call {
       this.channels.closed.audio.push( e )
     }
 
-    this.channels.audio = false
-    if( this._state._onhangup ) {
-      this._cleanup()
-      return
-    }
+    this.channels.count--
 
-    this.hangup() /* ? */
+    if ( 0 === this.channels.count ) {
+      this.channels.audio = false
+
+      if( this._state._onhangup ) {
+        this._cleanup()
+        return
+      }
+
+      // This will handle _cleanup() later
+      // based on the above flag
+      this.hangup()
+    }
   }
 
   /**
@@ -2010,9 +2018,13 @@ class call {
     same as used elsewhere. If a bond has been attached to the call, we will
     try to reuse an existing channel.
     @param { object } [ channeldef ]
+    @param { object } [ newchannel ]
     @private
   */
-  async reinvite( channeldef ) {
+  async reinvite( channeldef, newchannel ) {
+
+    if ( newchannel )
+      this.channels.audio = newchannel
 
     if ( !channeldef )
       channeldef = await this.#createchannelremotedef()
@@ -2045,17 +2057,43 @@ class call {
       const channeldef = await othercall.#createchannelremotedef()
 
       const oldchannel = othercall.channels.audio
-      // eslint-disable-next-line require-atomic-updates
-      othercall.channels.audio = await this.channels.audio.openchannel( channeldef, othercall._handlechannelevents.bind( othercall ) )
+      const newchannel = await this.#openchannel( channeldef, othercall )
 
-      await othercall.bond( this ).reinvite( channeldef )
+      await othercall.bond( this ).reinvite( channeldef, newchannel )
 
-      await oldchannel.close()
+      await oldchannel.unmix()
+      oldchannel.close()
     }
 
     await this.channels.audio.mix( othercall.channels.audio )
   }
 
+  /**
+    Mix two calls. If the two calls are on a different node
+    the second call is bonded and reinvited.
+    @param { object } channeldef - our call object which is early
+    @param { call } bindcall - the call which will own the channel
+  */
+  async #openchannel( channeldef, bindcall ) {
+
+    let chan = undefined
+
+    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 ) )
+    }
+
+    if ( bindcall )
+      bindcall.channels.count++
+    else
+      this.channels.count++
+
+    return chan
+  }
+
   /**
    * 
    * @param { object } req 
@@ -2156,20 +2194,32 @@ class call {
     RTP stall timer will kick in first, but if a call is placed on hold followed
     by AWOL... */
     this._timers.seinterval = setInterval( async () => {
-      const opts = {
-        "method": "INVITE",
-        "body": this.sdp.local.toString()
-      }
 
-      const res = await dialog.request( opts )
-        .catch( ( e ) => {
-          console.trace( e )
-          this.hangup( hangupcodes.USER_GONE )
-        } )
+      try{
 
-      if( !this.destroyed && 200 != res.msg.status ) {
-        this.hangup( hangupcodes.USER_GONE )
-      }
+        if( this.destroyed ) {
+          /* this should be done - but we are still running */
+          clearInterval( this._timers.seinterval )
+          return
+        }
+
+        if( "function" != typeof dialog.request ) return
+
+        const opts = {
+          "method": "INVITE",
+          "body": this.sdp.local.toString()
+        }
+  
+        const res = await dialog.request( opts )
+          .catch( ( e ) => {
+            console.trace( e )
+            this.hangup( hangupcodes.USER_GONE )
+          } )
+  
+        if( !this.destroyed && 200 != res.msg.status ) {
+          this.hangup( hangupcodes.USER_GONE )
+        }
+      } catch( e ) { /* empty */ }
 
     }, callmanager.options.seexpire )
 
@@ -2567,7 +2617,6 @@ class call {
     @private
   */
   _cleanup() {
-
     if( this.state.cleaned ) return
     this.state.cleaned = true
 
@@ -2643,7 +2692,7 @@ class call {
     if( this.channels.audio ) {
       this.channels.audio.close()
       this._timers.cleanup = setTimeout( () => {
-        console.trace( "Timeout waiting for channel close, cleaning up anyway", this.uuid )
+        console.trace( this.uuid + " Timeout waiting for channel close, cleaning up anyway, chan uuid: " + this.channels.audio.uuid + ", channel count: " + this.channels.count )
         this._cleanup() 
       }, 60 * 1000 )
 
@@ -2896,18 +2945,18 @@ 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( relatedcall && relatedcall.channels.audio && relatedcall.channels.audio.channels ) {
-      this.channels.audio = await this.other.channels.audio.openchannel( channeldef, this._handlechannelevents.bind( this ) )
+      this.channels.audio = await this.#openchannel( channeldef, this )
       return
     }
 
     for( const other of this.relatives ) {
       if( other.channels && other.channels.audio ) {
-        this.channels.audio = await other.channels.audio.openchannel( channeldef, this._handlechannelevents.bind( this ) )
+        this.channels.audio = await other.#openchannel( channeldef, this )
         return
       }
     }
 
-    this.channels.audio = await projectrtp.openchannel( channeldef, this._handlechannelevents.bind( this ) )
+    this.channels.audio = await this.#openchannel( channeldef )
   }
 
   /**

package/package.json

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