@babblevoice/babble-drachtio-callmanager 2.3.9 → 2.3.10

package/lib/call.js

@@ -205,6 +205,9 @@ class call {
     */
     this.parent = undefined
 
+    /** @summary Other channels which we might need - for things like opening a channel on the same node. */
+    this.relatives = new Set()
+
     /**
      * @typedef {Object} epochs
      * @property {number} startat UNIX timestamp of when the call was started (created)
@@ -889,16 +892,19 @@ class call {
   /**
   Emits the event call.pick to allow other parts of dial plan to give up on further processing.
   It wuld be normal to bridge this call to another after this call has been made.
+  @return { call }
   */
   pick() {
     this.state.picked = true
     this._em.emit( "call.pick", this )
+    return this
   }
 
   /**
     Delink calls logically - any calls which have parent or children they are all removed.
     when the dialog is either answered (or doesn't answer for some reason).
     The promise resolves to a new call is one is generated, or undefined if not.
+    @return { call }
   */
   detach() {
     if( this.parent ) {
@@ -911,11 +917,14 @@ class call {
 
     this.parent = undefined
     this.children.clear()
+    return this
   }
 
   /**
-  Logically adopt a child call
-  @param { call } other 
+  * Logically adopt a child call
+  * @param { object } other 
+  * @param { boolean } [ mix ]
+  * @return { call }
   */
   adopt( other, mix ) {
     other.parent = this
@@ -935,6 +944,29 @@ class call {
       this.epochs.mix = Math.floor( +new Date() / 1000 )
       other.epochs.mix = Math.floor( +new Date() / 1000 )
     }
+    return this
+  }
+
+  /**
+   * Create a bond between us and another call. This is currently only used
+   * to provide other channels we know we might need to open a channel on 
+   * the same node as. (replaces preferredcall)
+   * @param { object } relative 
+   * @return { call }
+   */
+  bond( relative ) {
+    if( !relative ) return
+    this.relatives.add( relative )
+    return this
+  }
+
+  /**
+   * Disown distant relatives.
+   * @return { call }
+   */
+  disown() {
+    this.relatives.clear()
+    return this
   }
 
   /**
@@ -1452,12 +1484,11 @@ class call {
   }
 
   /**
-   * @param { object } preferredcall - allow to specify a, not necessarily related call,
    * that can be used to open the new channel's node.
    *
    * @returns { Promise }
    */
-  async #choosecodecforanswer( preferredcall = undefined ) {
+  async #choosecodecforanswer() {
     if( this._req.msg && this._req.msg.body ) {
       this.selectedcodec = this.sdp.remote.intersection( this.options.preferedcodecs, true )
       if( !this.selectedcodec ) {
@@ -1484,8 +1515,6 @@ class call {
         channeldef.remote.icepwd = this.sdp.remote.sdp.media[ 0 ].icePwd
       }
 
-      channeldef.preferredcall = preferredcall
-
       /* We might have already opened our audio when we received 183 (early). */
       await this.#openchannelsforanswer( channeldef )
     }
@@ -1495,15 +1524,14 @@ class call {
    * 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).
-   * @param { object } [ options.preferredcall ]
    *
    * @return {Promise} Returns a promise which resolves if the call is answered, otherwise rejects the promise.
   */
-  async answer( options = { early: false, preferredcall: undefined } ) {
+  async answer( options = { early: false } ) {
 
     if( this.canceled || this.established ) return
 
-    await this.#choosecodecforanswer( options.preferredcall )
+    await this.#choosecodecforanswer()
 
     if( this.canceled ) return
 
@@ -2493,7 +2521,6 @@ class call {
   @param { string } [ options.entity.uri ]
   @param { number } [ options.entity.max ] - if included no more than this number of calls for this entity (only if we look user up)
   @param { object } [ options.parent ] - the call we wish to become parent
-  @param { object } [ options.preferredcall ] another related call which we may want to use the rtp host on
   @param { object } [ callbacks ]
   @param { earlycallback } [ callbacks.early ] - callback to provide a call object with early call (pre dialog)
   @param { confirmcallback } [ callbacks.confirm ] - called when a dialog is confirmed but before it is bridged with a parent - this provides an opportunity for another call to adopt this call
@@ -2517,9 +2544,6 @@ class call {
 
     if( !options.orphan && !options.parent ) {
       options.parent = this
-
-      if ( !options.preferredcall )
-        options.preferredcall = options.parent.channels.audio
     }
 
     return await call.newuac( options, callbacks )
@@ -2635,12 +2659,19 @@ class call {
     mechanism. This is causing problems in code like this. There is no interface to 
     detect which mode the channel is in - but the channels property will exist on a connect
     style channel. projectrtp will get a rewrite to support only one. */
-    if( relatedcall && relatedcall.channels.audio && relatedcall.channels.audio.channels )
+    if( relatedcall && relatedcall.channels.audio && relatedcall.channels.audio.channels ) {
       this.channels.audio = await this.other.channels.audio.openchannel( channeldef, this._handlechannelevents.bind( this ) )
-    else if ( channeldef && channeldef.preferredcall && channeldef.preferredcall.channels && channeldef.preferredcall.channels.audio )
-      this.channels.audio = await channeldef.preferredcall.channels.audio.openchannel( channeldef, this._handlechannelevents.bind( this ) )
-    else
-      this.channels.audio = await projectrtp.openchannel( channeldef, this._handlechannelevents.bind( 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 ) )
+        return
+      }
+    }
+
+    this.channels.audio = await projectrtp.openchannel( channeldef, this._handlechannelevents.bind( this ) )
   }
 
   /**
@@ -2837,7 +2868,7 @@ class call {
   @param { object } [ options.callerid ]
   @param { string } [ options.callerid.number ]
   @param { string } [ options.callerid.name ]
-  @param { object } [ options.preferredcall ] another related call which we may want to use the rtp host on
+  @param { call  } [ options.bond ] - other channel to bond to for pottential channel pairing
   @param { object } [ callbacks ]
   @param { earlycallback } [ callbacks.early ] - callback to provide a call object with early call (pre dialog)
   @param { confirmcallback } [ callbacks.confirm ] - called when a dialog is confirmed but before it is bridged with a parent - this provides an opportunity for another call to adopt this call
@@ -2860,6 +2891,8 @@ class call {
       options.parent.adopt( newcall )
     }
 
+    newcall.bond( options.bond )
+
     newcall.options = {
       headers: { ...options.headers }
     }
@@ -2886,7 +2919,7 @@ class call {
     newcall.options.headers = tmpheaders
 
     newcall.#confignetwork( options )
-    await newcall.#openchannelsfornewuac( { "preferredcall" : options.preferredcall } )
+    await newcall.#openchannelsfornewuac()
 
     let newdialog
     try {

package/package.json

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