@voicenter-team/opensips-js 1.0.21 → 1.0.22

package/build/enum/message.event.listener.type.d.ts

@@ -0,0 +1,5 @@
+export declare const MESSAGE_EVENT_LISTENER_TYPE: {
+    ACTIVE: string;
+    FAILED: string;
+    ENDED: string;
+};

package/build/enum/message.event.listener.type.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MESSAGE_EVENT_LISTENER_TYPE = void 0;
+exports.MESSAGE_EVENT_LISTENER_TYPE = {
+    ACTIVE: 'active',
+    FAILED: 'failed',
+    ENDED: 'ended'
+};

package/build/enum/session.direction.enum.d.ts

@@ -0,0 +1,2 @@
+import { SessionDirection } from 'jssip/lib/RTCSession';
+export { SessionDirection };

package/build/enum/session.direction.enum.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionDirection = void 0;
+const RTCSession_1 = require("jssip/lib/RTCSession");
+Object.defineProperty(exports, "SessionDirection", { enumerable: true, get: function () { return RTCSession_1.SessionDirection; } });

package/build/helpers/UA/index.d.ts

@@ -1,6 +1,41 @@
-import { UA } from 'jssip';
+import { MSRPOptions, UAConfiguration, UA as UAType } from 'jssip';
+import { Originator, RTCSession } from 'jssip/lib/RTCSession';
+import { IncomingRequest } from 'jssip/lib/SIPMessage';
+import { MSRPSession } from '../../lib/msrp/session';
 import { CallOptionsExtended } from '@/types/rtc';
-import { RTCSession } from 'jssip/lib/RTCSession';
-export default class UAExtended extends UA {
+export interface IncomingMSRPSessionEvent {
+    originator: Originator.REMOTE;
+    session: MSRPSession;
+    request: IncomingRequest;
+}
+export interface OutgoingMSRPSessionEvent {
+    originator: Originator.LOCAL;
+    session: MSRPSession;
+    request: IncomingRequest;
+}
+export type MSRPSessionEvent = IncomingMSRPSessionEvent | OutgoingMSRPSessionEvent;
+declare const UAConstructor: typeof UAType;
+export default class UAExtended extends UAConstructor {
+    _msrp_sessions: MSRPSession[];
+    _transactions: {
+        nist: {};
+        nict: {};
+        ist: {};
+        ict: {};
+    };
+    constructor(configuration: UAConfiguration);
     call(target: string, options?: CallOptionsExtended): RTCSession;
+    /**
+     * new MSRPSession
+     */
+    newMSRPSession(session: MSRPSession, data: object): void;
+    /**
+     * MSRPSession destroyed.
+     */
+    destroyMSRPSession(session: MSRPSession): void;
+    receiveRequest(request: any): void;
+    startMSRP(target: string, options: MSRPOptions): MSRPSession;
+    terminateMSRPSessions(options: object): void;
+    stop(): void;
 }
+export {};

package/build/helpers/UA/index.js

@@ -1,9 +1,318 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const jssip_1 = require("jssip");
-class UAExtended extends jssip_1.UA {
+const UA_1 = __importDefault(require("jssip/lib/UA"));
+const JsSIP_C = __importStar(require("jssip/lib/Constants"));
+const Transactions_1 = __importDefault(require("jssip/lib/Transactions"));
+const session_1 = require("../../lib/msrp/session");
+const logger = console;
+const C = {
+    // UA status codes.
+    STATUS_INIT: 0,
+    STATUS_READY: 1,
+    STATUS_USER_CLOSED: 2,
+    STATUS_NOT_READY: 3,
+    // UA error codes.
+    CONFIGURATION_ERROR: 1,
+    NETWORK_ERROR: 2
+};
+const UAConstructor = UA_1.default;
+class UAExtended extends UAConstructor {
+    constructor(configuration) {
+        console.log(configuration);
+        // const _proto = configuration.uri.split(':').shift()
+        // const _user = (configuration.uri.split(':').pop()).split('@').shift()
+        // const _realm = (configuration.uri.split(':').pop()).split('@').pop()
+        // configuration.uri = URI.parse(configuration.uri)
+        super(configuration);
+        this._msrp_sessions = [];
+        this._transactions = { nist: {},
+            nict: {},
+            ist: {},
+            ict: {}
+        };
+        // console.log(configuration.uri)
+    }
     call(target, options) {
         return super.call(target, options);
     }
+    /**
+     * new MSRPSession
+     */
+    newMSRPSession(session, data) {
+        // Listening for message history update
+        session.on('msgHistoryUpdate', (obj) => {
+            console.log(obj);
+        });
+        this._msrp_sessions[session.id] = session;
+        this.emit('newMSRPSession', data);
+    }
+    /**
+     * MSRPSession destroyed.
+     */
+    destroyMSRPSession(session) {
+        delete this._msrp_sessions[session.id];
+    }
+    receiveRequest(request) {
+        const method = request.method;
+        console.log('-----------');
+        // Check that request URI points to us.
+        if (request.ruri.user !== this._configuration.uri.user &&
+            request.ruri.user !== this._contact.uri.user) {
+            logger.debug('Request-URI does not point to us');
+            if (request.method !== JsSIP_C.ACK) {
+                request.reply_sl(404);
+            }
+            return;
+        }
+        // Check request URI scheme.
+        if (request.ruri.scheme === JsSIP_C.SIPS) {
+            request.reply_sl(416);
+            return;
+        }
+        // Check transaction.
+        if (Transactions_1.default.checkTransaction(this, request)) {
+            return;
+        }
+        // Create the server transaction.
+        if (method === JsSIP_C.INVITE) {
+            /* eslint-disable no-new */
+            new Transactions_1.default.InviteServerTransaction(this, this._transport, request);
+            /* eslint-enable no-new */
+        }
+        else if (method !== JsSIP_C.ACK && method !== JsSIP_C.CANCEL) {
+            /* eslint-disable no-new */
+            new Transactions_1.default.NonInviteServerTransaction(this, this._transport, request);
+            /* eslint-enable no-new */
+        }
+        /* RFC3261 12.2.2
+         * Requests that do not change in any way the state of a dialog may be
+         * received within a dialog (for example, an OPTIONS request).
+         * They are processed as if they had been received outside the dialog.
+         */
+        if (method === JsSIP_C.OPTIONS) {
+            if (this.listeners('newOptions').length === 0) {
+                request.reply(200);
+                return;
+            }
+            const message = new jssip_1.Options(this);
+            message.init_incoming(request);
+        }
+        else if (method === JsSIP_C.MESSAGE) {
+            if (this.listeners('newMessage').length === 0) {
+                request.reply(405);
+                return;
+            }
+            const message = new jssip_1.Message(this);
+            message.init_incoming(request);
+        }
+        else if (method === JsSIP_C.INVITE) {
+            // Initial INVITE.
+            if (!request.to_tag && this.listeners('newRTCSession').length === 0) {
+                request.reply(405);
+                return;
+            }
+        }
+        let dialog;
+        let session;
+        // Initial Request.
+        if (!request.to_tag) {
+            switch (method) {
+                case JsSIP_C.INVITE:
+                    if (window.RTCPeerConnection) { // TODO
+                        if (request.hasHeader('replaces')) {
+                            const replaces = request.replaces;
+                            dialog = this._findDialog(replaces.call_id, replaces.from_tag, replaces.to_tag);
+                            if (dialog) {
+                                session = dialog.owner;
+                                if (!session.isEnded()) {
+                                    session.receiveRequest(request);
+                                }
+                                else {
+                                    request.reply(603);
+                                }
+                            }
+                            else {
+                                request.reply(481);
+                            }
+                        }
+                        else {
+                            if (request.body.search(/MSRP/ig)) {
+                                session = new session_1.MSRPSession(this);
+                                session.init_incoming(request);
+                            }
+                            else {
+                                session = new jssip_1.RTCSessiono(this);
+                                session.init_incoming(request);
+                            }
+                        }
+                    }
+                    else {
+                        logger.warn('INVITE received but WebRTC is not supported');
+                        request.reply(488);
+                    }
+                    break;
+                case JsSIP_C.BYE:
+                    // Out of dialog BYE received.
+                    request.reply(481);
+                    break;
+                case JsSIP_C.CANCEL:
+                    session = this._findSession(request);
+                    if (session) {
+                        session.receiveRequest(request);
+                    }
+                    else {
+                        logger.debug('received CANCEL request for a non existent session');
+                    }
+                    break;
+                case JsSIP_C.ACK:
+                    /* Absorb it.
+                     * ACK request without a corresponding Invite Transaction
+                     * and without To tag.
+                     */
+                    break;
+                case JsSIP_C.NOTIFY:
+                    // Receive new sip event.
+                    this.emit('sipEvent', {
+                        event: request.event,
+                        request
+                    });
+                    request.reply(200);
+                    break;
+                default:
+                    request.reply(405);
+                    break;
+            }
+        }
+        // In-dialog request.
+        else {
+            dialog = this._findDialog(request.call_id, request.from_tag, request.to_tag);
+            if (dialog) {
+                dialog.receiveRequest(request);
+            }
+            else if (method === JsSIP_C.NOTIFY) {
+                session = this._findSession(request);
+                if (session) {
+                    session.receiveRequest(request);
+                }
+                else {
+                    logger.debug('received NOTIFY request for a non existent subscription');
+                    request.reply(481, 'Subscription does not exist');
+                }
+            }
+            /* RFC3261 12.2.2
+             * Request with to tag, but no matching dialog found.
+             * Exception: ACK for an Invite request for which a dialog has not
+             * been created.
+             */
+            else if (method !== JsSIP_C.ACK) {
+                request.reply(481);
+            }
+        }
+    }
+    startMSRP(target, options) {
+        logger.debug('startMSRP()', options);
+        const session = new session_1.MSRPSession(this);
+        session.connect(target);
+        return session;
+    }
+    terminateMSRPSessions(options) {
+        logger.debug('terminateSessions()');
+        for (const idx in this._msrp_sessions) {
+            if (!this._msrp_sessions[idx].isEnded()) {
+                this._msrp_sessions[idx].terminate(options);
+            }
+        }
+    }
+    stop() {
+        logger.debug('stop()');
+        // Remove dynamic settings.
+        this._dynConfiguration = {};
+        if (this._status === C.STATUS_USER_CLOSED) {
+            logger.debug('UA already closed');
+            return;
+        }
+        // Close registrator.
+        this._registrator.close();
+        // If there are session wait a bit so CANCEL/BYE can be sent and their responses received.
+        const num_sessions = Object.keys(this._sessions).length;
+        // Run  _terminate_ on every Session.
+        for (const session in this._sessions) {
+            if (Object.prototype.hasOwnProperty.call(this._sessions, session)) {
+                logger.debug(`closing session ${session}`);
+                try {
+                    this._sessions[session].terminate();
+                }
+                catch (error) {
+                    console.error(error);
+                }
+            }
+        }
+        // If there are session wait a bit so CANCEL/BYE can be sent and their responses received.
+        // const num_msrp_sessions = Object.keys(this._msrp_sessions).length
+        // Run  _terminate_ on every Session.
+        for (const msrp_session in this._msrp_sessions) {
+            if (Object.prototype.hasOwnProperty.call(this._msrp_sessions, msrp_session)) {
+                logger.debug(`closing session ${msrp_session}`);
+                try {
+                    this._msrp_sessions[msrp_session].terminate();
+                }
+                catch (error) {
+                    console.error(error);
+                }
+            }
+        }
+        // Run  _close_ on every applicant.
+        for (const applicant in this._applicants) {
+            if (Object.prototype.hasOwnProperty.call(this._applicants, applicant)) {
+                try {
+                    this._applicants[applicant].close();
+                }
+                catch (error) {
+                    console.error(error);
+                }
+            }
+        }
+        this._status = C.STATUS_USER_CLOSED;
+        const num_transactions = Object.keys(this._transactions.nict).length +
+            Object.keys(this._transactions.nist).length +
+            Object.keys(this._transactions.ict).length +
+            Object.keys(this._transactions.ist).length;
+        if (num_transactions === 0 && num_sessions === 0) {
+            this._transport.disconnect();
+        }
+        else {
+            this._closeTimer = setTimeout(() => {
+                this._closeTimer = null;
+                this._transport.disconnect();
+            }, 2000);
+        }
+    }
 }
 exports.default = UAExtended;

package/build/helpers/audio.helper.d.ts

@@ -1,9 +1,15 @@
-import { ICall, MediaEvent } from '@/types/rtc';
+import { ICall, MediaEvent, CustomLoggerType } from '@/types/rtc';
 import { Writeable } from '@/types/generic';
+import { IMessage } from '@/types/msrp';
 type ICallKey = keyof ICall;
 declare const CALL_KEYS_TO_INCLUDE: Array<ICallKey>;
+type IMessageKey = keyof IMessage;
+declare const MESSAGE_KEYS_TO_INCLUDE: Array<IMessageKey>;
 export type ICallSimplified = Writeable<Pick<ICall, typeof CALL_KEYS_TO_INCLUDE[number]>>;
+export type IMessageSimplified = Writeable<Pick<IMessage, typeof MESSAGE_KEYS_TO_INCLUDE[number]>>;
 export declare function simplifyCallObject(call: ICall): ICallSimplified;
+export declare function simplifyMessageObject(call: IMessage): IMessageSimplified;
 export declare function processAudioVolume(stream: MediaStream, volume: number): MediaStream;
 export declare function syncStream(event: MediaEvent, call: ICall, outputDevice: string, volume: number): void;
+export declare function isLoggerCompatible(logger: CustomLoggerType): true | undefined;
 export {};

package/build/helpers/audio.helper.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.syncStream = exports.processAudioVolume = exports.simplifyCallObject = void 0;
+exports.isLoggerCompatible = exports.syncStream = exports.processAudioVolume = exports.simplifyMessageObject = exports.simplifyCallObject = void 0;
 const CALL_KEYS_TO_INCLUDE = [
     'roomId',
     '_audioMuted',
@@ -26,6 +26,23 @@ const CALL_KEYS_TO_INCLUDE = [
     'localMuted',
     'autoAnswer'
 ];
+const MESSAGE_KEYS_TO_INCLUDE = [
+    //'roomId',
+    '_cancel_reason',
+    '_contact',
+    'direction',
+    '_end_time',
+    '_eventsCount',
+    '_from_tag',
+    '_id',
+    '_is_canceled',
+    '_is_confirmed',
+    '_late_sdp',
+    'status',
+    'start_time',
+    '_remote_identity',
+    'target_addr'
+];
 function simplifyCallObject(call) {
     const simplified = {};
     CALL_KEYS_TO_INCLUDE.forEach(key => {
@@ -37,6 +54,16 @@ function simplifyCallObject(call) {
     return simplified;
 }
 exports.simplifyCallObject = simplifyCallObject;
+function simplifyMessageObject(call) {
+    const simplified = {};
+    MESSAGE_KEYS_TO_INCLUDE.forEach(key => {
+        if (call[key] !== undefined) {
+            simplified[key] = call[key];
+        }
+    });
+    return simplified;
+}
+exports.simplifyMessageObject = simplifyMessageObject;
 function processAudioVolume(stream, volume) {
     const audioContext = new AudioContext();
     const audioSource = audioContext.createMediaStreamSource(stream);
@@ -59,3 +86,12 @@ function syncStream(event, call, outputDevice, volume) {
     call.audioTag = audio;
 }
 exports.syncStream = syncStream;
+function isLoggerCompatible(logger) {
+    if (logger
+        && typeof logger.log === 'function'
+        && typeof logger.warn === 'function'
+        && typeof logger.error === 'function') {
+        return true;
+    }
+}
+exports.isLoggerCompatible = isLoggerCompatible;

package/build/helpers/jssip.d.ts

@@ -0,0 +1,5 @@
+import JsSIP, { UA } from 'jssip';
+import { IncomingAckEvent, IncomingEvent, OutgoingAckEvent, OutgoingEvent } from 'jssip/lib/RTCSession';
+import { RTCSessionEvent, UAConfiguration, UAEventMap } from 'jssip/lib/UA';
+export default JsSIP;
+export { UA, IncomingAckEvent, IncomingEvent, OutgoingAckEvent, OutgoingEvent, RTCSessionEvent, UAConfiguration, UAEventMap };

package/build/helpers/jssip.js

@@ -0,0 +1,30 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UA = void 0;
+// @ts-nocheck
+const jssip_1 = __importStar(require("jssip"));
+Object.defineProperty(exports, "UA", { enumerable: true, get: function () { return jssip_1.UA; } });
+exports.default = jssip_1.default;