Secure Stream Recording: A Guide for Developers

Examples

Client side

This code demonstrates the usage of the eyeson-streamrec library. It imports the library, sets up necessary variables, and demonstrates how to connect, record, switch media streams, stop recording, and disconnect from a session. Here's a step-by-step explanation:

• Import the library: import eyeson from 'eyeson-streamrec'; imports the eyeson-streamrec library.

• Initialize variables: Four variables are initialized: clientId, clientAuthToken, stream, and webhookUrl. These are required for authentication and working with the media streams and webhooks.

• Define an event listener: eyeson.addEventListener() adds an event listener that listens for events from the Eyeson API. This example listens for 'connected' and 'disconnected' events and logs them to the console along with their termination cause, if available.

• Connect to a session: await eyeson.connect(clientId, clientAuthToken, stream, webhookUrl); connects the client to an Eyeson session using their client ID, authentication token, media stream, and a webhook URL.

• Start recording: await eyeson.startRecording(uploadUrl, webhookUrl); starts recording the connected session. The recording will be uploaded to the specified uploadUrl, and webhook events will be sent to the given webhookUrl.

• Switch media streams: await eyeson.switchStream(newStream); allows switching to a different media stream (newStream) if needed.

• Stop recording: await eyeson.stopRecording(); stops the recording of the current session.

• Disconnect from the session: await eyeson.disconnect(); disconnects the client from the session.

The entire process is wrapped in an asynchronous immediately-invoked function expression (IIFE) and uses a try-catch block for error handling.

import eyeson from 'eyeson-streamrec';

const clientId; // client identifier
const clientAuthToken; // client auth token gathered by the streamrec service
const stream; // media stream
const webhookUrl; // target URL for webhooks

(async () => {
  try {
    eyeson.addEventListener(({ type, termination_cause }) => {
        if (type === 'connected') {
            console.log('connected');
        }
        if (type === 'disconnected') {
            console.log('disconnected', termination_cause);
        }
    });

    // connect the client to a session
    await eyeson.connect(clientId, clientAuthToken, stream, webhookUrl);
    // start a recording for the connected session
    await eyeson.startRecording(uploadUrl, webhookUrl);
    
    // switch to another media stream if needed
    await eyeson.switchStream(newStream);

    // ensure Recording is started and has not yet been stopped before stopping
    // the recording or switching the stream
    await eyeson.stopRecording();

    // disconnect the client session
    await eyeson.disconnect();
  } catch(err) {
    console.error(err);
  }
})();

Supervisor session

This code demonstrates the usage of the eyeson-streamrec library to connect a supervisor to a video session. It imports the library, sets up necessary variables, and demonstrates how to connect the supervisor, display the remote video stream, and disconnect from the session. Here's a step-by-step explanation:

• Import the library: import { Supervisor } from 'eyeson-streamrec'; imports the Supervisor class from the eyeson-streamrec library.

• Initialize variables: Five variables are initialized: supervisorId, clientId, supervisorAuthToken, webhookUrl, and video. These are required for authentication, working with the media streams, and webhooks.

• Define an event listener: Supervisor.addEventListener() adds an event listener that listens for events from the Eyeson API. This example listens for the 'disconnected' event and logs it to the console. When the disconnection occurs, the srcObject of the video element is set to null.

• Connect the supervisor: const remoteStream = await Supervisor.connect(supervisorId, supervisorAuthToken, clientId, webhookUrl); connects the supervisor to an Eyeson session using their supervisor ID, authentication token, client ID, and a webhook URL. It returns the remote media stream.

• Display the remote stream: video.srcObject = remoteStream; and video.play(); set the srcObject of the video element to the remote media stream and start playing the video.

• Disconnect from the session: await Supervisor.disconnect(); disconnects the supervisor from the session.

The entire process is wrapped in an asynchronous immediately-invoked function expression (IIFE) and uses a try-catch block for error handling.

import { Supervisor } from 'eyeson-streamrec';

const supervisorId; // supervisor identifier
const clientId; // client identifier
const supervisorAuthToken; // supervisor auth token gathered by the streamrec service
const webhookUrl; // target URL for webhooks
const video; // video element

(async () => {
  try {
    Supervisor.addEventListener(({ type }) => {
        if (type === 'disconnected') {
          console.log('disconnected');
          video.srcObject = null;
        }
    });
    const remoteStream = await Supervisor.connect(supervisorId, supervisorAuthToken, clientId, webhookUrl);
    console.log('connected');
    video.srcObject = remoteStream;
    video.play();

    await Supervisor.disconnect();
  } catch(err) {
    console.error(err);
  }
})();