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

package/dist/es/stanza-definitions/webrtc-signaling.d.ts

@@ -0,0 +1,29 @@
+import { DefinitionOptions } from 'stanza/jxt';
+import { Stanzas } from 'stanza';
+import { GenesysMediaMessage, GenesysWebrtcJsonRpcMessage } from '../types/interfaces';
+export interface Propose {
+    sessionId: string;
+    conversationId: string;
+    autoAnswer: boolean;
+    persistentConversationId?: string;
+    originalRoomJid?: string;
+    fromUserId?: string;
+    sdpOverXmpp?: boolean;
+    privAnswerMode?: 'Auto';
+}
+declare module 'stanza/protocol' {
+    interface IQPayload {
+        genesysWebrtc?: GenesysWebrtcJsonRpcMessage;
+    }
+    interface ReceivedMessage {
+        mediaMessage?: GenesysMediaMessage;
+    }
+}
+declare module 'stanza' {
+    interface AgentEvents {
+        'iq:set:genesysWebrtc': Stanzas.ReceivedIQ & {
+            genesysWebrtc: GenesysWebrtcJsonRpcMessage;
+        };
+    }
+}
+export declare const definitions: DefinitionOptions<any>[];

package/dist/es/stanza-definitions/webrtc-signaling.js

@@ -0,0 +1,110 @@
+import { attribute, booleanAttribute, childAttribute, childJSON } from 'stanza/jxt';
+import { NS_CLIENT, NS_JINGLE_RTP_INFO_1 } from 'stanza/Namespaces';
+const NS_JINGLE_SIGNALING = 'urn:xmpp:jingle-message:0';
+const proposeDefinition = {
+    aliases: ['message.propose'],
+    element: 'propose',
+    fields: {
+        conversationId: attribute('inin-cid'),
+        persistentConversationId: attribute('inin-persistent-cid'),
+        sdpOverXmpp: booleanAttribute('inin-sdp-over-xmpp'),
+        privAnswerMode: attribute('inin-priv-answer-mode'),
+        originalRoomJid: attribute('inin-ofrom'),
+        autoAnswer: booleanAttribute('inin-autoanswer'),
+        fromUserId: attribute('inin-user-id'),
+        sessionId: attribute('id'),
+        meetingId: attribute('inin-meeting-id')
+    },
+    namespace: NS_JINGLE_SIGNALING
+};
+const proceedDefinition = {
+    aliases: ['message.proceed'],
+    element: 'proceed',
+    fields: {
+        sessionId: attribute('id')
+    },
+    namespace: NS_JINGLE_SIGNALING
+};
+const sessionAcceptedDefinition = {
+    aliases: ['message.accept'],
+    element: 'accept',
+    fields: {
+        sessionId: attribute('id')
+    },
+    namespace: NS_JINGLE_SIGNALING
+};
+const sessionRejectedDefinition = {
+    aliases: ['message.reject'],
+    element: 'reject',
+    fields: {
+        sessionId: attribute('id')
+    },
+    namespace: NS_JINGLE_SIGNALING
+};
+const sessionRetractedDefinition = {
+    aliases: ['message.retract'],
+    element: 'retract',
+    fields: {
+        sessionId: attribute('id')
+    },
+    namespace: NS_JINGLE_SIGNALING
+};
+const screenStartDefinition = {
+    aliases: ['iq.jingle.screenstart'],
+    element: 'screen-start',
+    namespace: NS_JINGLE_RTP_INFO_1
+};
+const screenStopDefinition = {
+    aliases: ['iq.jingle.screenstop'],
+    element: 'screen-stop',
+    namespace: NS_JINGLE_RTP_INFO_1
+};
+// this allows parsing xml that looks something like this:
+/*
+  <iq xmlns="jabber:client" [other stuff]>
+    <genesys-webrtc xmlns="genesys">{ "id": "whatver", "anyOtherFieldICareAbout": true }</genesys-webrtc>
+  </iq>
+*/
+const genesysWebrtc = {
+    path: 'iq',
+    namespace: NS_CLIENT,
+    element: 'iq',
+    fields: {
+        genesysWebrtc: childJSON('genesys', 'genesys-webrtc')
+    }
+};
+const mediaMessage = {
+    path: 'message',
+    namespace: NS_CLIENT,
+    element: 'message',
+    fields: {
+        mediaMessage: childJSON('genesys', 'media-message')
+    }
+};
+const upgradeMediaPresenceDefinition = {
+    aliases: ['presence.media'],
+    element: 'x',
+    fields: {
+        conversationId: attribute('conversationId'),
+        sourceCommunicationId: attribute('sourceCommunicationId'),
+        screenShare: childAttribute(null, 'mediastream', 'screenShare'),
+        video: childAttribute(null, 'mediastream', 'video'),
+        audio: childAttribute(null, 'mediastream', 'audio'),
+        listener: childAttribute(null, 'mediastream', 'listener'),
+        screenRecording: childAttribute(null, 'mediastream', 'screenRecording'),
+        videoGuest: childAttribute(null, 'mediastream', 'videoGuest')
+    },
+    namespace: 'orgspan:mediastream'
+};
+export const definitions = [
+    proposeDefinition,
+    proceedDefinition,
+    sessionAcceptedDefinition,
+    sessionRejectedDefinition,
+    sessionRetractedDefinition,
+    screenStartDefinition,
+    screenStopDefinition,
+    upgradeMediaPresenceDefinition,
+    genesysWebrtc,
+    mediaMessage
+];

package/dist/es/stanza-definitions/xep0051.d.ts

@@ -0,0 +1,19 @@
+import { Stanzas } from 'stanza';
+import { DefinitionOptions } from 'stanza/jxt';
+declare module 'stanza' {
+    interface AgentEvents {
+        'iq:set:connectionTransfer': Stanzas.ReceivedIQ & {
+            query: ConnectionTransfer;
+        };
+    }
+}
+declare module 'stanza/protocol' {
+    interface IQPayload {
+        query?: ConnectionTransfer;
+    }
+}
+export interface ConnectionTransfer {
+    domain?: string;
+    server?: string;
+}
+export declare const connectionTransfer: DefinitionOptions;

package/dist/es/stanza-definitions/xep0051.js

@@ -0,0 +1,25 @@
+import { childText } from 'stanza/jxt';
+// XEP-0051: Connection Transfer
+// Source: https://xmpp.org/extensions/xep-0051.html
+// Version: 0.2.1 (2022-03-08)
+// ---------------------------
+// We don't currently use domain or server
+const NS_CONNECTION_TRANSFER = 'urn:xmpp:cxfr';
+/*
+  <iq xmlns="jabber:client" id="<someId>" to="<toJID>" type="set">
+    <query xmlns="urn:xmpp:cxfr">
+      <domain>jabber.org</domain>
+      <server>123.123.123.122</server>
+    </query>
+  </iq>
+*/
+export const connectionTransfer = {
+    path: 'iq.query',
+    aliases: ['iq.connectionTransfer'],
+    namespace: NS_CONNECTION_TRANSFER,
+    element: 'query',
+    fields: {
+        domain: childText(null, 'domain'),
+        server: childText(null, 'server')
+    }
+};

package/dist/es/stats-formatter.d.ts

@@ -0,0 +1,6 @@
+import { StatsEvent } from 'webrtc-stats-gatherer';
+import { FlatObject, InsightAction } from './types/interfaces';
+export declare function formatStatsEvent(event: StatsEvent, extraDetails?: FlatObject): InsightAction<{
+    _eventType: string;
+} & FlatObject>;
+export declare function deepFlatten(obj: any, prefix?: string): any;

package/dist/es/stats-formatter.js

@@ -0,0 +1,54 @@
+function isGetStatsEvent(event) {
+    return event.name === 'getStats';
+}
+function prepGetStatsEvent(event) {
+    const details = {};
+    Object.assign(details, deepFlatten(event.tracks, 'localTrack'));
+    delete event.tracks;
+    Object.assign(details, deepFlatten(event.remoteTracks, 'remoteTrack'));
+    delete event.remoteTracks;
+    return details;
+}
+export function formatStatsEvent(event, extraDetails = {}) {
+    const details = Object.assign({ _eventType: event.name, _eventTimestamp: new Date().getTime() }, extraDetails);
+    // anything that needs to be renamed or massaged
+    if (isGetStatsEvent(event)) {
+        Object.assign(details, prepGetStatsEvent(event));
+    }
+    // general case
+    Object.assign(details, deepFlatten(event));
+    delete details.name;
+    const formattedEvent = {
+        actionName: 'WebrtcStats',
+        details
+    };
+    return formattedEvent;
+}
+export function deepFlatten(obj, prefix = '') {
+    const flatObj = {};
+    if (Array.isArray(obj)) {
+        for (let i = 0; i < obj.length; i++) {
+            Object.assign(flatObj, deepFlatten(obj[i], `${prefix}_[${i}]`));
+        }
+    }
+    else if (typeof obj !== 'object') {
+        flatObj[prefix] = obj;
+    }
+    else {
+        Object.keys(obj)
+            /* Filter all IP addresses before sending to NR.
+            https://developer.mozilla.org/en-US/docs/Web/API/RTCIceCandidatePairStats */
+            .filter(key => !['ip', 'address', 'relatedaddress'].includes(key.toLowerCase()))
+            .forEach((key) => {
+            const val = obj[key];
+            const nextPrefix = prefix ? `${prefix}_${key}` : key;
+            if (typeof val !== 'object' && !Array.isArray(val)) {
+                flatObj[nextPrefix] = val;
+            }
+            else {
+                Object.assign(flatObj, deepFlatten(val, nextPrefix));
+            }
+        });
+    }
+    return flatObj;
+}

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

@@ -0,0 +1,64 @@
+import { JingleReasonCondition } from 'stanza/Constants';
+import { JingleReason } from 'stanza/protocol';
+import { ConnectionState, IGenesysCloudMediaSessionParams, IMediaSession, SessionState } from './media-session';
+import { WebrtcExtension } from '../webrtc';
+import { SessionTypes } from './interfaces';
+export interface GenesysCloudMediaSession extends IMediaSession {
+}
+export declare class GenesysCloudMediaSession {
+    private webrtcExtension;
+    private statsGatherer?;
+    private iceCandidatesDiscovered;
+    private iceCandidatesReceivedFromPeer;
+    private interruptionStart?;
+    private logger;
+    private stateSyncTimeout?;
+    conversationId: string;
+    id: string;
+    fromJid: string;
+    peerID: string;
+    peerConnection: RTCPeerConnection;
+    fromUserId?: string;
+    originalRoomJid?: string;
+    sessionType: SessionTypes;
+    ignoreHostCandidatesFromRemote: boolean;
+    allowIPv6: boolean;
+    allowTCP: boolean;
+    dataChannel?: RTCDataChannel;
+    state: SessionState;
+    connectionState: ConnectionState;
+    privAnswerMode?: 'Auto';
+    constructor(webrtcExtension: WebrtcExtension, params: IGenesysCloudMediaSessionParams);
+    private keepStateInSyncWithPeerConnection;
+    setRemoteDescription(sdp: string): Promise<void>;
+    private getLogDetails;
+    private log;
+    private sendGenesysWebrtc;
+    end(reason?: JingleReasonCondition | JingleReason, silent?: boolean): Promise<void>;
+    setupStatsGatherer(): void;
+    protected onIceStateChange(): Promise<void>;
+    protected onConnectionStateChange(): void;
+    protected onIceCandidateError(ev: Event): void;
+    private createIceCandidate;
+    addRemoteIceCandidate(sdpFragment: string): Promise<void>;
+    protected onIceCandidate(e: RTCPeerConnectionIceEvent): Promise<any> | undefined;
+    onSessionTerminate(reason?: JingleReasonCondition): void;
+    addTrack(track: MediaStreamTrack, stream?: MediaStream): Promise<void>;
+    protected _setupDataChannel(): void;
+    _handleDataChannelMessage(event: MessageEvent): void;
+    accept(): Promise<any>;
+    mute(userId: string, type: 'audio' | 'video'): Promise<any>;
+    unmute(userId: string, type: 'audio' | 'video'): Promise<any>;
+    removeTrack(): Promise<void>;
+    hold(): Promise<void>;
+    resume(): Promise<void>;
+    toString(): {
+        connectionState: ConnectionState;
+        state: SessionState;
+        sessionType: SessionTypes;
+        fromJid: string;
+        conversationId: string;
+        id: string;
+        peerConnection: RTCPeerConnection;
+    };
+}