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

package/dist/es/utils.js

@@ -0,0 +1,192 @@
+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());
+    });
+};
+import { TimeoutError } from './types/timeout-error';
+import { StreamingClientErrorTypes } from './types/interfaces';
+export class StreamingClientError extends Error {
+    constructor(type, messageOrError, details) {
+        let message;
+        if (messageOrError instanceof Error) {
+            message = messageOrError.message;
+        }
+        else {
+            message = messageOrError;
+        }
+        super(message);
+        if (messageOrError instanceof Error) {
+            this.name = messageOrError.name;
+        }
+        this.type = type !== null && type !== void 0 ? type : StreamingClientErrorTypes.generic;
+        this.details = details;
+    }
+}
+export class StreamingSubscriptionError extends Error {
+    constructor(message, topic, operation, details) {
+        super(message);
+        this.topic = topic;
+        this.operation = operation;
+        this.name = 'StreamingSubscriptionError';
+        this.missingPermissions = details === null || details === void 0 ? void 0 : details.missingPermissions;
+    }
+}
+/* istanbul ignore next */
+export function timeoutPromise(fn, timeoutMs, msg, details) {
+    return new Promise(function (resolve, reject) {
+        const timeout = setTimeout(function () {
+            const err = new TimeoutError(`Timeout: ${msg}`);
+            err.details = details;
+            reject(err);
+        }, timeoutMs);
+        const done = function (resolvedValue) {
+            clearTimeout(timeout);
+            resolve(resolvedValue);
+        };
+        fn(done, reject);
+    });
+}
+export function delay(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+export function splitIntoIndividualTopics(topicString) {
+    const topics = [];
+    if (topicString.includes('?')) {
+        const split = topicString.split('?');
+        const prefix = split[0];
+        const postfixes = split[1] && split[1].split('&');
+        if (postfixes && postfixes.length) {
+            postfixes.forEach(postfix => {
+                topics.push(`${prefix}.${postfix}`);
+            });
+        }
+    }
+    else {
+        topics.push(topicString);
+    }
+    return topics;
+}
+export const isAcdJid = function (jid) {
+    return jid.startsWith('acd-') && !isSoftphoneJid(jid);
+};
+export const isScreenRecordingJid = function (jid) {
+    return jid.startsWith('screenrecording-') && !isSoftphoneJid(jid);
+};
+export const isLiveScreenMonitoringJid = function (jid) {
+    return jid.startsWith('livemonitor-') && !isSoftphoneJid(jid);
+};
+export const isSoftphoneJid = function (jid) {
+    if (!jid) {
+        return false;
+    }
+    return !!jid.match(/.*@.*gjoll.*/i);
+};
+export const isVideoJid = function (jid) {
+    return !!(jid && jid.match(/@conference/) && !isAcdJid(jid));
+};
+export function retryPromise(promiseFn, 
+// if a number is returned, that's how long we will wait before retrying (in milliseconds)
+retryFn, retryInterval = 15000, logger = console) {
+    let timeout;
+    let cancel;
+    let complete;
+    let tryPromiseFn;
+    let _hasCompleted = false;
+    const promise = new Promise((resolve, reject) => {
+        tryPromiseFn = () => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const val = yield promiseFn();
+                complete(val);
+            }
+            catch (error) {
+                let timeToWait = retryInterval;
+                const retryValue = retryFn(error);
+                if (Number.isInteger(retryValue)) {
+                    timeToWait = retryValue;
+                }
+                if (retryValue !== false) {
+                    logger.debug('Retrying promise', error);
+                    timeout = setTimeout(tryPromiseFn, timeToWait);
+                }
+                else {
+                    cancel(error);
+                }
+            }
+        });
+        complete = (value) => {
+            clearTimeout(timeout);
+            _hasCompleted = true;
+            resolve(value);
+        };
+        cancel = (reason) => {
+            clearTimeout(timeout);
+            _hasCompleted = true;
+            reject(reason);
+        };
+        tryPromiseFn();
+    });
+    return {
+        promise,
+        cancel,
+        complete,
+        _id: globalThis.crypto.randomUUID(),
+        hasCompleted: () => _hasCompleted
+    };
+}
+// from https://stackoverflow.com/questions/38552003/how-to-decode-jwt-token-in-javascript
+export const parseJwt = (token) => {
+    const base64Url = token.split('.')[1];
+    const base64 = base64Url.replace(/-/g, '+').replace(/_/g, '/');
+    const jsonPayload = decodeURIComponent(window.atob(base64).split('').map(function (c) {
+        return '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2);
+    }).join(''));
+    return JSON.parse(jsonPayload);
+};
+export function calculatePayloadSize(trace) {
+    const str = JSON.stringify(trace);
+    // http://stackoverflow.com/questions/5515869/string-length-in-bytes-in-javascript
+    // Matches only the 10.. bytes that are non-initial characters in a multi-byte sequence.
+    const m = encodeURIComponent(str).match(/%[89ABab]/g);
+    return str.length + (m ? m.length : 0);
+}
+export function getUfragFromSdp(sdp) {
+    if (!sdp) {
+        return null;
+    }
+    const regex = /a=ice-ufrag:(\S+)/;
+    const match = sdp.match(regex);
+    return match ? match[1] : null;
+}
+export function getIcePwdFromSdp(sdp) {
+    if (!sdp) {
+        return null;
+    }
+    const regex = /a=ice-pwd:(\S+)/;
+    const match = sdp.match(regex);
+    return match ? match[1] : null;
+}
+export function iceIsDifferent(sdp1, sdp2) {
+    return getUfragFromSdp(sdp1) !== getUfragFromSdp(sdp2) || getIcePwdFromSdp(sdp1) !== getIcePwdFromSdp(sdp2);
+}
+// unsed, but handy. no test coverage until used
+// function mergeOptions (destination, provided) {
+//   for (var key in provided) {
+//     let value = provided[key];
+//     if (value instanceof Object) {
+//       if (!destination[key]) {
+//         destination[key] = {};
+//       }
+//       mergeOptions(destination[key], value);
+//     } else {
+//       destination[key] = provided[key];
+//     }
+//   }
+//
+//   return destination;
+// }

package/dist/es/webrtc.d.ts

@@ -0,0 +1,126 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import { IQ } from 'stanza/protocol';
+import { LRUCache } from 'lru-cache';
+import { SessionManager } from 'stanza/jingle';
+import { SessionOpts } from 'stanza/jingle/Session';
+import { Client } from './client';
+import { ExtendedRTCIceServer, IClientOptions, SessionTypes, IPendingSession, StreamingClientExtension, NRProxyStat, InsightAction } from './types/interfaces';
+import { NamedAgent } from './types/named-agent';
+import { StanzaMediaSession } from './types/stanza-media-session';
+import { IMediaSession } from './types/media-session';
+import Logger from 'genesys-cloud-client-logger';
+export interface InitRtcSessionOptions {
+    stream?: MediaStream;
+    provideVideo?: boolean;
+    provideAudio?: boolean;
+    mediaPurpose?: string;
+    jid?: string;
+    conversationId?: string;
+    sourceCommunicationId?: string;
+    videoGuest?: boolean;
+}
+export declare class WebrtcExtension extends EventEmitter implements StreamingClientExtension {
+    client: Client;
+    ignoredSessions: LRUCache<string, boolean, unknown>;
+    private earlyIceCandidates;
+    logger: Logger;
+    pendingSessions: {
+        [sessionId: string]: IPendingSession;
+    };
+    config: {
+        allowIPv6: boolean;
+        optOutOfWebrtcStatsTelemetry?: boolean;
+    };
+    private statsArr;
+    private throttleSendStatsInterval;
+    private currentMaxStatSize;
+    private statsSizeDecreaseAmount;
+    private statBuffer;
+    private throttledSendStats;
+    private discoRetries;
+    private refreshIceServersRetryPromise;
+    private refreshIceServersTimer;
+    private iceServers;
+    private stanzaInstance?;
+    private stanzaSessions;
+    private webrtcSessions;
+    private reinviteCache;
+    private sessionsMap;
+    get jid(): string | undefined;
+    constructor(client: Client, clientOptions: IClientOptions);
+    private onOnlineStatusChange;
+    handleStanzaInstanceChange(stanzaInstance: NamedAgent): Promise<void>;
+    configureNewStanzaInstance(stanzaInstance: NamedAgent): Promise<void>;
+    private configureStanzaIceServers;
+    private handleGenesysOffer;
+    private applyEarlyIceCandidates;
+    private handleGenesysRenegotiate;
+    private handleGenesysIceCandidate;
+    private handleGenesysTerminate;
+    private getSessionById;
+    sendIq(iq: IQ): Promise<any>;
+    handleMessage(msg: any): Promise<void>;
+    handleGenesysWebrtcStanza(iq: IQ): Promise<boolean | void>;
+    prepareSession(options: SessionOpts): StanzaMediaSession | undefined;
+    proxyStatsForSession(session: IMediaSession): void;
+    addStatToQueue<T extends {
+        _eventType: string;
+    }>(stat: InsightAction<T>): void;
+    getLogDetailsForPendingSessionId(sessionId: string): {
+        conversationId?: string;
+        sessionId: string;
+        sessionType?: SessionTypes;
+    };
+    sendStatsImmediately(): void;
+    sendStats(): Promise<void>;
+    addEventListeners(): void;
+    /**
+     * Stanza Handlers
+     */
+    private handlePropose;
+    private handleRetract;
+    /**
+     * Inform the client that another client has already taken care of the pendingSession
+     */
+    private handledIncomingRtcSession;
+    /**
+     * Exposed Api
+     */
+    initiateRtcSession(opts: InitRtcSessionOptions): Promise<any>;
+    acceptRtcSession(sessionId: string): Promise<void>;
+    rejectRtcSession(sessionId: string, ignore?: boolean): Promise<void>;
+    rtcSessionAccepted(sessionId: string): Promise<void>;
+    notifyScreenShareStart(session: IMediaSession): Promise<void>;
+    notifyScreenShareStop(session: IMediaSession): Promise<void>;
+    cancelRtcSession(sessionId: string): Promise<void>;
+    refreshIceServers(): Promise<ExtendedRTCIceServer[]>;
+    _refreshIceServers(stanzaInstance?: NamedAgent): Promise<ExtendedRTCIceServer[]>;
+    setIceServers(iceServers: any[], stanzaInstance: NamedAgent): void;
+    getIceTransportPolicy(): RTCIceTransportPolicy | undefined;
+    setIceTransportPolicy(policy: 'relay' | 'all', stanzaInstance: NamedAgent): void;
+    getSessionTypeByJid(jid: string): SessionTypes;
+    getSessionManager(): SessionManager | undefined;
+    getAllSessions(): IMediaSession[];
+    proxyNRStat(stat: NRProxyStat): void;
+    get expose(): WebrtcExtensionAPI;
+}
+export interface WebrtcExtensionAPI {
+    on: (event: string, handler: (...args: any) => void) => void;
+    once: (event: string, handler: (...args: any) => void) => void;
+    off: (event: string, handler: (...args: any) => void) => void;
+    removeAllListeners(event?: string | symbol): void;
+    removeListener(event: string | symbol, listener: (...args: any[]) => void): void;
+    refreshIceServers(): Promise<any[]>;
+    acceptRtcSession(sessionId: string): void;
+    rejectRtcSession(sessionId: string, ignore?: boolean): void;
+    cancelRtcSession(sessionId: string): void;
+    rtcSessionAccepted(sessionId: string): void;
+    initiateRtcSession(opts: InitRtcSessionOptions): Promise<void>;
+    notifyScreenShareStart(session: IMediaSession): void;
+    notifyScreenShareStop(session: IMediaSession): void;
+    getSessionTypeByJid(jid: string): SessionTypes;
+    getSessionManager: () => SessionManager | undefined;
+    getAllSessions: () => IMediaSession[];
+    proxyNRStat: (stat: NRProxyStat) => void;
+}