surflion-service 1.5.2 → 1.5.4

package/package.json

@@ -1,11 +1,27 @@
 {
   "name": "surflion-service",
-  "version": "1.5.2",
-  "description": "SurfLion WebRTC Service Library with integrated JsSIP for real-time communication",
+  "version": "1.5.4",
+  "description": "SurfLion WebRTC Library",
+  "type": "module",
   "main": "surflion.js",
+  "module": "surflion.js",
+  "browser": "dist/surflion.min.js",
+  "unpkg": "dist/surflion.js",
+  "jsdelivr": "dist/surflion.js",
+  "types": "surflion.d.ts",
+  "exports": {
+    ".": {
+      "types": "./surflion.d.ts",
+      "import": "./surflion.js",
+      "require": "./surflion.js",
+      "browser": "./dist/surflion.min.js",
+      "default": "./surflion.js"
+    }
+  },
   "files": [
     "surflion.js",
-    "surflion.min.js"
+    "surflion.d.ts",
+    "dist/"
   ],
   "keywords": [
     "webrtc",

package/surflion.d.ts

@@ -0,0 +1,178 @@
+// TypeScript declarations for SurfLion WebRTC Library
+
+declare module 'surflion-service' {
+  export default SurfLion;
+}
+
+/**
+ * Call type enumeration
+ */
+export enum CallTypeEnum {
+  INIT = 0,
+  PREDICTIVE_OUTBOUND = 10,
+}
+
+/**
+ * Call information interface
+ */
+export interface CallInfo {
+  CallNumber: string;
+  [key: string]: any;
+}
+
+/**
+ * User list item interface
+ */
+export interface UserListItem {
+  value: string;
+  label: string;
+}
+
+/**
+ * Media constraints interface
+ */
+export interface MediaConstraints {
+  audio: boolean;
+  video: boolean;
+}
+
+/**
+ * Position configuration interface
+ */
+export interface PositionConfig {
+  position?: number;
+  positionX?: string;
+  positionY?: string;
+}
+
+/**
+ * Event handler function types
+ */
+export type EventHandler = () => void;
+export type CallEventHandler = (callInfo: CallInfo) => void;
+
+/**
+ * Main SurfLion interface
+ */
+export interface SurfLionInterface {
+  // Version and configuration
+  version: string;
+  showAll: boolean;
+  
+  // Session management
+  outgoingSession: any | null;
+  incomingSession: any | null;
+  currentSession: any | null;
+  vCallTimerId: any | null;
+  
+  // Audio/Video settings
+  microphone: boolean;
+  outgoing: boolean;
+  constraints: MediaConstraints;
+  localStream: HTMLAudioElement | null;
+  ringtoneStream: HTMLAudioElement | null;
+  hangupStream: HTMLAudioElement | null;
+  
+  // SIP configuration
+  ext_num: string;
+  sip_uri_: string;
+  sip_password_: string;
+  ws_uri_: string;
+  userAgent: any | null;
+  
+  // Status and state
+  debug: boolean;
+  agentStatus: boolean;
+  canIncoming: boolean;
+  phoneEnded: boolean;
+  phoneState: string;
+  callingState: string;
+  floatWindowState: boolean;
+  phoneToward: string;
+  phoneCallingTime: string;
+  phoneResult: boolean;
+  
+  // UI positioning
+  vPosition: number;
+  vDirection: boolean;
+  positionX: string;
+  positionY: string;
+  
+  // Data and identification
+  userList: UserListItem[];
+  showPhoneNumber: string;
+  callID: string;
+  endReason: string;
+  pageError: string;
+  CallType: number;
+  XUuid: string;
+  worker: any | null;
+  
+  // Event handlers
+  onRegister: EventHandler;
+  onUnRegister: EventHandler;
+  onRegisterFail: EventHandler;
+  onCallBegin: EventHandler;
+  onCallAnswer: EventHandler;
+  onCallEnd: EventHandler;
+  onCallIn: CallEventHandler;
+  
+  // UI management methods
+  closeVCalling(): void;
+  createVCalling(callInfo: CallInfo): void;
+  closeVAnswer(): void;
+  createVAnswer(callInfo: CallInfo): void;
+  createVError(position: number, positionX: string, positionY: string): void;
+  closeVError(): void;
+  createVEnd(): void;
+  closeVEnd(): void;
+  closeVCall(): void;
+  createVCall(): void;
+  closeVKeyboard(): void;
+  createVKeyboard(show: boolean): void;
+  
+  // SIP methods
+  sipRegister(
+    sip_uri_: string,
+    sip_password_: string,
+    ws_uri_: string,
+    show: boolean,
+    ext_num: string,
+    direction: boolean,
+    floatWindowState: boolean,
+    position: number,
+    positionX: string,
+    positionY: string,
+    ringtoneStream?: string,
+    hangupStream?: string
+  ): void;
+  
+  sipUnRegister(): void;
+  sipCall(sip_phone_number_: string): void;
+  sipAnswer(): void;
+  sipHangUp(): void;
+  
+  // Utility methods
+  findName(value: string): string;
+  sipInitAddress(list: UserListItem[]): void;
+  sipMute(): void;
+  sipUnmute(): void;
+  sipMuteAudio(): void;
+  sipUnmuteAudio(): void;
+  sipLogout(): void;
+  sipShowHidden(): void;
+  sipCloseFloat(): void;
+  
+  // SharedWorker methods
+  initSharework(address: string): void;
+  visibilityListen(address: string): void;
+  closeShareWork(): void;
+  closeAllPage(state: boolean): void;
+}
+
+/**
+ * Main SurfLion object
+ */
+declare const SurfLion: SurfLionInterface;
+
+export default SurfLion;

package/surflion.js

@@ -1,5 +1,13 @@
 import JsSIP from 'jssip'
-var SurfLion = {
+
+const CallTypeEnum = {
+    INIT: 0,
+    PREDICTIVE_OUTBOUND: 10,
+    APP_OUT_CALL: 11,
+    API_OUT_CALL: 12,
+};
+
+const SurfLion = {
     version: process.env.PACKAGE_VERSION,
     showAll: true,
     outgoingSession: null,
@@ -39,7 +47,51 @@ var SurfLion = {
     phoneToward: 'in',
     phoneCallingTime: '0',
     phoneResult: false,
+    phoneAnswerTime: '',
     worker: null,
+    CallType: CallTypeEnum.INIT,
+    XUuid: '',
+    preferOpus: function(sdp) {
+        var sdpLines = sdp.split('\r\n');
+        var mLineIndex = -1;
+        for (var i = 0; i < sdpLines.length; i++) {
+            if (sdpLines[i].search('m=audio') !== -1) {
+                mLineIndex = i;
+                break;
+            }
+        }
+        if (mLineIndex === -1) return sdp;
+
+        for (var i = 0; i < sdpLines.length; i++) {
+            if (sdpLines[i].search('opus/48000') !== -1) {
+                var opusPayload = extractPayloadType(sdpLines[i]);
+                if (opusPayload) {
+                    sdpLines[mLineIndex] = removePayloadType(sdpLines[mLineIndex], opusPayload);
+                    var parts = sdpLines[mLineIndex].split(' ');
+                    parts.splice(3, 0, opusPayload);
+                    sdpLines[mLineIndex] = parts.join(' ');
+                }
+            }
+        }
+        return sdpLines.join('\r\n');
+
+        function extractPayloadType(line) {
+            var pattern = /a=rtpmap:(\d+) opus\/48000/;
+            var result = line.match(pattern);
+            return (result && result.length == 2) ? result[1] : null;
+        }
+
+        function removePayloadType(line, payload) {
+            var parts = line.split(' ');
+            for (var i = 3; i < parts.length; i++) {
+                if (parts[i] == payload) {
+                    parts.splice(i, 1);
+                    i--;
+                }
+            }
+            return parts.join(' ');
+        }
+    },
     onRegister: function () {
     },
     onUnRegister: function () {
@@ -236,7 +288,7 @@ var SurfLion = {
         let seconds = 0;
         let minutes = 0;
         let hours = 0;
-
+        SurfLion.phoneAnswerTime = Date.now();
         SurfLion.vCallTimerId = setInterval(function () {
             seconds++;
 
@@ -1080,7 +1132,7 @@ var SurfLion = {
         })
     },
     addVKeydown(event){
-        var keyPressed = event.key;
+        const keyPressed = event.key;
         if (keyPressed >= '0' && keyPressed <= '9') {
             SurfLion.addToPhoneNumber(keyPressed)
         }
@@ -1353,7 +1405,6 @@ var SurfLion = {
                 CallNumber : e.request.from._display_name
             }
 
-
             if(SurfLion.ext_num == e.request.from._display_name) {
                 SurfLion.endReason = 'Cannot call oneself '
                 SurfLion.sipHangUp()
@@ -1363,6 +1414,15 @@ var SurfLion = {
                 SurfLion.createVAnswer(callInfo)
             }
             
+            const CallType = e.request.getHeader('Call-Type');
+            if (CallType) {
+                SurfLion.CallType = +CallType || 0;
+            }
+            const XUuid = e.request.getHeader('X-Uuid');
+            if (XUuid) {
+                SurfLion.XUuid = XUuid;
+            }
+
             window.localStorage.setItem("surflion_registered", '3');
             const event = new Event('localStorageSurflionChange');
             window.dispatchEvent(event);
@@ -1435,6 +1495,10 @@ var SurfLion = {
 
             SurfLion.microphone = true
             SurfLion.outgoing = true
+
+            SurfLion.CallType = CallTypeEnum.INIT;
+            SurfLion.XUuid = '';
+
             window.localStorage.setItem("surflion_registered", '1');
             const event = new Event('localStorageSurflionChange');
             window.localStorage.setItem("localStorageSurflionCall", '0');
@@ -1480,14 +1544,13 @@ var SurfLion = {
             document.body.appendChild(SurfLion.hangupStream);
         }
         
-        var socket = new JsSIP.WebSocketInterface(ws_uri_);
-        var configuration = {
+        const socket = new JsSIP.WebSocketInterface(ws_uri_);
+        const configuration = {
             sockets: [socket],
             uri: sip_uri_,
             password: sip_password_,
             register: true,
             session_timers: false,
-            iceServers: [],
             contact_uri: sip_uri_ + ';transport=wss'
         };
 
@@ -1520,6 +1583,14 @@ var SurfLion = {
         });
         SurfLion.userAgent.on('newRTCSession', function (data) {
             
+            // Force the use of OPUS encoding as the preferred method.
+            const session = data.session;
+            session.on('sdp', function(e) {
+                if (e.originator === 'local') {
+                    e.sdp = SurfLion.preferOpus(e.sdp);
+                }
+            });
+
             if (data.originator == 'remote') {
                 if (!SurfLion.canIncoming){
                     return
@@ -1629,9 +1700,18 @@ var SurfLion = {
 
     sipAnswer: function () {
         if (SurfLion.incomingSession) {
-            SurfLion.incomingSession.answer({
-                'mediaConstraints': {'audio': true, 'video': false},
-            });
+            try {
+                // Check if session is already ended or not in a valid state
+                if (SurfLion.incomingSession.isEnded()) {
+                    console.warn('SurfLion: Session already ended, cannot answer.');
+                    return;
+                }
+                SurfLion.incomingSession.answer({
+                    'mediaConstraints': {'audio': true, 'video': false},
+                });
+            } catch (error) {
+                console.error('SurfLion: Error answering call:', error);
+            }
         }
     },
     sipHangUp: function () {