@ohos-ports/genesys-cloud-streaming-client 20.1.0-beta.1

package/dist/es/types/interfaces.js

@@ -0,0 +1,19 @@
+export var AlertableInteractionTypes;
+(function (AlertableInteractionTypes) {
+    AlertableInteractionTypes["voice"] = "voice";
+})(AlertableInteractionTypes || (AlertableInteractionTypes = {}));
+export var StreamingClientErrorTypes;
+(function (StreamingClientErrorTypes) {
+    StreamingClientErrorTypes["generic"] = "generic";
+    StreamingClientErrorTypes["invalid_token"] = "invalid_token";
+    StreamingClientErrorTypes["userCancelled"] = "user_cancelled";
+})(StreamingClientErrorTypes || (StreamingClientErrorTypes = {}));
+export var SessionTypes;
+(function (SessionTypes) {
+    SessionTypes["softphone"] = "softphone";
+    SessionTypes["collaborateVideo"] = "collaborateVideo";
+    SessionTypes["acdScreenShare"] = "screenShare";
+    SessionTypes["screenRecording"] = "screenRecording";
+    SessionTypes["liveScreenMonitoring"] = "liveScreenMonitoring";
+    SessionTypes["unknown"] = "unknown";
+})(SessionTypes || (SessionTypes = {}));

package/dist/es/types/libs.d.ts

@@ -0,0 +1,32 @@
+declare module 'wildemitter' {
+    export default class WildEmitter {
+        constructor();
+        on(event: string, groupNameOrCallback: any, callback?: any): void;
+        once(event: string, groupNameOrCallback: any, callback?: any): void;
+        off(event: string, groupNameOrCallback?: any, callback?: any): void;
+        emit(event: string, ...args: any[]): void;
+        emit(event: string, ...args: any[]): void;
+        releaseGroup(groupName?: string): void;
+        getWildcardCallbacks(): (...args: any[]) => void;
+        static mixin(arg: any): void;
+    }
+}
+declare module 'backoff-web' {
+    export interface Backoff {
+        failAfter(attempts: number): void;
+        on(evt: 'backoff' | 'ready', callback: (count: number, delay: number) => void): void;
+        on(evt: 'fail', callback: (...args: any[]) => void): void;
+        backoff(): void;
+        reset(): void;
+        backoffNumber_: number;
+    }
+    const backoffInitializer: {
+        exponential(options: {
+            randomisationFactor: number;
+            initialDelay: number;
+            maxDelay: number;
+            factor: number;
+        }): Backoff;
+    };
+    export default backoffInitializer;
+}

package/dist/es/types/libs.js

@@ -0,0 +1 @@
+"use strict";

package/dist/es/types/media-session.d.ts

@@ -0,0 +1,76 @@
+/// <reference types="node" />
+import EventEmitter from 'events';
+import Logger from 'genesys-cloud-client-logger';
+import { JingleReasonCondition } from 'stanza/Constants';
+import { SessionOpts } from 'stanza/jingle/Session';
+import StrictEventEmitter from 'stanza/lib/StrictEventEmitter';
+import { JingleInfo, JingleReason } from 'stanza/protocol';
+import { StatsEvent } from 'webrtc-stats-gatherer';
+import { JsonRpcMessage, SessionTypes, SessionTypesAsStrings } from './interfaces';
+export declare type SessionState = 'pending' | 'active' | 'ended';
+export declare type ConnectionState = 'starting' | 'new' | 'connecting' | 'connected' | 'interrupted' | 'disconnected' | 'failed' | 'closed';
+export interface SessionEvents {
+    iceConnectionType: ({
+        localCandidateType: string;
+        relayed: boolean;
+        remoteCandidateType: string;
+    });
+    peerTrackAdded: (track: MediaStreamTrack, stream?: MediaStream) => void;
+    peerTrackRemoved: (track: MediaStreamTrack, stream?: MediaStream) => void;
+    mute: JingleInfo;
+    unmute: JingleInfo;
+    sessionState: SessionState;
+    connectionState: ConnectionState;
+    terminated: JingleReason;
+    stats: StatsEvent;
+    endOfCandidates: void;
+    dataChannelMessage: JsonRpcMessage;
+}
+export interface IMediaSessionParams {
+    logger: Logger;
+    id: string;
+    fromJid: string;
+    peerID: string;
+    sessionType: SessionTypes | SessionTypesAsStrings;
+    allowIPv6?: boolean;
+    allowTCP?: boolean;
+    ignoreHostCandidatesFromRemote?: boolean;
+    optOutOfWebrtcStatsTelemetry?: boolean;
+    conversationId?: string;
+    fromUserId?: string;
+    originalRoomJid?: string;
+    meetingId?: string;
+    privAnswerMode?: 'Auto';
+}
+export interface IStanzaMediaSessionParams extends IMediaSessionParams {
+    options: SessionOpts;
+}
+export interface IGenesysCloudMediaSessionParams extends IMediaSessionParams {
+    iceServers: RTCIceServer[];
+    iceTransportPolicy: RTCIceTransportPolicy;
+    reinvite: boolean;
+}
+export interface IMediaSession extends StrictEventEmitter<EventEmitter, SessionEvents> {
+    conversationId: string;
+    id: string;
+    sessionType: SessionTypes;
+    fromUserId?: string;
+    peerID: string;
+    peerConnection: RTCPeerConnection;
+    pc: RTCPeerConnection;
+    dataChannel?: RTCDataChannel;
+    connectionState: ConnectionState | string;
+    state: SessionState | string;
+    reinvite: boolean;
+    meetingId?: string;
+    privAnswerMode?: 'Auto';
+    setupStatsGatherer(): void;
+    accept(opts?: RTCAnswerOptions): Promise<void>;
+    end(reason: JingleReasonCondition, silent?: boolean): Promise<void>;
+    addTrack(track: MediaStreamTrack, stream?: MediaStream): Promise<void>;
+    removeTrack(sender: RTCRtpSender): Promise<void>;
+    mute(userId: string, name?: string): Promise<void>;
+    unmute(userId: string, name?: string): Promise<void>;
+    hold(): Promise<void>;
+    resume(): Promise<void>;
+}

package/dist/es/types/media-session.js

@@ -0,0 +1 @@
+export {};

package/dist/es/types/named-agent.d.ts

@@ -0,0 +1,13 @@
+import { Agent } from 'stanza';
+import { Ping } from '../ping';
+import { ServerMonitor } from '../server-monitor';
+import { ConnectionTransfer } from '../connection-transfer';
+export interface NamedAgent extends Omit<Agent, 'disconnect'> {
+    id: string;
+    channelId?: string;
+    originalEmitter?: Function;
+    pinger?: Ping;
+    serverMonitor?: ServerMonitor;
+    connectionTransfer?: ConnectionTransfer;
+    disconnect: () => Promise<void>;
+}

package/dist/es/types/named-agent.js

@@ -0,0 +1 @@
+export {};

package/dist/es/types/offline-error.d.ts

@@ -0,0 +1,2 @@
+export default class OfflineError extends Error {
+}

package/dist/es/types/offline-error.js

@@ -0,0 +1,2 @@
+export default class OfflineError extends Error {
+}

package/dist/es/types/sasl-error.d.ts

@@ -0,0 +1,8 @@
+import { SASLFailureCondition } from 'stanza/Constants';
+export default class SaslError extends Error {
+    condition: SASLFailureCondition;
+    channelId: string;
+    stanzaInstanceId: string;
+    name: string;
+    constructor(condition: SASLFailureCondition, channelId: string, stanzaInstanceId: string);
+}

package/dist/es/types/sasl-error.js

@@ -0,0 +1,9 @@
+export default class SaslError extends Error {
+    constructor(condition, channelId, stanzaInstanceId) {
+        super();
+        this.condition = condition;
+        this.channelId = channelId;
+        this.stanzaInstanceId = stanzaInstanceId;
+        this.name = 'SaslError';
+    }
+}

package/dist/es/types/stanza-media-session.d.ts

@@ -0,0 +1,56 @@
+import { MediaSession } from 'stanza/jingle';
+import { JingleReasonCondition } from 'stanza/Constants';
+import { ActionCallback } from 'stanza/jingle/Session';
+import { JingleReason } from 'stanza/protocol';
+import { IMediaSession, IStanzaMediaSessionParams } from './media-session';
+import { SessionTypes } from './interfaces';
+import { Jingle } from 'stanza/protocol/xep0166';
+export declare class StanzaMediaSession extends MediaSession implements IMediaSession {
+    private statsGatherer?;
+    private iceCandidatesDiscovered;
+    private iceCandidatesReceivedFromPeer;
+    private interruptionStart?;
+    private logger;
+    off: any;
+    removeAllListeners: any;
+    on: any;
+    once: any;
+    setMaxListeners: any;
+    getMaxListeners: any;
+    listeners: any;
+    rawListeners: any;
+    listenerCount: any;
+    prependListener: any;
+    prependOnceListener: any;
+    eventNames: any;
+    addListener: any;
+    removeListener: any;
+    emit: any;
+    conversationId: string;
+    peerConnection: RTCPeerConnection;
+    id: string;
+    fromUserId: string;
+    meetingId?: string;
+    originalRoomJid?: string;
+    sessionType: SessionTypes;
+    ignoreHostCandidatesFromRemote: boolean;
+    allowIPv6: boolean;
+    allowTCP: boolean;
+    dataChannel?: RTCDataChannel;
+    reinvite: boolean;
+    privAnswerMode?: 'Auto';
+    constructor(params: IStanzaMediaSessionParams);
+    private getLogDetails;
+    onTransportInfo(changes: Jingle, cb: ActionCallback): Promise<void>;
+    protected _log(level: string, message: string, ...data: any[]): void;
+    end(reason?: JingleReasonCondition | JingleReason, silent?: boolean): Promise<void>;
+    setupStatsGatherer(): void;
+    onIceStateChange(): void;
+    onConnectionStateChange(): void;
+    onIceCandidateError(ev: Event): void;
+    onIceCandidate(e: RTCPeerConnectionIceEvent): void;
+    onIceEndOfCandidates(): void;
+    addTrack(track: MediaStreamTrack, stream?: MediaStream): Promise<void>;
+    _setupDataChannel(): void;
+    _handleDataChannelMessage(event: MessageEvent): void;
+}

package/dist/es/types/stanza-media-session.js

@@ -0,0 +1,264 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+/* istanbul ignore file */
+import EventEmitter from 'events';
+import { MediaSession } from 'stanza/jingle';
+import { JingleAction, JINGLE_INFO_ACTIVE } from 'stanza/Constants';
+import StatsGatherer from 'webrtc-stats-gatherer';
+import { SessionTypes } from './interfaces';
+const loggingOverrides = {
+    'Discovered new ICE candidate': { skipMessage: true }
+};
+// because we are trying to unify the interfaces between stanza and genesys media session
+// we kind of have to hack the stanza one so it works with typescript
+export class StanzaMediaSession extends MediaSession {
+    constructor(params) {
+        super(params.options);
+        this.iceCandidatesDiscovered = 0;
+        this.iceCandidatesReceivedFromPeer = 0;
+        this.reinvite = false;
+        this.logger = params.logger;
+        this.conversationId = params.conversationId;
+        this.peerConnection = this.pc;
+        this.fromUserId = params.fromUserId;
+        this.meetingId = params.meetingId;
+        this.id = this.sid;
+        this.originalRoomJid = params.originalRoomJid;
+        this.sessionType = SessionTypes[params.sessionType];
+        this.ignoreHostCandidatesFromRemote = !!params.ignoreHostCandidatesFromRemote;
+        this.allowIPv6 = !!params.allowIPv6;
+        this.allowTCP = !!params.allowTCP;
+        this.privAnswerMode = params.privAnswerMode;
+        // babel does not like the typescript recipe for multiple extends so we are hacking this one
+        // referencing https://github.com/babel/babel/issues/798
+        const eventEmitter = new EventEmitter();
+        Object.keys(eventEmitter.__proto__).forEach((name) => {
+            this[name] = eventEmitter[name];
+        });
+        if (!params.optOutOfWebrtcStatsTelemetry) {
+            this.setupStatsGatherer();
+        }
+        this.pc.addEventListener('connectionstatechange', this.onConnectionStateChange.bind(this));
+        this.pc.addEventListener('icecandidateerror', this.onIceCandidateError.bind(this));
+    }
+    getLogDetails() {
+        return {
+            conversationId: this.conversationId,
+            sessionId: this.id,
+            sessionType: this.sessionType
+        };
+    }
+    onTransportInfo(changes, cb) {
+        const _super = Object.create(null, {
+            onTransportInfo: { get: () => super.onTransportInfo }
+        });
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            const transport = (_a = changes.contents) === null || _a === void 0 ? void 0 : _a[0].transport;
+            const candidates = transport === null || transport === void 0 ? void 0 : transport.candidates;
+            if (this.ignoreHostCandidatesFromRemote) {
+                const nonHostCandidates = candidates === null || candidates === void 0 ? void 0 : candidates.filter(candidate => candidate.type !== 'host');
+                if ((nonHostCandidates === null || nonHostCandidates === void 0 ? void 0 : nonHostCandidates.length) !== ((_b = transport === null || transport === void 0 ? void 0 : transport.candidates) === null || _b === void 0 ? void 0 : _b.length)) {
+                    this._log('info', 'Ignoring remote host ice candidates');
+                    transport.candidates = nonHostCandidates;
+                }
+            }
+            if (candidates) {
+                for (const candidate of candidates) {
+                    this._log('info', 'Received candidate from peer', { candidateType: candidate.type });
+                    this.iceCandidatesReceivedFromPeer++;
+                }
+            }
+            return _super.onTransportInfo.call(this, changes, cb);
+        });
+    }
+    _log(level, message, ...data) {
+        const redactionInfo = loggingOverrides[message];
+        if (redactionInfo === null || redactionInfo === void 0 ? void 0 : redactionInfo.skipMessage) {
+            return;
+        }
+        let details;
+        if (data.length) {
+            const firstItem = data[0];
+            // if first item is an object, merge the details, else wrap them
+            if (typeof firstItem === 'object' &&
+                !Array.isArray(firstItem) &&
+                firstItem !== null) {
+                Object.assign(data[0], this.getLogDetails());
+                details = data;
+            }
+            else {
+                details = Object.assign(Object.assign({}, this.getLogDetails()), { data: firstItem });
+            }
+        }
+        else {
+            details = [...data, this.getLogDetails()];
+        }
+        this.logger[level](message, details);
+    }
+    end(reason = 'success', silent = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.state = 'ended';
+            this.processingQueue.kill();
+            if (typeof reason === 'string') {
+                reason = { condition: reason };
+            }
+            if (!silent) {
+                this._log('info', 'sending jingle session-terminate');
+                this.send('session-terminate', { reason });
+            }
+            // After sending session-terminate, wait for the peer connection to die -> if it doesn't, we will manually close it.
+            setTimeout(() => {
+                if (this.pc.connectionState === 'connected' || this.pc.connectionState === 'connecting') {
+                    this.pc.close();
+                }
+            }, 2000);
+            this.parent.emit('terminated', this, reason);
+            this.parent.forgetSession(this);
+        });
+    }
+    setupStatsGatherer() {
+        this.statsGatherer = new StatsGatherer(this.pc);
+        this.statsGatherer.on('stats', this.emit.bind(this, 'stats'));
+    }
+    onIceStateChange() {
+        const iceState = this.pc.iceConnectionState;
+        const sessionId = this.id;
+        const conversationId = this.conversationId;
+        const sessionType = this.sessionType;
+        this._log('info', 'ICE state changed: ', { iceState, sessionId, conversationId });
+        if (iceState === 'disconnected') {
+            // this means we actually connected at one point
+            if (this.pc.signalingState === 'stable') {
+                this.interruptionStart = new Date();
+                this._log('info', 'Connection state is interrupted', { sessionId, conversationId, sessionType });
+            }
+        }
+        else if (iceState === 'connected') {
+            this._log('info', 'sending session-info: active');
+            this.send(JingleAction.SessionInfo, {
+                info: {
+                    infoType: JINGLE_INFO_ACTIVE
+                }
+            });
+            this._setupDataChannel();
+        }
+        else if (iceState === 'failed') {
+            this._log('info', 'ICE connection failed', {
+                candidatesDiscovered: this.iceCandidatesDiscovered,
+                candidatesReceivedFromPeer: this.iceCandidatesReceivedFromPeer
+            });
+        }
+        super.onIceStateChange();
+    }
+    onConnectionStateChange() {
+        const connectionState = this.pc.connectionState;
+        const sessionId = this.id;
+        const conversationId = this.conversationId;
+        const sessionType = this.sessionType;
+        this._log('info', 'Connection state changed: ', { connectionState, sessionId, conversationId, sessionType });
+        if (this.interruptionStart) {
+            if (connectionState === 'connected') {
+                const diff = new Date().getTime() - this.interruptionStart.getTime();
+                this._log('info', 'Connection was interrupted but was successfully recovered/connected', { sessionId, conversationId, sessionType, timeToRecover: diff });
+                this.interruptionStart = undefined;
+            }
+            else if (connectionState === 'failed') {
+                this._log('info', 'Connection was interrupted and failed to recover', { sessionId, conversationId, sessionType });
+            }
+        }
+    }
+    onIceCandidateError(ev) {
+        const event = ev;
+        this._log('error', 'IceCandidateError', {
+            errorCode: event.errorCode,
+            errorText: event.errorText,
+            url: event.url
+        });
+        console.error('IceCandidateError', event);
+    }
+    onIceCandidate(e) {
+        if (e.candidate) {
+            if (!this.allowTCP && e.candidate.protocol === 'tcp') {
+                return;
+            }
+            if (!this.allowIPv6) {
+                const addressRegex = /.+udp [^ ]+ ([^ ]+).*typ host/;
+                const matches = addressRegex.exec(e.candidate.candidate);
+                const ipv4Regex = /\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/;
+                if (matches && !matches[1].match(ipv4Regex)) {
+                    this._log('debug', 'Filtering out IPv6 candidate', e.candidate.candidate);
+                    return;
+                }
+            }
+            // this has too much information and can only be logged locally (debug)
+            this._log('debug', 'Processing ice candidate', e.candidate.candidate);
+            // this one is info level so it can go to the server
+            this._log('info', 'Discovered ice candidate to send to peer', { type: e.candidate.type });
+            this.iceCandidatesDiscovered++;
+        }
+        return super.onIceCandidate(e);
+    }
+    onIceEndOfCandidates() {
+        super.onIceEndOfCandidates();
+        this.emit('endOfCandidates');
+    }
+    addTrack(track, stream) {
+        if (track.kind === 'audio') {
+            this.includesAudio = true;
+        }
+        if (track.kind === 'video') {
+            this.includesVideo = true;
+        }
+        return this.processLocal('addtrack', () => __awaiter(this, void 0, void 0, function* () {
+            // find an available sender with the correct type
+            const availableTransceiver = this.pc.getTransceivers().find((transceiver) => {
+                var _a;
+                return !transceiver.sender.track && ((_a = transceiver.receiver.track) === null || _a === void 0 ? void 0 : _a.kind) === track.kind;
+            });
+            if (availableTransceiver) {
+                return availableTransceiver.sender.replaceTrack(track);
+            }
+            this.pc.addTrack(track, stream);
+            return;
+        }));
+    }
+    _setupDataChannel() {
+        var _a;
+        // this shouldn't happen, but we shouldn't set the datachannel up more than once
+        if (this.dataChannel) {
+            return;
+        }
+        // do nothing if a datachannel wasn't offered
+        if ((_a = this.pc.localDescription) === null || _a === void 0 ? void 0 : _a.sdp.includes('webrtc-datachannel')) {
+            this._log('info', 'creating data channel');
+            this.dataChannel = this.pc.createDataChannel('videoConferenceControl');
+            this.dataChannel.addEventListener('open', () => {
+                this._log('info', 'data channel opened');
+            });
+            this.dataChannel.addEventListener('message', this._handleDataChannelMessage.bind(this));
+            this.dataChannel.addEventListener('close', () => {
+                this._log('info', 'closing data channel');
+            });
+            this.dataChannel.addEventListener('error', (error) => {
+                this._log('error', 'Error occurred with the data channel', error);
+            });
+        }
+    }
+    _handleDataChannelMessage(event) {
+        try {
+            const message = JSON.parse(event.data);
+            this.emit('dataChannelMessage', message);
+        }
+        catch (e) {
+            this._log('error', 'Failed to parse data channel message', { error: e });
+        }
+    }
+}

package/dist/es/types/streaming-client-extension.d.ts

@@ -0,0 +1,14 @@
+import { TokenBucket } from 'limiter';
+import { IQ, Message } from 'stanza/protocol';
+import { NamedAgent } from './named-agent';
+export interface StreamingClientExtension {
+    handleIq?: (iq: IQ) => void;
+    handleMessage?: (message: Message) => void;
+    tokenBucket?: TokenBucket;
+    on?: (eventName: string, ...args: any[]) => void;
+    expose?: {
+        [fnName: string]: any;
+    };
+    configureNewStanzaInstance?: (stanzaInstance: NamedAgent) => Promise<any>;
+    handleStanzaInstanceChange: (stanzaInstance: NamedAgent) => void;
+}

package/dist/es/types/streaming-client-extension.js

@@ -0,0 +1 @@
+export {};

package/dist/es/types/timeout-error.d.ts

@@ -0,0 +1,3 @@
+export declare class TimeoutError extends Error {
+    constructor(message: string);
+}

package/dist/es/types/timeout-error.js

@@ -0,0 +1,5 @@
+export class TimeoutError extends Error {
+    constructor(message) {
+        super(message);
+    }
+}

package/dist/es/types/user-cancelled-error.d.ts

@@ -0,0 +1,2 @@
+export default class UserCancelledError extends Error {
+}

package/dist/es/types/user-cancelled-error.js

@@ -0,0 +1,2 @@
+export default class UserCancelledError extends Error {
+}

package/dist/es/utils.d.ts

@@ -0,0 +1,34 @@
+import { StreamingClientErrorTypes, StreamingSubscriptionErrorDetails } from './types/interfaces';
+export declare class StreamingClientError extends Error {
+    type: StreamingClientErrorTypes;
+    details?: unknown;
+    constructor(type: StreamingClientErrorTypes | null, messageOrError: string | Error, details?: unknown);
+}
+export declare class StreamingSubscriptionError extends Error {
+    readonly topic?: string | undefined;
+    readonly operation?: "subscribe" | "unsubscribe" | undefined;
+    name: string;
+    missingPermissions?: string[];
+    constructor(message: string, topic?: string | undefined, operation?: "subscribe" | "unsubscribe" | undefined, details?: StreamingSubscriptionErrorDetails);
+}
+export declare function timeoutPromise(fn: Function, timeoutMs: number, msg: string, details?: any): Promise<any>;
+export declare function delay(ms: number): Promise<void>;
+export declare function splitIntoIndividualTopics(topicString: string): string[];
+export declare const isAcdJid: (jid: string) => boolean;
+export declare const isScreenRecordingJid: (jid: string) => boolean;
+export declare const isLiveScreenMonitoringJid: (jid: string) => boolean;
+export declare const isSoftphoneJid: (jid: string) => boolean;
+export declare const isVideoJid: (jid: string) => boolean;
+export declare type RetryPromise<T = any> = {
+    promise: Promise<T>;
+    cancel: (reason?: string | Error) => void;
+    complete: (value?: T) => void;
+    hasCompleted: () => boolean;
+    _id: string;
+};
+export declare function retryPromise<T = any>(promiseFn: () => Promise<T>, retryFn: (error?: Error | any) => boolean | number, retryInterval?: number, logger?: any): RetryPromise<T>;
+export declare const parseJwt: (token: string) => any;
+export declare function calculatePayloadSize(trace: any): number;
+export declare function getUfragFromSdp(sdp: string | undefined): string | null;
+export declare function getIcePwdFromSdp(sdp: string | undefined): string | null;
+export declare function iceIsDifferent(sdp1: string | undefined, sdp2: string | undefined): boolean;