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

package/dist/cjs/types/interfaces.d.ts

@@ -0,0 +1,310 @@
+import { ILogger, LogFormatterFn, LogLevel } from 'genesys-cloud-client-logger';
+import { AxiosError, ResponseType } from 'axios';
+import { NamedAgent } from './named-agent';
+import { JingleReasonCondition } from 'stanza/Constants';
+export { ILogger, LogLevel };
+export interface IClientOptions {
+    host: string;
+    apiHost?: string;
+    authToken?: string;
+    jwt?: string;
+    jid?: string;
+    userId?: string;
+    jidResource?: string;
+    reconnectOnNoLongerSubscribed?: boolean;
+    optOutOfWebrtcStatsTelemetry?: boolean;
+    allowIPv6?: boolean;
+    logger?: ILogger;
+    logLevel?: LogLevel;
+    logFormatters?: LogFormatterFn[];
+    signalIceConnected?: boolean;
+    useServerSidePings?: boolean;
+    appName?: string;
+    appVersion?: string;
+    appId?: string;
+    customHeaders?: ICustomHeader;
+    /** When true, creates a unique log uploader instance rather than sharing a singleton per URL. */
+    useUniqueLogUploader?: boolean;
+    /** Allow bulk topic resubscribe to succeed or fail per-topic rather than all or nothing */
+    enablePartialBulkResubscribe?: boolean;
+    /** Genesys internal use only - non-Genesys apps that pass in `alertableInteractionTypes` may experience unexpected behavior */
+    alertableInteractionTypes?: AlertableInteractionTypes[];
+}
+export interface ICustomHeader {
+    [header: string]: string;
+}
+export declare enum AlertableInteractionTypes {
+    voice = "voice"
+}
+/** The alerting status for an interaction type */
+export interface IAlertingStatus {
+    /**
+     * Indicates whether this client should be alerting. This can be because this client is the alerting
+     * leader for this interaction type, alerting leader functionality is not configured by an admin,
+     * or because setup for alerting leader failed and we fallback to `alerting: true` so interactions
+     * don't go unnoticed.
+     */
+    alerting: boolean;
+    /**
+     * Indicates if alerting leader functionality is configured by an admin. This will also be `false`
+     * if setup for alerting leader failed.
+    */
+    configured: boolean;
+    /** A string representing the client type of the alerting leader, based on OAuth client ID. */
+    clientType?: string;
+}
+/** The alerting leader status for this client. Currently only `voice` interactions are supported. */
+export interface ILeaderStatus {
+    voice?: IAlertingStatus;
+}
+export interface IClientConfig {
+    host: string;
+    apiHost: string;
+    authToken?: string;
+    jwt?: string;
+    userId?: string;
+    jid?: string;
+    jidResource?: string;
+    channelId: string;
+    appName?: string;
+    appVersion?: string;
+    appId?: string;
+    logLevel?: LogLevel;
+    customHeaders?: ICustomHeader;
+}
+export interface IHttpClientOptions {
+    customHeaders?: ICustomHeader;
+}
+export interface ExtendedRTCIceServer extends RTCIceServer {
+    type: string;
+}
+export declare type RequestApiOptions = {
+    method: 'get' | 'post' | 'patch' | 'put' | 'delete';
+    host: string;
+    data?: any;
+    version?: string;
+    responseType?: ResponseType;
+    contentType?: string;
+    authToken?: string;
+    logger?: any;
+    noAuthHeader?: boolean;
+    requestTimeout?: number;
+    customHeaders?: ICustomHeader;
+    maxAttempts?: number;
+    signal?: AbortSignal;
+};
+export interface IAxiosResponseError extends AxiosError {
+    text: string;
+}
+export interface ISuperagentNetworkError extends Error {
+    status: number | undefined;
+    method: string;
+    url: string;
+    crossDomain: boolean;
+}
+export interface ISuperagentResponseError {
+    original?: any;
+    status: number;
+    response: {
+        body: any;
+        error: ISuperagentNetworkError;
+        header: {
+            [key: string]: string;
+        };
+        headers: {
+            [key: string]: string;
+        };
+        status: number;
+        statusCode: number;
+        statusText: string;
+        text: string;
+        req: {
+            method: string;
+            _data?: string;
+        };
+    };
+}
+export interface INetworkError extends IError {
+    status: number;
+    method: string;
+    url: string;
+    crossDomain: boolean;
+}
+export interface IResponseError extends IError {
+    status: number;
+    correlationId: string;
+    responseBody: string;
+    method: string;
+    requestBody: string;
+    url: string;
+}
+export declare enum StreamingClientErrorTypes {
+    generic = "generic",
+    invalid_token = "invalid_token",
+    userCancelled = "user_cancelled"
+}
+export interface IError {
+    message: string;
+    name: string;
+    stack?: string;
+}
+export declare type SessionTypesAsStrings = 'softphone' | 'screenShare' | 'screenRecording' | 'liveScreenMonitoring' | 'collaborateVideo' | 'unknown';
+export declare enum SessionTypes {
+    softphone = "softphone",
+    collaborateVideo = "collaborateVideo",
+    acdScreenShare = "screenShare",
+    screenRecording = "screenRecording",
+    liveScreenMonitoring = "liveScreenMonitoring",
+    unknown = "unknown"
+}
+export interface ISessionInfo extends IPendingSession {
+}
+export interface IPendingSession {
+    sessionId: string;
+    id: string;
+    autoAnswer: boolean;
+    toJid: string;
+    fromJid: string;
+    conversationId: string;
+    originalRoomJid?: string;
+    sdpOverXmpp?: boolean;
+    privAnswerMode?: 'Auto';
+    fromUserId?: string;
+    roomJid?: string;
+    accepted?: boolean;
+    meetingId?: string;
+    sessionType: SessionTypes | SessionTypesAsStrings;
+}
+export interface StreamingClientExtension {
+    handleIq?: Function;
+    handleMessage?: Function;
+    handleStanzaInstanceChange: (stanzaInstance: NamedAgent) => void;
+    expose: any;
+}
+export interface StreamingClientConnectOptions {
+    /**
+     * @deprecated since version 15.1.1. Please use maxConnectionAttempts instead
+     */
+    keepTryingOnFailure?: boolean;
+    maxConnectionAttempts?: number;
+    maxDelayBetweenConnectionAttempts?: number;
+}
+export interface StreamingSubscriptionErrorDetails {
+    missingPermissions?: string[];
+}
+export declare type GenesysWebrtcBaseParams = {
+    sessionId: string;
+};
+export declare type GenesysWebrtcSdpParams = GenesysWebrtcBaseParams & {
+    sdp: string;
+};
+export declare type GenesysWebrtcOfferParams = GenesysWebrtcSdpParams & {
+    conversationId: string;
+    reinvite?: boolean;
+};
+export declare type GenesysInfoActiveParams = GenesysWebrtcBaseParams & {
+    status: 'active';
+};
+export declare type GenesysSessionTerminateParams = GenesysWebrtcBaseParams & {
+    reason?: JingleReasonCondition;
+};
+export declare type GenesysWebrtcMuteParams = GenesysWebrtcBaseParams & {
+    type: 'audio' | 'video';
+};
+export declare type TypedJsonRpcMessage<Method extends string, Params> = {
+    jsonrpc: string;
+    method: Method;
+    id?: string;
+    params?: Params;
+};
+export declare type JsonRpcMessage = TypedJsonRpcMessage<string, any>;
+export declare type GenesysWebrtcOffer = TypedJsonRpcMessage<'offer', GenesysWebrtcOfferParams>;
+export declare type GenesysWebrtcAnswer = TypedJsonRpcMessage<'answer', GenesysWebrtcSdpParams>;
+export declare type GenesysWebrtcInfo = TypedJsonRpcMessage<'info', GenesysInfoActiveParams>;
+export declare type GenesysWebrtcIceCandidate = TypedJsonRpcMessage<'iceCandidate', GenesysWebrtcSdpParams>;
+export declare type GenesysWebrtcTerminate = TypedJsonRpcMessage<'terminate', GenesysSessionTerminateParams>;
+export declare type GenesysWebrtcMute = TypedJsonRpcMessage<'mute', GenesysWebrtcMuteParams>;
+export declare type GenesysWebrtcUnmute = TypedJsonRpcMessage<'unmute', GenesysWebrtcMuteParams>;
+export declare type GenesysWebrtcJsonRpcMessage = GenesysWebrtcOffer | GenesysWebrtcAnswer | GenesysWebrtcInfo | GenesysWebrtcIceCandidate | GenesysWebrtcTerminate | GenesysWebrtcMute | GenesysWebrtcUnmute;
+export declare type HeadsetControlsRequestType = 'mediaHelper' | 'standard' | 'prioritized';
+export declare type HeadsetControlsRejectionReason = 'activeCall' | 'mediaHelper' | 'priority';
+export declare type HeadsetControlsRejectionParams = {
+    requestId: string;
+    reason: HeadsetControlsRejectionReason;
+};
+export declare type HeadsetControlsChangedParams = {
+    hasControls: boolean;
+};
+export declare type HeadsetControlsRequest = TypedJsonRpcMessage<'headsetControlsRequest', {
+    requestType: HeadsetControlsRequestType;
+}>;
+export declare type HeadsetControlsRejection = TypedJsonRpcMessage<'headsetControlsRejection', HeadsetControlsRejectionParams>;
+export declare type HeadsetControlsChanged = TypedJsonRpcMessage<'headsetControlsChanged', HeadsetControlsChangedParams>;
+export declare type GenesysMediaMessage = HeadsetControlsRequest | HeadsetControlsRejection | HeadsetControlsChanged;
+export declare type FlatObject = {
+    [key: string]: string | number | boolean | null | Date;
+};
+export declare type GenericAction = {
+    _eventType: string;
+};
+export declare type InsightReport = {
+    appName: string;
+    appVersion: string;
+    originAppName?: string;
+    originAppVersion?: string;
+    actions: InsightAction<any>[];
+};
+export declare type InsightAction<T extends {
+    _eventType: string;
+}> = {
+    actionName: 'WebrtcStats';
+    details: InsightActionDetails<T>;
+};
+export declare type InsightActionDetails<K extends {
+    _eventType: string;
+}> = {
+    _eventType: K['_eventType'];
+    /**
+     * This should be ms since epoch, e.g. new Date().getTime()
+     */
+    _eventTimestamp: number;
+    _appId?: string;
+    _appName?: string;
+    _appVersion?: string;
+} & K;
+export declare type OnlineStatusStat = InsightAction<{
+    _eventType: 'onlineStatus';
+    online: boolean;
+}>;
+export declare type FirstProposeStat = InsightAction<{
+    _eventType: 'firstPropose';
+    sdpViaXmppRequested: boolean;
+    sessionType: SessionTypesAsStrings;
+    originAppId?: string;
+    conversationId: string;
+    sessionId: string;
+}>;
+export declare type FirstAlertingConversationStat = InsightAction<{
+    _eventType: 'firstAlertingConversationUpdate';
+    conversationId: string;
+    participantId: string;
+}>;
+export declare type MediaStat = InsightAction<{
+    _eventType: 'mediaRequested' | 'mediaStarted' | 'mediaError';
+    requestId?: string;
+    message?: string;
+    audioRequested: boolean;
+    videoRequested: boolean;
+    displayRequested: boolean;
+    conversationId?: string;
+    sessionType?: SessionTypesAsStrings;
+    sessionId?: string;
+    elapsedMsFromInitialRequest?: number;
+}>;
+export declare type NRProxyStat = FirstAlertingConversationStat | MediaStat;
+export declare type SCConnectionData = {
+    currentDelayMs: number;
+    delayMsAfterNextReduction?: number;
+    nextDelayReductionTime?: number;
+    timeOfTotalReset?: number;
+};

package/dist/cjs/types/interfaces.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionTypes = exports.StreamingClientErrorTypes = exports.AlertableInteractionTypes = void 0;
+var AlertableInteractionTypes;
+(function (AlertableInteractionTypes) {
+    AlertableInteractionTypes["voice"] = "voice";
+})(AlertableInteractionTypes = exports.AlertableInteractionTypes || (exports.AlertableInteractionTypes = {}));
+var StreamingClientErrorTypes;
+(function (StreamingClientErrorTypes) {
+    StreamingClientErrorTypes["generic"] = "generic";
+    StreamingClientErrorTypes["invalid_token"] = "invalid_token";
+    StreamingClientErrorTypes["userCancelled"] = "user_cancelled";
+})(StreamingClientErrorTypes = exports.StreamingClientErrorTypes || (exports.StreamingClientErrorTypes = {}));
+var SessionTypes;
+(function (SessionTypes) {
+    SessionTypes["softphone"] = "softphone";
+    SessionTypes["collaborateVideo"] = "collaborateVideo";
+    SessionTypes["acdScreenShare"] = "screenShare";
+    SessionTypes["screenRecording"] = "screenRecording";
+    SessionTypes["liveScreenMonitoring"] = "liveScreenMonitoring";
+    SessionTypes["unknown"] = "unknown";
+})(SessionTypes = exports.SessionTypes || (exports.SessionTypes = {}));

package/dist/cjs/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/cjs/types/libs.js

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

package/dist/cjs/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/cjs/types/media-session.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/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/cjs/types/named-agent.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

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

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

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class OfflineError extends Error {
+}
+exports.default = OfflineError;

package/dist/cjs/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/cjs/types/sasl-error.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class SaslError extends Error {
+    constructor(condition, channelId, stanzaInstanceId) {
+        super();
+        this.condition = condition;
+        this.channelId = channelId;
+        this.stanzaInstanceId = stanzaInstanceId;
+        this.name = 'SaslError';
+    }
+}
+exports.default = SaslError;

package/dist/cjs/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;
+}