@signalwire/js 1.3.0-dev.1 → 1.4.0

package/dist/esm/common/src/webrtc/VertoHandler.js

@@ -9,164 +9,204 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import logger from '../util/logger';
 import Call from './Call';
+import { checkSubscribeResponse } from './helpers';
 import { Result } from '../messages/Verto';
 import { SwEvent } from '../util/constants';
-import { VertoMethod, Notification, Direction } from './constants';
-import { trigger } from '../services/Handler';
-import { State } from './constants';
-import { checkIsDirectCall } from './helpers';
-const _handlePvtEvent = (session, pvtData) => __awaiter(void 0, void 0, void 0, function* () {
-    const { action, callID } = pvtData;
-    if (!callID || !session.calls[callID]) {
-        return logger.debug('Verto pvtData with invalid or unknown callID.', pvtData);
+import { VertoMethod, NOTIFICATION_TYPE } from './constants';
+import { trigger, deRegister } from '../services/Handler';
+import { State, ConferenceAction } from './constants';
+import { MCULayoutEventHandler } from './LayoutHandler';
+class VertoHandler {
+    constructor(session) {
+        this.session = session;
     }
-    const call = session.calls[callID];
-    if (call.options.skipLiveArray) {
-        return logger.debug('Skip liveArray pvtData for', callID, pvtData);
-    }
-    switch (action) {
-        case 'conference-liveArray-join':
-            yield call.conferenceJoinHandler(pvtData);
-            break;
-        case 'conference-liveArray-part':
-            yield call.conferencePartHandler(pvtData);
-            break;
-    }
-});
-const _handleSessionEvent = (session, eventData) => {
-    const { contentType, callID } = eventData;
-    if (!callID || !session.calls.hasOwnProperty(callID)) {
-        return logger.debug('Unhandled session event:', eventData);
-    }
-    const call = session.calls[callID];
-    switch (contentType) {
-        case 'layout-info':
-        case 'layer-info':
-            call.updateLayouts(eventData);
-            break;
-        case 'logo-info':
-            call.updateLogo(eventData);
-            break;
-        case 'caption-info':
-            call.handleCaptionInfo(eventData);
-            break;
-        case 'conference-info':
-            call.handleConferenceInfo(eventData);
-            break;
-    }
-};
-const _buildCall = (session, params, attach, nodeId) => {
-    let remoteCallerName = params.caller_id_name;
-    let remoteCallerNumber = params.caller_id_number;
-    let callerName = params.callee_id_name;
-    let callerNumber = params.callee_id_number;
-    if (params.display_direction === Direction.Inbound) {
-        remoteCallerName = params.callee_id_name;
-        remoteCallerNumber = params.callee_id_number;
-        callerName = params.caller_id_name;
-        callerNumber = params.caller_id_number;
-    }
-    const call = new Call(session, {
-        id: params.callID,
-        remoteSdp: params.sdp,
-        destinationNumber: params.callee_id_number,
-        remoteCallerName,
-        remoteCallerNumber,
-        callerName,
-        callerNumber,
-        attach,
-        secondSource: /;second-source$/.test(params.callee_id_number),
-        screenShare: /;screen$/.test(params.callee_id_number),
-        shakenCheck: params.shaken_check || '',
-        shakenResult: params.shaken_result || '',
-    });
-    const hasAudioLine = params.sdp.indexOf('m=audio') !== -1;
-    if (!hasAudioLine) {
-        call.options.audio = false;
-        call.options.micId = null;
-        call.options.micLabel = null;
-    }
-    const hasVideoLine = params.sdp.indexOf('m=video') !== -1;
-    if (!hasVideoLine) {
-        call.options.video = false;
-        call.options.camId = null;
-        call.options.camLabel = null;
-    }
-    call.nodeId = nodeId;
-    call.isDirect = checkIsDirectCall(params);
-    return call;
-};
-export default (session, msg) => {
-    const { id, method, nodeId, params } = msg;
-    const { callID, eventChannel, eventType } = params;
-    if (eventType === 'channelPvtData') {
-        params.pvtData.nodeId = nodeId;
-        return _handlePvtEvent(session, params.pvtData);
-    }
-    if (eventChannel === session.sessionid || eventChannel === session.relayProtocol) {
-        return _handleSessionEvent(session, params.eventData);
-    }
-    if (callID && session.calls.hasOwnProperty(callID)) {
-        trigger(callID, params, method);
-        if (method !== VertoMethod.Attach) {
-            const msg = new Result(id, method);
-            msg.targetNodeId = nodeId;
-            session.execute(msg);
+    _ack(id, method) {
+        const msg = new Result(id, method);
+        if (this.nodeId) {
+            msg.targetNodeId = this.nodeId;
         }
-        return;
+        this.session.execute(msg);
     }
-    const attach = method === VertoMethod.Attach;
-    switch (method) {
-        case VertoMethod.Ping:
-            const msg = new Result(id, method);
-            msg.targetNodeId = nodeId;
-            return session.execute(msg);
-        case VertoMethod.Punt:
-            session.purge();
-            return session.disconnect();
-        case VertoMethod.Invite: {
-            const call = _buildCall(session, params, attach, nodeId);
-            call.setState(State.Ringing);
-            const msg = new Result(id, method);
-            msg.targetNodeId = nodeId;
-            return session.execute(msg);
-        }
-        case VertoMethod.Attach: {
-            const call = _buildCall(session, params, attach, nodeId);
-            return trigger(call.id, params, method);
+    handleMessage(msg) {
+        const { session } = this;
+        const { id, method, params } = msg;
+        const { callID, eventChannel, eventType } = params;
+        const attach = method === VertoMethod.Attach;
+        if (eventType === 'channelPvtData') {
+            return this._handlePvtEvent(params.pvtData);
         }
-        case VertoMethod.Event:
-        case 'webrtc.event': {
-            const { subscribedChannel } = params;
-            if (subscribedChannel && trigger(session.relayProtocol, params, subscribedChannel)) {
+        if (callID && session.calls.hasOwnProperty(callID)) {
+            if (attach) {
+                session.calls[callID].hangup({}, false);
+            }
+            else {
+                session.calls[callID].handleMessage(msg);
+                this._ack(id, method);
                 return;
             }
-            if (eventChannel) {
-                const channelType = eventChannel.split('.')[0];
-                const global = trigger(session.relayProtocol, params, channelType);
-                let specific = false;
-                if (channelType !== eventChannel) {
-                    specific = trigger(session.relayProtocol, params, eventChannel);
+        }
+        const _buildCall = () => {
+            const call = new Call(session, {
+                id: callID,
+                remoteSdp: params.sdp,
+                destinationNumber: params.callee_id_number,
+                remoteCallerName: params.caller_id_name,
+                remoteCallerNumber: params.caller_id_number,
+                callerName: params.callee_id_name,
+                callerNumber: params.callee_id_number,
+                attach
+            });
+            call.nodeId = this.nodeId;
+            return call;
+        };
+        switch (method) {
+            case VertoMethod.Punt:
+                session.disconnect();
+                break;
+            case VertoMethod.Invite: {
+                const call = _buildCall();
+                call.setState(State.Ringing);
+                this._ack(id, method);
+                break;
+            }
+            case VertoMethod.Attach: {
+                const call = _buildCall();
+                if (this.session.autoRecoverCalls) {
+                    call.answer();
+                }
+                else {
+                    call.setState(State.Recovering);
                 }
-                if (global || specific) {
+                call.handleMessage(msg);
+                break;
+            }
+            case VertoMethod.Event:
+            case 'webrtc.event':
+                if (!eventChannel) {
+                    logger.error('Verto received an unknown event:', params);
                     return;
                 }
+                const protocol = session.relayProtocol;
+                const firstValue = eventChannel.split('.')[0];
+                if (session._existsSubscription(protocol, eventChannel)) {
+                    trigger(protocol, params, eventChannel);
+                }
+                else if (eventChannel === session.sessionid) {
+                    this._handleSessionEvent(params.eventData);
+                }
+                else if (session._existsSubscription(protocol, firstValue)) {
+                    trigger(protocol, params, firstValue);
+                }
+                else if (session.calls.hasOwnProperty(eventChannel)) {
+                    session.calls[eventChannel].handleMessage(msg);
+                }
+                else {
+                    trigger(SwEvent.Notification, params, session.uuid);
+                }
+                break;
+            case VertoMethod.Info:
+                params.type = NOTIFICATION_TYPE.generic;
+                trigger(SwEvent.Notification, params, session.uuid);
+                break;
+            case VertoMethod.ClientReady:
+                params.type = NOTIFICATION_TYPE.vertoClientReady;
+                trigger(SwEvent.Notification, params, session.uuid);
+                break;
+            default:
+                logger.warn('Verto message unknown method:', msg);
+        }
+    }
+    _retrieveCallId(packet, laChannel) {
+        const callIds = Object.keys(this.session.calls);
+        if (packet.action === 'bootObj') {
+            const me = packet.data.find((pr) => callIds.includes(pr[0]));
+            if (me instanceof Array) {
+                return me[0];
             }
-            params.type = Notification.Generic;
-            return trigger(SwEvent.Notification, params, session.uuid);
         }
-        case VertoMethod.Info:
-            params.type = Notification.Generic;
-            return trigger(SwEvent.Notification, params, session.uuid);
-        case VertoMethod.ClientReady:
-            params.type = Notification.VertoClientReady;
-            return trigger(SwEvent.Notification, params, session.uuid);
-        case VertoMethod.Announce:
-            params.type = Notification.Announce;
-            return trigger(SwEvent.Notification, params, session.uuid);
-        default:
-            logger.debug('Unknown Verto method:', method, params);
-            params.type = method;
-            return trigger(SwEvent.Notification, params, session.uuid);
+        else {
+            return callIds.find((id) => this.session.calls[id].channels.includes(laChannel));
+        }
     }
-};
+    _handlePvtEvent(pvtData) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { session } = this;
+            const protocol = session.relayProtocol;
+            const { action, laChannel, laName, chatChannel, infoChannel, modChannel, conferenceMemberID, role, callID } = pvtData;
+            switch (action) {
+                case 'conference-liveArray-join': {
+                    const _liveArrayBootstrap = () => {
+                        session.vertoBroadcast({ nodeId: this.nodeId, channel: laChannel, data: { liveArray: { command: 'bootstrap', context: laChannel, name: laName } } });
+                    };
+                    const tmp = {
+                        nodeId: this.nodeId,
+                        channels: [laChannel],
+                        handler: ({ data: packet }) => {
+                            const id = callID || this._retrieveCallId(packet, laChannel);
+                            if (id && session.calls.hasOwnProperty(id)) {
+                                const call = session.calls[id];
+                                call._addChannel(laChannel);
+                                call.extension = laName;
+                                call.handleConferenceUpdate(packet, pvtData)
+                                    .then(error => {
+                                    if (error === 'INVALID_PACKET') {
+                                        _liveArrayBootstrap();
+                                    }
+                                });
+                            }
+                        }
+                    };
+                    const result = yield session.vertoSubscribe(tmp)
+                        .catch(error => {
+                        logger.error('liveArray subscription error:', error);
+                    });
+                    if (checkSubscribeResponse(result, laChannel)) {
+                        _liveArrayBootstrap();
+                    }
+                    break;
+                }
+                case 'conference-liveArray-part': {
+                    let call = null;
+                    if (laChannel && session._existsSubscription(protocol, laChannel)) {
+                        const { callId = null } = session.subscriptions[protocol][laChannel];
+                        call = session.calls[callId] || null;
+                        if (callId !== null) {
+                            const notification = { type: NOTIFICATION_TYPE.conferenceUpdate, action: ConferenceAction.Leave, conferenceName: laName, participantId: Number(conferenceMemberID), role };
+                            if (!trigger(SwEvent.Notification, notification, callId, false)) {
+                                trigger(SwEvent.Notification, notification, session.uuid);
+                            }
+                            if (call === null) {
+                                deRegister(SwEvent.Notification, null, callId);
+                            }
+                        }
+                    }
+                    const channels = [laChannel, chatChannel, infoChannel, modChannel];
+                    session.vertoUnsubscribe({ nodeId: this.nodeId, channels })
+                        .then(({ unsubscribedChannels = [] }) => {
+                        if (call) {
+                            call.channels = call.channels.filter(c => !unsubscribedChannels.includes(c));
+                        }
+                    })
+                        .catch(error => {
+                        logger.error('liveArray unsubscribe error:', error);
+                    });
+                    break;
+                }
+            }
+        });
+    }
+    _handleSessionEvent(eventData) {
+        switch (eventData.contentType) {
+            case 'layout-info':
+            case 'layer-info':
+                MCULayoutEventHandler(this.session, eventData);
+                break;
+            case 'logo-info': {
+                const notification = { type: NOTIFICATION_TYPE.conferenceUpdate, action: ConferenceAction.LogoInfo, logo: eventData.logoURL };
+                trigger(SwEvent.Notification, notification, this.session.uuid);
+                break;
+            }
+        }
+    }
+}
+export default VertoHandler;

package/dist/esm/common/src/webrtc/constants.d.ts

@@ -22,30 +22,18 @@ export declare enum VertoMethod {
     Unsubscribe = "verto.unsubscribe",
     ClientReady = "verto.clientReady",
     Modify = "verto.modify",
-    MediaParams = "verto.mediaParams",
-    Prompt = "verto.prompt",
-    JsApi = "jsapi",
-    Stats = "verto.stats",
-    Ping = "verto.ping",
-    Announce = "verto.announce"
-}
-export declare enum Notification {
-    Generic = "event",
-    ParticipantData = "participantData",
-    ConferenceUpdate = "conferenceUpdate",
-    CallUpdate = "callUpdate",
-    VertoClientReady = "vertoClientReady",
-    UserMediaError = "userMediaError",
-    RefreshToken = "refreshToken",
-    Prompt = "prompt",
-    Announce = "announce",
-    DeviceUpdated = "deviceUpdated",
-    MediaParams = "mediaParams",
-    ConferenceListBootstrap = "conferenceListBootstrap",
-    ConferenceListAdd = "conferenceListAdd",
-    ConferenceListModify = "conferenceListModify",
-    ConferenceListDelete = "conferenceListDelete"
+    MediaParams = "verto.mediaParams"
 }
+export declare const NOTIFICATION_TYPE: {
+    generic: string;
+    "verto.display": string;
+    "verto.attach": string;
+    conferenceUpdate: string;
+    callUpdate: string;
+    vertoClientReady: string;
+    userMediaError: string;
+    refreshToken: string;
+};
 export declare const DEFAULT_CALL_OPTIONS: CallOptions;
 export declare enum State {
     New = 0,
@@ -78,10 +66,7 @@ export declare enum ConferenceAction {
     LogoInfo = "logoInfo",
     LayoutInfo = "layoutInfo",
     LayoutList = "layoutList",
-    ModCmdResponse = "modCommandResponse",
-    ConferenceInfo = "conferenceInfo",
-    CaptionInfo = "captionInfo",
-    MemberTalkState = "memberTalkState"
+    ModCmdResponse = "modCommandResponse"
 }
 export declare enum DeviceType {
     Video = "videoinput",

package/dist/esm/common/src/webrtc/constants.js

@@ -25,30 +25,17 @@ export var VertoMethod;
     VertoMethod["ClientReady"] = "verto.clientReady";
     VertoMethod["Modify"] = "verto.modify";
     VertoMethod["MediaParams"] = "verto.mediaParams";
-    VertoMethod["Prompt"] = "verto.prompt";
-    VertoMethod["JsApi"] = "jsapi";
-    VertoMethod["Stats"] = "verto.stats";
-    VertoMethod["Ping"] = "verto.ping";
-    VertoMethod["Announce"] = "verto.announce";
 })(VertoMethod || (VertoMethod = {}));
-export var Notification;
-(function (Notification) {
-    Notification["Generic"] = "event";
-    Notification["ParticipantData"] = "participantData";
-    Notification["ConferenceUpdate"] = "conferenceUpdate";
-    Notification["CallUpdate"] = "callUpdate";
-    Notification["VertoClientReady"] = "vertoClientReady";
-    Notification["UserMediaError"] = "userMediaError";
-    Notification["RefreshToken"] = "refreshToken";
-    Notification["Prompt"] = "prompt";
-    Notification["Announce"] = "announce";
-    Notification["DeviceUpdated"] = "deviceUpdated";
-    Notification["MediaParams"] = "mediaParams";
-    Notification["ConferenceListBootstrap"] = "conferenceListBootstrap";
-    Notification["ConferenceListAdd"] = "conferenceListAdd";
-    Notification["ConferenceListModify"] = "conferenceListModify";
-    Notification["ConferenceListDelete"] = "conferenceListDelete";
-})(Notification || (Notification = {}));
+export const NOTIFICATION_TYPE = {
+    generic: 'event',
+    [VertoMethod.Display]: 'participantData',
+    [VertoMethod.Attach]: 'participantData',
+    conferenceUpdate: 'conferenceUpdate',
+    callUpdate: 'callUpdate',
+    vertoClientReady: 'vertoClientReady',
+    userMediaError: 'userMediaError',
+    refreshToken: 'refreshToken',
+};
 export const DEFAULT_CALL_OPTIONS = {
     destinationNumber: '',
     remoteCallerName: 'Outbound Call',
@@ -56,17 +43,11 @@ export const DEFAULT_CALL_OPTIONS = {
     callerName: '',
     callerNumber: '',
     audio: true,
-    video: true,
+    video: false,
     useStereo: false,
     attach: false,
     screenShare: false,
-    secondSource: false,
     userVariables: {},
-    requestTimeout: 10 * 1000,
-    experimental: false,
-    autoApplyMediaParams: true,
-    iceGatheringTimeout: 2 * 1000,
-    maxIceGatheringTimeout: 5 * 1000,
 };
 export var State;
 (function (State) {
@@ -103,9 +84,6 @@ export var ConferenceAction;
     ConferenceAction["LayoutInfo"] = "layoutInfo";
     ConferenceAction["LayoutList"] = "layoutList";
     ConferenceAction["ModCmdResponse"] = "modCommandResponse";
-    ConferenceAction["ConferenceInfo"] = "conferenceInfo";
-    ConferenceAction["CaptionInfo"] = "captionInfo";
-    ConferenceAction["MemberTalkState"] = "memberTalkState";
 })(ConferenceAction || (ConferenceAction = {}));
 export var DeviceType;
 (function (DeviceType) {

package/dist/esm/common/src/webrtc/helpers.d.ts

@@ -1,25 +1,31 @@
-import { CallOptions, IVertoCanvasInfo, ICanvasInfo, IConferenceInfo, ILayout, IVertoLayout } from './interfaces';
-export declare const getUserMedia: (constraints: MediaStreamConstraints) => Promise<MediaStream>;
-export declare const removeUnsupportedConstraints: (constraints: MediaTrackConstraints) => void;
-export declare const getMediaConstraints: (options: CallOptions) => Promise<MediaStreamConstraints>;
-declare type DestructuredResult = {
+import { CallOptions } from './interfaces';
+declare const getUserMedia: (constraints: MediaStreamConstraints) => Promise<MediaStream | null>;
+declare const getDevices: (kind?: string, fullList?: boolean) => Promise<MediaDeviceInfo[]>;
+declare const scanResolutions: (deviceId: string) => Promise<any[]>;
+declare const getMediaConstraints: (options: CallOptions) => Promise<MediaStreamConstraints>;
+declare const assureDeviceId: (id: string, label: string, kind: MediaDeviceInfo['kind']) => Promise<string>;
+declare const removeUnsupportedConstraints: (constraints: MediaTrackConstraints) => void;
+declare const checkDeviceIdConstraints: (id: string, label: string, kind: MediaDeviceInfo['kind'], constraints: MediaTrackConstraints) => Promise<MediaTrackConstraints>;
+declare const sdpStereoHack: (sdp: string) => string;
+declare const sdpMediaOrderHack: (answer: string, localOffer: string) => string;
+declare const checkSubscribeResponse: (response: any, channel: string) => boolean;
+type DestructuredResult = {
     subscribed: string[];
     alreadySubscribed: string[];
     unauthorized: string[];
     unsubscribed: string[];
     notSubscribed: string[];
 };
-export declare const destructSubscribeResponse: (response: any) => DestructuredResult;
-export declare const enableAudioTracks: (stream: MediaStream) => void;
-export declare const disableAudioTracks: (stream: MediaStream) => void;
-export declare const toggleAudioTracks: (stream: MediaStream) => void;
-export declare const enableVideoTracks: (stream: MediaStream) => void;
-export declare const disableVideoTracks: (stream: MediaStream) => void;
-export declare const toggleVideoTracks: (stream: MediaStream) => void;
-export declare const mutateCanvasInfoData: (canvasInfo: IVertoCanvasInfo) => ICanvasInfo;
-export declare const checkIsDirectCall: ({ variables }: {
-    variables: any;
-}) => boolean;
-export declare const destructConferenceState: (confState: any) => IConferenceInfo;
-export declare const mungeLayoutList: (layouts: IVertoLayout[], layoutGroups: IVertoLayout[]) => ILayout[];
-export {};
+declare const destructSubscribeResponse: (response: any) => DestructuredResult;
+declare const enableAudioTracks: (stream: MediaStream) => void;
+declare const disableAudioTracks: (stream: MediaStream) => void;
+declare const toggleAudioTracks: (stream: MediaStream) => void;
+declare const enableVideoTracks: (stream: MediaStream) => void;
+declare const disableVideoTracks: (stream: MediaStream) => void;
+declare const toggleVideoTracks: (stream: MediaStream) => void;
+declare const sdpBitrateHack: (sdp: string, max: number, min: number, start: number) => string;
+interface FilterIceServersOptions {
+    disableUdpIceServers: boolean;
+}
+declare const filterIceServers: (servers: RTCIceServer[], options?: FilterIceServersOptions) => RTCIceServer[];
+export { getUserMedia, getDevices, scanResolutions, getMediaConstraints, assureDeviceId, removeUnsupportedConstraints, checkDeviceIdConstraints, sdpStereoHack, sdpMediaOrderHack, sdpBitrateHack, checkSubscribeResponse, destructSubscribeResponse, enableAudioTracks, disableAudioTracks, toggleAudioTracks, enableVideoTracks, disableVideoTracks, toggleVideoTracks, filterIceServers };