STREAM-777: try again

Author: Aidan Zimmermann

.gitignore

@@ -14,13 +14,17 @@ test/test-pages/*/index.html
 
 *.tgz
 .ignore
+.DS_Store
 
 ## vscode specific files
 /.vscode
 
 ## webstorm specific files
 /.idea
 
+## jetbrains specific files
+genesys-cloud-webrtc-sdk.iml
+
 # tap specific files
 /.nyc_output
 /coverage

src/client.ts

@@ -25,6 +25,7 @@ import {
   IPendingSessionActionParams,
   IExtendedMediaSession,
   ScreenRecordingMediaSession,
+  ScreenRecordingMetadata,
   VideoMediaSession,
   IVideoResolution,
   JWTDetails,
@@ -402,6 +403,25 @@ export class GenesysCloudWebrtcSdk extends (EventEmitter as { new(): StrictEvent
     return this.sessionManager.startSession({ meetingId, sessionType: SessionTypes.collaborateVideo });
   }
 
+  /**
+   * Start a screen conference session that identifies the primary screen
+   * from the provided metadata and joins a conference using that screen as video.
+   *
+   * `initialize()` must be called first.
+   *
+   * @param conferenceJid JID of the conference to join
+   * @param screenRecordingMetadatas Array of screen metadata to identify primary screen
+   *
+   * @returns a promise with an object with the newly created 'conversationId'
+   */
+  async startLiveMonitoringSession (conferenceJid: string, screenRecordingMetadatas: ScreenRecordingMetadata[]): Promise<{ conversationId: string }> {
+    return this.sessionManager.startSession({
+      conferenceJid,
+      screenRecordingMetadatas,
+      sessionType: SessionTypes.collaborateVideo
+    });
+  }
+
   /**
    * Start a softphone session with the given peer or peers.
    *  `initialize()` must be called first.

src/index.ts

@@ -8,6 +8,7 @@ export * from './sessions/softphone-session-handler';
 export * from './sessions/video-session-handler';
 export * from './sessions/screen-recording-session-handler';
 export * from './sessions/screen-share-session-handler';
+export * from './sessions/live-monitoring-session-handler';
 export { ExpandedDeviceConnectionStatus } from './headsets/headset-types';
 
 import * as utils from './utils';

src/sessions/live-monitoring-session-handler.ts

@@ -0,0 +1,105 @@
+import {
+  IPendingSession,
+  IExtendedMediaSession,
+  IAcceptSessionRequest,
+  ScreenRecordingMetadata,
+  IUpdateOutgoingMedia, IStartScreenConferenceSessionParams,
+} from '../types/interfaces';
+import BaseSessionHandler from './base-session-handler';
+import { SessionTypes, SdkErrorTypes } from '../types/enums';
+import {createAndEmitSdkError, isMonitorJid, requestApi} from '../utils';
+
+export class LiveMonitoringSessionHandler extends BaseSessionHandler {
+  sessionType = SessionTypes.collaborateVideo;
+  private primaryScreenMediaStream?: MediaStream;
+
+  shouldHandleSessionByJid(jid: string): boolean {
+    return isMonitorJid(jid);
+  }
+
+  handleConversationUpdate(): void {
+    /* no-op */
+    return;
+  }
+
+  async handlePropose (pendingSession: IPendingSession): Promise<void> {
+    return this.proceedWithSession(pendingSession);
+  }
+
+  async startSession(params: IStartScreenConferenceSessionParams): Promise<{ conversationId: string }> {
+    const primaryScreen = this.identifyPrimaryScreen(params.screenRecordingMetadatas);
+
+    if (!primaryScreen) {
+      throw createAndEmitSdkError.call(this.sdk, SdkErrorTypes.invalid_options, 'No primary screen found in metadata');
+    }
+
+    const screenStream = await this.getScreenMediaForPrimary(primaryScreen);
+
+    return this.joinConferenceWithScreen(params.conferenceJid, screenStream);
+  }
+
+  private identifyPrimaryScreen(metadatas: ScreenRecordingMetadata[]): ScreenRecordingMetadata | null {
+    return metadatas.find(metadata => metadata.primary) || null;
+  }
+
+  private async getScreenMediaForPrimary(primaryScreen: ScreenRecordingMetadata): Promise<MediaStream> {
+    try {
+      const constraints = {
+        video: {
+          deviceId: primaryScreen.screenId
+        }
+      } as DisplayMediaStreamOptions;
+
+      return await window.navigator.mediaDevices.getDisplayMedia(constraints);
+    } catch (error) {
+      throw createAndEmitSdkError.call(this.sdk, SdkErrorTypes.session, 'Failed to get screen media', { error });
+    }
+  }
+
+  private async joinConferenceWithScreen(conferenceJid: string, screenStream: MediaStream): Promise<{ conversationId: string }> {
+    const data = JSON.stringify({
+      roomId: conferenceJid,
+      participant: { address: this.sdk._personDetails.chat.jabberId }
+    });
+
+    try {
+      const response = await requestApi.call(this.sdk, '/conversations/videos', {
+        method: 'post',
+        data
+      });
+
+      // Store screen stream for later use in acceptSession
+      this.primaryScreenMediaStream = screenStream;
+
+      return { conversationId: response.data.conversationId };
+    } catch (error) {
+      screenStream.getTracks().forEach(track => track.stop());
+      throw createAndEmitSdkError.call(this.sdk, SdkErrorTypes.session, 'Failed to join conference', { error });
+    }
+  }
+
+  async acceptSession(session: IExtendedMediaSession, params: IAcceptSessionRequest): Promise<any> {
+    if (!params.screenRecordingMetadatas?.length) {
+      throw createAndEmitSdkError.call(this.sdk, SdkErrorTypes.not_supported, 'acceptSession must be called with a `screenRecordingMetadatas` property for live monitoring sessions');
+    }
+
+    // Set outbound stream to primary video media stream
+    session._outboundStream = this.primaryScreenMediaStream;
+
+    // Add primary screen tracks to session
+    for (const track of this.primaryScreenMediaStream.getTracks()) {
+      session.pc.addTrack(track);
+    }
+
+    this.primaryScreenMediaStream = undefined;
+
+    return super.acceptSession(session, params);
+  }
+
+  updateOutgoingMedia(session: IExtendedMediaSession, options: IUpdateOutgoingMedia): never {
+    this.log('warn', 'Cannot update outgoing media for live monitoring sessions', { sessionId: session.id, sessionType: session.sessionType });
+    throw createAndEmitSdkError.call(this.sdk, SdkErrorTypes.not_supported, 'Cannot update outgoing media for live monitoring sessions');
+  }
+}
+
+export default LiveMonitoringSessionHandler;

src/sessions/session-manager.ts

@@ -21,19 +21,21 @@ import {
   IConversationHeldRequest,
   IPendingSessionActionParams,
   VideoMediaSession,
-  IActiveConversationDescription
+  IActiveConversationDescription, IStartScreenConferenceSessionParams
 } from '../types/interfaces';
 import { ConversationUpdate } from '../conversations/conversation-update';
 import { SessionTypesAsStrings } from 'genesys-cloud-streaming-client';
 import { Constants } from 'stanza';
 import ScreenRecordingSessionHandler from './screen-recording-session-handler';
+import LiveMonitoringSessionHandler from './live-monitoring-session-handler';
 import { WebrtcExtensionAPI } from 'genesys-cloud-streaming-client/dist/es/webrtc';
 
 const sessionHandlersToConfigure: any[] = [
   SoftphoneSessionHandler,
   VideoSessionHandler,
   ScreenShareSessionHandler,
-  ScreenRecordingSessionHandler
+  ScreenRecordingSessionHandler,
+  LiveMonitoringSessionHandler
 ];
 
 export class SessionManager {
@@ -175,7 +177,7 @@ export class SessionManager {
     return handler;
   }
 
-  async startSession (startSessionParams: IStartSessionParams | IStartVideoSessionParams | IStartVideoMeetingSessionParams | IStartSoftphoneSessionParams): Promise<any> {
+  async startSession (startSessionParams: IStartSessionParams | IStartVideoSessionParams | IStartVideoMeetingSessionParams | IStartSoftphoneSessionParams | IStartScreenConferenceSessionParams): Promise<any> {
     if (!this.sdk.connected) {
       throw createAndEmitSdkError.call(this.sdk, SdkErrorTypes.session, 'A session cannot be started as streaming client is not yet connected', { sessionType: startSessionParams.sessionType });
     }
@@ -400,7 +402,7 @@ export class SessionManager {
     }
 
     session._alreadyAccepted = true;
-    
+
     const sessionHandler = this.getSessionHandler({ jingleSession: session });
     return sessionHandler.acceptSession(session, params);
   }

src/types/interfaces.ts

@@ -1215,6 +1215,13 @@ export interface IStartSoftphoneSessionParams extends IStartSessionParams {
   uuiData?: string;
 }
 
+export interface IStartScreenConferenceSessionParams extends IStartSessionParams {
+  /** Conference room JID to join */
+  conferenceJid: string;
+  /** Screen recording metadata to identify primary screen */
+  screenRecordingMetadatas: ScreenRecordingMetadata[];
+}
+
 export interface ISdkSoftphoneDestination {
   /** address or phone number */
   address: string;

src/utils.ts

@@ -124,6 +124,10 @@ export const isAgentVideoJid = function (jid: string) {
   return isVideoJid(jid) && jid.startsWith('agent-');
 };
 
+export const isMonitorJid = function (jid: string) {
+  return isVideoJid(jid) && jid.startsWith('livemonitor-');
+};
+
 export const isVideoJid = function (jid: string): boolean {
   return jid && !!jid.match(/@conference/) && !isAcdJid(jid) && !isScreenRecordingJid(jid);
 };

test/test-utils.ts

@@ -157,6 +157,10 @@ class MockPC extends EventTarget {
   _addReceiver (track: MockTrack) {
     this._receivers.push(new MockReceiver(track));
   }
+
+  addTrack (track: MockTrack) {
+    this._addSender(track);
+  }
 }
 
 export class MockSession extends EventEmitter {

test/unit/client.test.ts

@@ -29,7 +29,7 @@ import {
   IStation,
   IPersonDetails,
   ISessionIdAndConversationId,
-  VideoSessionHandler
+  VideoSessionHandler, ScreenRecordingMetadata, IStartScreenConferenceSessionParams
 } from '../../src';
 import * as utils from '../../src/utils';
 import { RetryPromise } from 'genesys-cloud-streaming-client/dist/es/utils';
@@ -331,24 +331,22 @@ describe('Client', () => {
     });
   });
 
-  describe('startVideoMeeting()', () => {
-    it('should call session manager to start video meeting', async () => {
+  describe('startLiveMonitoringSession()', () => {
+    it('should call session manager to start a live monitoring session', async () => {
       sdk = constructSdk();
+      const conferenceJid = 'livemonitor@example.com';
+      const screenRecordingMetadatas = [{ screenId: 'screen1', primary: true } as ScreenRecordingMetadata];
 
-      sessionManagerMock.startSession.mockResolvedValue({});
-      await sdk.startVideoMeeting('123abc');
-      expect(sessionManagerMock.startSession).toBeCalledWith({ meetingId: '123abc', sessionType: SessionTypes.collaborateVideo });
-    });
+      sessionManagerMock.startSession = jest.fn().mockResolvedValue({ conversationId: 'conv123' });
 
-    it('should throw if guest user', async () => {
-      sdk = constructSdk({ organizationId: 'some-org' }); // no access_token is a guest user
-      try {
-        await sdk.startVideoMeeting('123');
-        fail('should have failed');
-      } catch (e) {
-        expect(e).toEqual(new Error('video conferencing meetings not supported for guests'));
-        expect(sessionManagerMock.startSession).not.toHaveBeenCalled();
-      }
+      const result = await sdk.startLiveMonitoringSession(conferenceJid, screenRecordingMetadatas);
+
+      expect(sessionManagerMock.startSession).toBeCalledWith({
+        conferenceJid,
+        screenRecordingMetadatas,
+        sessionType: SessionTypes.collaborateVideo
+      } as IStartScreenConferenceSessionParams);
+      expect(result).toEqual({ conversationId: 'conv123' });
     });
   });