Endpoint.js

  1. import React, {DeviceEventEmitter, NativeModules} from 'react-native';
  2. import {EventEmitter} from 'events'
  4. import Call from './Call'
  5. import Message from './Message'
  6. import Account from './Account'
  8. /**
  9.  * SIP headers object, where each key is a header name and value is a header value.
  10.  * Example:
  11.  * {
  12.  *   "X-Custom-Header": "Test Header Value",
  13.  *   "X-Custom-ID": "Awesome Header"
  14.  * }
  15.  *
  16.  * @typedef {Object} PjSipHdrList
  17.  */
  19. /**
  20.  * An additional information to be sent with outgoing SIP message.
  21.  * It can (optionally) be specified for example
  22.  * with #Endpoint.makeCall(), #Endpoint.answerCall(), #Endpoint.hangupCall(),
  23.  * #Endpoint.holdCall() and many more.
  24.  *
  25.  * @typedef {Object} PjSipMsgData
  26.  * @property {String} target_uri - Indicates whether the Courage component is present.
  27.  * @property {PjSipHdrList} hdr_list - Additional message headers as linked list.
  28.  * @property {String} content_type - MIME type of optional message body.
  29.  * @property {String} msg_body - MIME type of optional message body.
  30.  */
  32. /**
  33.  * An additional information to be sent with outgoing SIP message.
  34.  * It can (optionally) be specified for example
  35.  * with #Endpoint.makeCall(), #Endpoint.answerCall(), #Endpoint.hangupCall(),
  36.  * #Endpoint.holdCall() and many more.
  37.  *
  38.  * @typedef {Object} PjSipCallSetttings
  39.  * @property {number} flag - Bitmask of #pjsua_call_flag constants.
  40.  * @property {number} req_keyframe_method - This flag controls what methods to request keyframe are allowed on the call.
  41.  * @property {number} aud_cnt - Number of simultaneous active audio streams for this call. Setting this to zero will disable audio in this call.
  42.  * @property {number} vid_cnt - Number of simultaneous active video streams for this call. Setting this to zero will disable video in this call.
  43.  */
  47. export default class Endpoint extends EventEmitter {
  49.     constructor() {
  50.         super();
  52.         // Subscribe to Accounts events
  53.         DeviceEventEmitter.addListener('pjSipRegistrationChanged', this._onRegistrationChanged.bind(this));
  55.         // Subscribe to Calls events
  56.         DeviceEventEmitter.addListener('pjSipCallReceived', this._onCallReceived.bind(this));
  57.         DeviceEventEmitter.addListener('pjSipCallChanged', this._onCallChanged.bind(this));
  58.         DeviceEventEmitter.addListener('pjSipCallTerminated', this._onCallTerminated.bind(this));
  59.         DeviceEventEmitter.addListener('pjSipCallScreenLocked', this._onCallScreenLocked.bind(this));
  60.         DeviceEventEmitter.addListener('pjSipMessageReceived', this._onMessageReceived.bind(this));
  61.         DeviceEventEmitter.addListener('pjSipConnectivityChanged', this._onConnectivityChanged.bind(this));
  62.     }
  64.     /**
  65.      * Returns a Promise that will be resolved once PjSip module is initialized.
  66.      * Do not call any function while library is not initialized.
  67.      *
  68.      * @returns {Promise}
  69.      */
  70.     start(configuration) {
  71.         return new Promise(function(resolve, reject) {
  72.             NativeModules.PjSipModule.start(configuration, (successful, data) => {
  73.                 if (successful) {
  74.                     let accounts = [];
  75.                     let calls = [];
  77.                     if (data.hasOwnProperty('accounts')) {
  78.                         for (let d of data['accounts']) {
  79.                             accounts.push(new Account(d));
  80.                         }
  81.                     }
  83.                     if (data.hasOwnProperty('calls')) {
  84.                         for (let d of data['calls']) {
  85.                             calls.push(new Call(d));
  86.                         }
  87.                     }
  89.                     let extra = {};
  91.                     for (let key in data) {
  92.                         if (data.hasOwnProperty(key) && key != "accounts" && key != "calls") {
  93.                             extra[key] = data[key];
  94.                         }
  95.                     }
  97.                     resolve({
  98.                         accounts,
  99.                         calls,
  100.                         ...extra
  101.                     });
  102.                 } else {
  103.                     reject(data);
  104.                 }
  105.             });
  106.         });
  107.     }
  109.     updateStunServers(accountId, stunServerList) {
  110.         return new Promise(function(resolve, reject) {
  111.             NativeModules.PjSipModule.updateStunServers(accountId, stunServerList, (successful, data) => {
  112.                 if (successful) {
  113.                     resolve(data);
  114.                 } else {
  115.                     reject(data);
  116.                 }
  117.             })
  118.         })
  119.     }
  121.     /**
  122.      * @param configuration
  123.      * @returns {Promise}
  124.      */
  125.     changeNetworkConfiguration(configuration) {
  126.         return new Promise(function(resolve, reject) {
  127.             NativeModules.PjSipModule.changeNetworkConfiguration(configuration, (successful, data) => {
  128.                 if (successful) {
  129.                     resolve(data);
  130.                 } else {
  131.                     reject(data);
  132.                 }
  133.             });
  134.         });
  135.     }
  137.     /**
  138.      * @param configuration
  139.      * @returns {Promise}
  140.      */
  141.     changeServiceConfiguration(configuration) {
  142.         return new Promise(function(resolve, reject) {
  143.             NativeModules.PjSipModule.changeServiceConfiguration(configuration, (successful, data) => {
  144.                 if (successful) {
  145.                     resolve(data);
  146.                 } else {
  147.                     reject(data);
  148.                 }
  149.             });
  150.         });
  151.     }
  153.     /**
  154.      * Add a new account. If registration is configured for this account, this function would also start the
  155.      * SIP registration session with the SIP registrar server. This SIP registration session will be maintained
  156.      * internally by the library, and application doesn't need to do anything to maintain the registration session.
  157.      *
  158.      * An example configuration:
  159.      * {
  160.      *   name: "John Doe",
  161.      *   username: "100",
  162.      *   domain: "pbx.com",
  163.      *   password: "XXXXXX",
  164.      *
  165.      *   proxy: "192.168.100.1:5060", // default disabled.
  166.      *   transport: "TCP", // default TCP
  167.      *   regServer: "pbx.com", // default taken from domain
  168.      *   regTimeout: 300, // default 300
  169.      * }
  170.      *
  171.      * @param {Object} configuration
  172.      * @returns {Promise}
  173.      */
  174.     createAccount(configuration) {
  175.         return new Promise(function(resolve, reject) {
  176.             NativeModules.PjSipModule.createAccount(configuration, (successful, data) => {
  177.                 if (successful) {
  178.                     resolve(new Account(data));
  179.                 } else {
  180.                     reject(data);
  181.                 }
  182.             });
  183.         });
  184.     }
  186.     replaceAccount(account, configuration) {
  187.         throw new Error("Not implemented");
  188.     }
  190.     /**
  191.      * Update registration or perform unregistration.
  192.      * If registration is configured for this account, then initial SIP REGISTER will be sent when the account is added.
  193.      * Application normally only need to call this function if it wants to manually update the registration or to unregister from the server.
  194.      *
  195.      * @param {Account} account
  196.      * @param bool renew If renew argument is zero, this will start unregistration process.
  197.      * @returns {Promise}
  198.      */
  199.     registerAccount(account, renew = true) {
  200.         return new Promise(function(resolve, reject) {
  201.             NativeModules.PjSipModule.registerAccount(account.getId(), renew, (successful, data) => {
  202.                 if (successful) {
  203.                     resolve(data);
  204.                 } else {
  205.                     reject(data);
  206.                 }
  207.             });
  208.         });
  209.     }
  211.     /**
  212.      * Delete an account. This will unregister the account from the SIP server, if necessary, and terminate server side presence subscriptions associated with this account.
  213.      *
  214.      * @param {Account} account
  215.      * @returns {Promise}
  216.      */
  217.     deleteAccount(account) {
  218.         return new Promise(function(resolve, reject) {
  219.             NativeModules.PjSipModule.deleteAccount(account.getId(), (successful, data) => {
  220.                 if (successful) {
  221.                     resolve(data);
  222.                 } else {
  223.                     reject(data);
  224.                 }
  225.             });
  226.         });
  227.     }
  229.     /**
  230.      * Make an outgoing call to the specified URI.
  231.      * Available call settings:
  232.      * - audioCount - Number of simultaneous active audio streams for this call. Setting this to zero will disable audio in this call.
  233.      * - videoCount - Number of simultaneous active video streams for this call. Setting this to zero will disable video in this call.
  234.      * -
  235.      *
  236.      * @param account {Account}
  237.      * @param destination {String} Destination SIP URI.
  238.      * @param callSettings {PjSipCallSetttings} Outgoing call settings.
  239.      * @param msgSettings {PjSipMsgData} Outgoing call additional information to be sent with outgoing SIP message.
  240.      */
  241.     makeCall(account, destination, callSettings, msgData) {
  242.         destination = this._normalize(account, destination);
  244.         return new Promise(function(resolve, reject) {
  245.             NativeModules.PjSipModule.makeCall(account.getId(), destination, callSettings, msgData, (successful, data) => {
  246.                 if (successful) {
  247.                     resolve(new Call(data));
  248.                 } else {
  249.                     reject(data);
  250.                 }
  251.             });
  252.         });
  253.     }
  255.     /**
  256.      * Send response to incoming INVITE request.
  257.      *
  258.      * @param call {Call} Call instance
  259.      * @returns {Promise}
  260.      */
  261.     answerCall(call) {
  262.         return new Promise((resolve, reject) => {
  263.             NativeModules.PjSipModule.answerCall(call.getId(), (successful, data) => {
  264.                 if (successful) {
  265.                     resolve(data);
  266.                 } else {
  267.                     reject(data);
  268.                 }
  269.             });
  270.         });
  271.     }
  273.     /**
  274.      * Hangup call by using method that is appropriate according to the call state.
  275.      *
  276.      * @param call {Call} Call instance
  277.      * @returns {Promise}
  278.      */
  279.     hangupCall(call) {
  280.         // TODO: Add possibility to pass code and reason for hangup.
  281.         return new Promise((resolve, reject) => {
  282.             NativeModules.PjSipModule.hangupCall(call.getId(), (successful, data) => {
  283.                 if (successful) {
  284.                     resolve(data);
  285.                 } else {
  286.                     reject(data);
  287.                 }
  288.             });
  289.         });
  290.     }
  292.     /**
  293.      * Hangup call by using Decline (603) method.
  294.      *
  295.      * @param call {Call} Call instance
  296.      * @returns {Promise}
  297.      */
  298.     declineCall(call) {
  299.         return new Promise((resolve, reject) => {
  300.             NativeModules.PjSipModule.declineCall(call.getId(), (successful, data) => {
  301.                 if (successful) {
  302.                     resolve(data);
  303.                 } else {
  304.                     reject(data);
  305.                 }
  306.             });
  307.         });
  308.     }
  310.     /**
  311.      * Put the specified call on hold. This will send re-INVITE with the appropriate SDP to inform remote that the call is being put on hold.
  312.      *
  313.      * @param call {Call} Call instance
  314.      * @returns {Promise}
  315.      */
  316.     holdCall(call) {
  317.         return new Promise((resolve, reject) => {
  318.             NativeModules.PjSipModule.holdCall(call.getId(), (successful, data) => {
  319.                 if (successful) {
  320.                     resolve(data);
  321.                 } else {
  322.                     reject(data);
  323.                 }
  324.             });
  325.         });
  326.     }
  328.     /**
  329.      * Release the specified call from hold. This will send re-INVITE with the appropriate SDP to inform remote that the call is resumed.
  330.      *
  331.      * @param call {Call} Call instance
  332.      * @returns {Promise}
  333.      */
  334.     unholdCall(call) {
  335.         return new Promise((resolve, reject) => {
  336.             NativeModules.PjSipModule.unholdCall(call.getId(), (successful, data) => {
  337.                 if (successful) {
  338.                     resolve(data);
  339.                 } else {
  340.                     reject(data);
  341.                 }
  342.             });
  343.         });
  344.     }
  346.     /**
  347.      * @param call {Call} Call instance
  348.      * @returns {Promise}
  349.      */
  350.     muteCall(call) {
  351.         return new Promise((resolve, reject) => {
  352.             NativeModules.PjSipModule.muteCall(call.getId(), (successful, data) => {
  353.                 if (successful) {
  354.                     resolve(data);
  355.                 } else {
  356.                     reject(data);
  357.                 }
  358.             });
  359.         });
  360.     }
  362.     /**
  363.      * @param call {Call} Call instance
  364.      * @returns {Promise}
  365.      */
  366.     unMuteCall(call) {
  367.         return new Promise((resolve, reject) => {
  368.             NativeModules.PjSipModule.unMuteCall(call.getId(), (successful, data) => {
  369.                 if (successful) {
  370.                     resolve(data);
  371.                 } else {
  372.                     reject(data);
  373.                 }
  374.             });
  375.         });
  376.     }
  378.     /**
  379.      * @param call {Call} Call instance
  380.      * @returns {Promise}
  381.      */
  382.     useSpeaker(call) {
  383.         return new Promise((resolve, reject) => {
  384.             NativeModules.PjSipModule.useSpeaker(call.getId(), (successful, data) => {
  385.                 if (successful) {
  386.                     resolve(data);
  387.                 } else {
  388.                     reject(data);
  389.                 }
  390.             });
  391.         });
  392.     }
  394.     /**
  395.      * @param call {Call} Call instance
  396.      * @returns {Promise}
  397.      */
  398.     useEarpiece(call) {
  399.         return new Promise((resolve, reject) => {
  400.             NativeModules.PjSipModule.useEarpiece(call.getId(), (successful, data) => {
  401.                 if (successful) {
  402.                     resolve(data);
  403.                 } else {
  404.                     reject(data);
  405.                 }
  406.             });
  407.         });
  408.     }
  410.     /**
  411.      * Initiate call transfer to the specified address.
  412.      * This function will send REFER request to instruct remote call party to initiate a new INVITE session to the specified destination/target.
  413.      *
  414.      * @param account {Account} Account associated with call.
  415.      * @param call {Call} The call to be transferred.
  416.      * @param destination URI of new target to be contacted. The URI may be in name address or addr-spec format.
  417.      * @returns {Promise}
  418.      */
  419.     xferCall(account, call, destination) {
  420.         destination = this._normalize(account, destination);
  422.         return new Promise((resolve, reject) => {
  423.             NativeModules.PjSipModule.xferCall(call.getId(), destination, (successful, data) => {
  424.                 if (successful) {
  425.                     resolve(data);
  426.                 } else {
  427.                     reject(data);
  428.                 }
  429.             });
  430.         });
  431.     }
  433.     /**
  434.      * Initiate attended call transfer.
  435.      * This function will send REFER request to instruct remote call party to initiate new INVITE session to the URL of destCall.
  436.      * The party at destCall then should "replace" the call with us with the new call from the REFER recipient.
  437.      *
  438.      * @param call {Call} The call to be transferred.
  439.      * @param destCall {Call} The call to be transferred.
  440.      * @returns {Promise}
  441.      */
  442.     xferReplacesCall(call, destCall) {
  443.         return new Promise((resolve, reject) => {
  444.             NativeModules.PjSipModule.xferReplacesCall(call.getId(), destCall.getId(), (successful, data) => {
  445.                 if (successful) {
  446.                     resolve(data);
  447.                 } else {
  448.                     reject(data);
  449.                 }
  450.             });
  451.         });
  452.     }
  454.     /**
  455.      * Redirect (forward) specified call to destination.
  456.      * This function will send response to INVITE to instruct remote call party to redirect incoming call to the specified destination/target.
  457.      *
  458.      * @param account {Account} Account associated with call.
  459.      * @param call {Call} The call to be transferred.
  460.      * @param destination URI of new target to be contacted. The URI may be in name address or addr-spec format.
  461.      * @returns {Promise}
  462.      */
  463.     redirectCall(account, call, destination) {
  464.         destination = this._normalize(account, destination);
  466.         return new Promise((resolve, reject) => {
  467.             NativeModules.PjSipModule.redirectCall(call.getId(), destination, (successful, data) => {
  468.                 if (successful) {
  469.                     resolve(data);
  470.                 } else {
  471.                     reject(data);
  472.                 }
  473.             });
  474.         });
  475.     }
  477.     /**
  478.      * Send DTMF digits to remote using RFC 2833 payload formats.
  479.      *
  480.      * @param call {Call} Call instance
  481.      * @param digits {String} DTMF string digits to be sent as described on RFC 2833 section 3.10.
  482.      * @returns {Promise}
  483.      */
  484.     dtmfCall(call, digits) {
  485.         return new Promise((resolve, reject) => {
  486.             NativeModules.PjSipModule.dtmfCall(call.getId(), digits, (successful, data) => {
  487.                 if (successful) {
  488.                     resolve(data);
  489.                 } else {
  490.                     reject(data);
  491.                 }
  492.             });
  493.         });
  494.     }
  496.     activateAudioSession() {
  497.         return new Promise((resolve, reject) => {
  498.             NativeModules.PjSipModule.activateAudioSession((successful, data) => {
  499.                 if (successful) {
  500.                     resolve(data);
  501.                 } else {
  502.                     reject(data);
  503.                 }
  504.             });
  505.         });
  506.     }
  508.     deactivateAudioSession() {
  509.         return new Promise((resolve, reject) => {
  510.             NativeModules.PjSipModule.deactivateAudioSession((successful, data) => {
  511.                 if (successful) {
  512.                     resolve(data);
  513.                 } else {
  514.                     reject(data);
  515.                 }
  516.             });
  517.         });
  518.     }
  520.     changeOrientation(orientation) {
  521.       const orientations = [
  522.         'PJMEDIA_ORIENT_UNKNOWN',
  523.         'PJMEDIA_ORIENT_ROTATE_90DEG',
  524.         'PJMEDIA_ORIENT_ROTATE_270DEG',
  525.         'PJMEDIA_ORIENT_ROTATE_180DEG',
  526.         'PJMEDIA_ORIENT_NATURAL'
  527.       ]
  529.       if (orientations.indexOf(orientation) === -1) {
  530.         throw new Error(`Invalid ${JSON.stringify(orientation)} device orientation, but expected ${orientations.join(", ")} values`)
  531.       }
  533.       NativeModules.PjSipModule.changeOrientation(orientation)
  534.     }
  536.     changeCodecSettings(codecSettings) {
  537.         return new Promise(function(resolve, reject) {
  538.         NativeModules.PjSipModule.changeCodecSettings(codecSettings, (successful, data) => {
  539.                 if (successful) {
  540.                     resolve(data);
  541.                 } else {
  542.                     reject(data);
  543.                 }
  544.             });
  545.         });
  546.     }
  548.     /**
  549.      * @fires Endpoint#connectivity_changed
  550.      * @private
  551.      * @param data {Object}
  552.      */
  553.     _onConnectivityChanged(data) {
  554.         /**
  555.          * Fires when registration status has changed.
  556.          *
  557.          * @event Endpoint#connectivity_changed
  558.          * @property {Account} account
  559.          */
  560.         this.emit("connectivity_changed", new Account(data));
  561.     }
  563.     /**
  564.      * @fires Endpoint#registration_changed
  565.      * @private
  566.      * @param data {Object}
  567.      */
  568.     _onRegistrationChanged(data) {
  569.         /**
  570.          * Fires when registration status has changed.
  571.          *
  572.          * @event Endpoint#registration_changed
  573.          * @property {Account} account
  574.          */
  575.         this.emit("registration_changed", new Account(data));
  576.     }
  578.     /**
  579.      * @fires Endpoint#call_received
  580.      * @private
  581.      * @param data {Object}
  582.      */
  583.     _onCallReceived(data) {
  584.         /**
  585.          * TODO
  586.          *
  587.          * @event Endpoint#call_received
  588.          * @property {Call} call
  589.          */
  590.         this.emit("call_received", new Call(data));
  591.     }
  593.     /**
  594.      * @fires Endpoint#call_changed
  595.      * @private
  596.      * @param data {Object}
  597.      */
  598.     _onCallChanged(data) {
  599.         /**
  600.          * TODO
  601.          *
  602.          * @event Endpoint#call_changed
  603.          * @property {Call} call
  604.          */
  605.         this.emit("call_changed", new Call(data));
  606.     }
  608.     /**
  609.      * @fires Endpoint#call_terminated
  610.      * @private
  611.      * @param data {Object}
  612.      */
  613.     _onCallTerminated(data) {
  614.         /**
  615.          * TODO
  616.          *
  617.          * @event Endpoint#call_terminated
  618.          * @property {Call} call
  619.          */
  620.         this.emit("call_terminated", new Call(data));
  621.     }
  623.     /**
  624.      * @fires Endpoint#call_screen_locked
  625.      * @private
  626.      * @param lock bool
  627.      */
  628.     _onCallScreenLocked(lock) {
  629.         /**
  630.          * TODO
  631.          *
  632.          * @event Endpoint#call_screen_locked
  633.          * @property bool lock
  634.          */
  635.         this.emit("call_screen_locked", lock);
  636.     }
  638.     /**
  639.      * @fires Endpoint#message_received
  640.      * @private
  641.      * @param data {Object}
  642.      */
  643.     _onMessageReceived(data) {
  644.         /**
  645.          * TODO
  646.          *
  647.          * @event Endpoint#message_received
  648.          * @property {Message} message
  649.          */
  650.         this.emit("message_received", new Message(data));
  651.     }
  653.     /**
  654.      * @fires Endpoint#connectivity_changed
  655.      * @private
  656.      * @param available bool
  657.      */
  658.     _onConnectivityChanged(available) {
  659.         /**
  660.          * @event Endpoint#connectivity_changed
  661.          * @property bool available True if connectivity matches current Network settings, otherwise false.
  662.          */
  663.         this.emit("connectivity_changed", available);
  664.     }
  666.     /**
  667.      * Normalize Destination URI
  668.      *
  669.      * @param account
  670.      * @param destination {string}
  671.      * @returns {string}
  672.      * @private
  673.      */
  674.     _normalize(account, destination) {
  675.         if (!destination.startsWith("sip:")) {
  676.             let realm = account.getRegServer();
  678.             if (!realm) {
  679.                 realm = account.getDomain();
  680.                 let s = realm.indexOf(":");
  682.                 if (s > 0) {
  683.                     realm = realm.substr(0, s + 1);
  684.                 }
  685.             }
  687.             destination = "sip:" + destination + "@" + realm;
  688.         }
  690.         return destination;
  691.     }
  692.     // setUaConfig(UaConfig value)
  693.     // setMaxCalls
  694.     // setUserAgent
  695.     // setNatTypeInSdp
  697.     // setLogConfig(LogConfig value)
  698.     // setLevel
  699. }