@jenkinsopenvidu jenkinsopenvidu released this Oct 1, 2018 · 131 commits to master since this release

Assets 6

Release v2.5.0

NEW FEATURES

Kurento filters support

OpenVidu API offers a simple way of applying filters to video and audio streams in the server side by making use of Kurento Media Server capabilities. See Voice and video filters section to learn more.

Individual user configuration for maximum/minimum bandwidth

In version 2.3.0 we introduced 4 new configuration parameters for OpenVidu Server that allow the limitation of the video bandwidth both sent and received to/from OpenVidu Server, affecting all video streams in a global manner. Now it is possible to specifically configure certain input and output bandwidth for every user connected to a session. This way you can customize the bandwidth for each Publisher and Subscriber object of each Connection object. Users with no specific configuration will use the global values.

You can set custom bandwidths by using REST API, openvidu-java-client or openvidu-node-client:

  • REST API: in POST /api/tokens append a property in the json body like this

      "kurentoOptions": {
        "videoMaxRecvBandwidth": 1000,
        "videoMinRecvBandwidth": 1000,
        "videoMaxSendBandwidth": 1000,
        "videoMinSendBandwidth": 1000
      }
    
  • openvidu-java-client: build your tokens like this

      KurentoOptions kurentoOptions = new KurentoOptions.Builder()
        .videoMaxRecvBandwidth(1000)
        .videoMinRecvBandwidth(1000)
        .videoMaxSendBandwidth(1000)
        .videoMinSendBandwidth(1000)
        .build();
      TokenOptions tokenOptions = new TokenOptions.Builder()
        .data("User data")
        .role(OpenViduRole.PUBLISHER)
        .kurentoOptions(kurentoOptions)
        .build();
      String myToken = mySession.generateToken(tokenOptions);
    
  • openvidu-node-client: build your tokens like this

      var tokenOptions = {
          data: "User data",
          role: OpenViduRole.PUBLISHER,
          kurentoOptions: {
            videoMaxRecvBandwidth: 1000,
            videoMinRecvBandwidth: 1000,
            videoMaxSendBandwidth: 1000,
            videoMinSendBandwidth: 1000
          }
      };
      mySession.generateToken(tokenOptions).then(token => { ... } );
    

REST API and Server SDKs improvements

  • Connection objects have a brand new property very useful for session analysis: platform. It carries a complete description of the platform used by the client to connect to your session. For example: "Chrome 69.0.3497.81 on OS X 10.13.6 64-bit" or "Firefox Mobile 62.0 on Mobile (Android 8.1.0)"

    You can get this information by retrieving session information with the REST api (GET /api/sessions or GET /api/sessions/SESSION_ID) or inspecting openvidu-java-client and openvidu-node-client Session objects: calling Session.fetch() or OpenVidu.fetch() will update the status of their activeConnections property. Then you can check it out in openvidu-node-client (property Session.activeConnections) or openvidu-java-client (method Session.getActiveConnections())

  • Session, Connection and Publisher objects now have createdAt property, indicating when these objects where initialized in OpenVidu Server. This property has been integrated to maintain consistency with OpenVidu Server Call Detail Record, which has already been storing it in previous versions (check "timestamp" property of every CDR entry).

OpenVidu Browser improvements

  • New method OpenVidu.checkScreenSharingCapabilities(). It allows developers to know if the client platform supports screen sharing (see its declaration in OpenVidu Documentation)

New OpenVidu Angular and OpenVidu React libraries

We introduced OpenVidu Web Component in release 2.3.0. Now we offer native libraries for both Angular and React (latest versions) to insert the same powerful component in your applications by making use of each framework capabilities. You can check a tutorial for OpenVidu Angular (openvidu-library-angular) and for OpenVidu React (openvidu-library-react) right now.

Of course you can keep using OpenVidu Browser library instead of these components in any frontend framework. These tutorials show a basic use of OpenVidu Browser in an Angular app (openvidu-insecure-angular) and in a React app (openvidu-insecure-react).

BUG FIXES

  • Local tracks now are not stopped on stream disposal if property PublisherProperties.videoSource was of type MediaStreamTrack (custom stream got with OpenVidu.getUserMedia()). Issue #107, PR #108
  • Deprecated RTCPeerConnection.getRemoteStreams and RTCPeerConnection.getLocalStreams to RTCPeerConnection.getReceivers and RTCPeerConnection.getSenders. Issue #54
  • Allow full screen sharing in Firefox. Issue #103, PR #105
  • Fixed duplicated camera permissions in Firefox if PublisherProperties.videoSource/audioSource are provided as MediaStreamTracks. PR #109
  • openvidu-node-client now rejects with Error object upon OpenVidu Server unreachable. Issue #116, PR #117

@jenkinsopenvidu jenkinsopenvidu released this Jul 23, 2018 · 229 commits to master since this release

Assets 6

Release v2.4.0

NEW FEATURES

OpenVidu Java Client and OpenVidu Node Client REST API support for v2.3.0

Backend clients are now compatible with REST API 2.3.0, adding methods:

  • Session.close(): close a Session from your backend
  • Session.forceDisconnect(): force some user to leave a Session
  • Session.forceUnpublish(): force some user to unpublish a Publisher from a Session
  • Session.fetch(): bring Session information from OpenVidu Server
  • OpenVidu.fetch(): bring information from every active Session from OpenVidu Server

You can call methods Session.fetch() and OpenVidu.fetch() to bring the current status of sessions from OpenVidu Server. You can consult now directly from OpenVidu Java Client / OpenVidu Node Client all the active sessions with OpenVidu.getActiveSessions() / OpenVidu.activeSessions and the active connections of a session with Session.getActiveConnections() / Session.activeConnections.

OpenVidu CDR extended

Event recordingStopped event now has reason property. Can be:

  • "recordingStoppedByServer": the recording was stopped by the application (using REST API, OpenVidu Java Client or OpenVidu Node Client)
  • "lastParticipantLeft": if the Session was configured for automatic recording (RecordingMode.ALWAYS, check OpenVidu Node Client docs for more info), then it stopped because the last participant left the session
  • "sessionClosedByServer": the recording stopped because the session was forcibly closed by the application (using REST API, OpenVidu Java Client or OpenVidu Node Client)
  • "openviduServerStopped": the recording stopped because OpenVidu Server process unexpectedly stopped (cannot be guaranteed)

OpenVidu WebComponent improvements

  • Added a generic fullscreen button which will set as fullscreen element the entire component
  • Local video toolbar shown on fullscreen
  • User's nickname update process is now less intrusive (pop-up removed, simple text input instead)
  • Updated every dialog: now they appear inside of the component (center position), instead of appended to DOM body
  • The chat component is integrated in the layout for a better experience
  • New close chat button (top right corner)
  • New send button (bottom right corner)
  • New avatar user in each message. A new snapshot image will be displayed with each new message

BUG FIXES

  • OpenVidu Server dashboard test could sometimes fail because of a misuse of TURN server
  • OpenVidu Java Client: pending requests bug fixed
  • Remote Stream status properties are now properly updated when calling Session.publish, Session.unpublish and Session.publish for the same Publisher object (having unpublished audio or video in between the calls)

@jenkinsopenvidu jenkinsopenvidu released this Jul 11, 2018 · 255 commits to master since this release

Assets 6

Release v2.3.0

OPENVIDU WEB COMPONENT

OpenVidu platform now offers an easier way to get started: just include our new Web Component into your web and start enjoying video call capabilities with just 3 new lines of code:

Add to your index.html OpenVidu Web Component files:

<link rel="stylesheet" href="openvidu-webcomponent.css" />
<script src="openvidu-webcomponent.js"></script>

And add your video-call element wherever you want in your application:

<openvidu-webcomponent session-config='{"user":"NICKNAME", "token":"TOKEN"}' theme="dark"></openvidu-webcomponent>

Being NICKNAME the user's name during the call and TOKEN one token generated in OpenVidu Server. Of course, if you want to connect users to the same session, the tokens should be generated for the same session.
Attribute theme can be dark or light. Use the one that better fits your application.

OpenVidu Web Component supports a reasonable amount of different dimensions, and every video displayed inside of it will be automatically relocated and resized for its optimal position upon window resizing. You can set the position, width and height of the component by styling it like this:

  1. Setting its property position to absolute or fixed, depending on your web layout and the desired behavior you want the component to have.
  2. Playing with values:
    • width
    • height
    • top or bottom
    • right or left

For example, the following CSS rule would position the upper OpenVidu Web Component in the bottom-right corner of your web, taking up half of the height of the page and a third of its width.

openvidu-webcomponent {
  position: absolute;
  bottom: 0;
  right: 0;
  width: 33vw;
  height: 50vh;
}

If you give enough width to the component (at least 700px), users can communicate through an integrated chat.

To see some images of OpenVidu Web Component in action, check this post on Medium. If you want to learn more about OpenVidu Web Component, visit Tutorials section


NEW FEATURES

StreamPropertyChangedEvent (See here)

OpenVidu Browser now lets users connected to a Session know when any Stream they are subscribed to undergoes any possible change in its properties. Every Session object will dispatch this new event (you can subscribe to it to every Publisher or Subscriber object too). This event can refer to the following Stream properties:

  • Stream.audioActive: this property may change if the user publishing the Stream calls Publisher.pusblishAudio(bool).
  • Stream.videoActive: this property may change if the user publishing the Stream calls Publisher.publishVideo(bool).
  • Stream.videoDimensions: this property may change if...
    • ...the user publishing the stream is screen-sharing and the shared window changes its dimensions.
    • ...the user is publishing from a mobile device and it is rotated (every camera from a phone will invert the resolution in the output video when rotated).

So, for example, now you can do:

var OV = new OpenVidu();
var session = OV.initSession();
session.on('streamPropertyChanged', event => {
    if (event.changedProperty === 'audioActive') {
        console.log('The state of the audio of the publisher has changed. Is enabled? -> ' + event.newValue);
    } else if (event.changedProperty === 'videoActive') {
        console.log('The state of the video of the publisher has changed. Is enabled? -> ' + event.newValue);
    } else if (event.changedProperty === 'videoDimensions') {
        console.log('The video dimensions of the publisher has changed. New dimensions: ' + event.newValue);
    }
});

This way you can react more easily upon this variations in the published streams and update your application's layout accordingly.

Session.capabilities (See here)

You can check capabilities property of Session object to know which methods are able to invoke each one of your clients, depending on their role. Also, if a client tries to call a method for which he has no permissions, now an OpenViduError is thrown with property name being OPENVIDU_PERMISSION_DENIED.

New MODERATOR role

At last developers have available the new role that has been in our roadmap for a long time. Users connecting to a session with a token configured with MODERATOR role can call every method granted for SUBSCRIBER and PUBLISHER roles, but also:

  • Session.forceDisconnect: you can evict any user from the Session (force the method Session.disconnect)
  • Session.forceUnpublish: you can stop the Publisher of any user publishing in the Session (force the method Session.unpublish)

REST API extended

5 new methods join the REST API of OpenVidu Server:

Future iterations will add this capabilities to openvidu-java-client and openvidu-node-client libraries

Configure global bandwidth for your WebRTC connections

We have included a first way to set the maximum and minimum bandwidths for the media connections established between browsers and OpenVidu Server. You can configure it with the following system properties, as stated in OpenVidu Server configuration sections:

  • openvidu.streams.video.max-recv-bandwidth: Maximum video bandwidth sent from clients to OpenVidu Server, in kbps. 0 means unconstrained (default 600)
  • openvidu.streams.video.min-recv-bandwidth: Minimum video bandwidth sent from clients to OpenVidu Server, in kbps. 0 means unconstrained (default 300)
  • openvidu.streams.video.max-send-bandwidth: Maximum video bandwidth sent from OpenVidu Server to clients, in kbps. 0 means unconstrained (default 600)
  • openvidu.streams.video.min-send-bandwidth: Minimum video bandwidth sent from OpenVidu Server to clients, in kbps. 0 means unconstrained (default 300)

Future iterations will study the possibility of configuring this same parameters for each session individually or even for each incoming or outgoing WebRTC connection (maybe as part of PublisherProperties or SubscriberProperties)

@jenkinsopenvidu jenkinsopenvidu released this Jun 27, 2018 · 313 commits to master since this release

Assets 5

Release v2.2.0

OpenVidu now offers integrated and automated support for TURN server. We encourage developers to check out our post on Medium to learn more about it.

The platform now integrates by default a COTURN server as part of its ecosystem. This means that media connections will work OK even when clients are located on restricted networks. When deploying OpenVidu Server in Amazon Web Services with our Cloud Formation template no changes are required at all. If you are deploying OpenVidu Server on your own in an Ubuntu machine, installation instructions have changed a little bit. You have them properly updated here.

@jenkinsopenvidu jenkinsopenvidu released this Jun 1, 2018 · 364 commits to master since this release

Assets 5

Release v2.1.0

NEW FEATURES

OpenVidu Browser support for video management

We have implemented a new class in OpenVidu Browser aimed to better support declarative frontend framewroks such as Angular, React or Vue.js.

Now Publisher and Subscriber objects both inherit from StreamManager, which provides 2 different methods to tell OpenVidu what DOM video players should display each specific stream (addVideoElement and createVideoElement). This allows us to let OpenVidu take control of the video elements (even if our framework dinamically creates them) and do not worry about its internals. This is all explained in detail in Manage video players section.

If you want to check out a real example of this behaviuor, explore our renovated OpenVidu Angular tutorial.

@jenkinsopenvidu jenkinsopenvidu released this May 11, 2018 · 426 commits to master since this release

Assets 5

Release v2.0.0

This is the first breaking change update for OpenVidu, which brings in lots of new features and internal improvements.

BREAKING CHANGES LIST

  • OpenVidu Browser

    • OpenVidu.initSession now doesn't receive any input parameter.
    • OpenVidu.initPublisher input parameters have changed. Now properties parameter must match PublisherProperties interface.
    • Session.connect method has been promisified. Change the last mandatory callback parameter for a Promise implementation: session.connect(token, (error) => { ... }) to session.connect(token).then(() => {...}).catch(error => {...});

  • OpenVidu Java Client

    • All Archive entities are now called Recording. This includes: class Archive to Recording, class ArchiveMode to RecordingMode, class ArchiveLayout to RecordingLayout, method SessionProperties.archiveLayout() to SessionProperties.recordingLayout(), method SessionProperties.archiveMode() to SessionProperties.recordingMode(), method SessionProperties.Builder.archiveLayout() to SessionProperties.Builder.recordingLayout(), method SessionProperties.Builder.archiveMode() to SessionProperties.Builder.recordingMode()
    • RecordingLayout property in SessionProperties.Builder is now configured calling method defaultRecordingLayout() instead of recordingLayout(). This means that if one Session is gonna be recorded more than once, each recording layout may be customize with RecordingProperties.Builder.recordingLayout(), which will overwrite the default one globally configured in SessionProperties object.

  • OpenVidu Node Client

    • We have removed the builder pattern in all openvidu-node-client classes. Now objects are used instead, which includes classes TokenOptions, SessionProperties and RecordingProperties. For example, instead of getting a TokenOptions object like this: var tokenOptions = new TokenOptions.Builder().data(serverData).role(role).build() now it must be like this: var tokenOptions = {data: serverData, role: role}
    • There has been a simple change in certain asynchronous call. Method Session.getSessionId() is now synchronous, but method OpenVidu.createSession() is now asynchronous (the reason is pretty simple: now method createSession implements the behaviour that getSessionId was providing the first time it was called for certain Session object).
    • All callback methods have been promisified. This includes method Session.generateToken(tokenOptions?, callback): void (now Session.generateToken(tokenOptions?): Promise<string>) and method Session.getSessionId(callback): void (now OpenVidu.createSession(): Promise<Session>, take also into account that the async call has changed from one method to the other as stated in the previous point).
    • All Archive entities are now called Recording. This includes: object Archive to Recording, object ArchiveMode to RecordingMode, object ArchiveLayout to RecordingLayout, method SessionProperties.archiveLayout() to SessionProperties.recordingLayout(), method SessionProperties.archiveMode() to SessionProperties.recordingMode(), method SessionProperties.Builder.archiveLayout() to SessionProperties.Builder.recordingLayout(), method SessionProperties.Builder.archiveMode() to SessionProperties.Builder.recordingMode()
    • recordingLayout property in SessionProperties has changed to defaultRecordingLayout. This means that if one Session is gonna be recorded more than once, each recording layout may be customize with recordingLayout property (of RecordingProperties interface, which will overwrite the default one globally configured in SessionProperties object.

  • REST API

    • All Archive entities are now called Recording in API REST. For example: {"archiveMode": "ARCHIVE_MODE", "archiveLayout": "ARCHIVE_LAYOUT", "mediaMode": "MEDIA_MODE"} now is {"recordingMode": "RECORDING_MODE", "recordingLayout": "RECORDING_LAYOUT", "mediaMode": "MEDIA_MODE"}.
    • Field recordingLayout is now called defaultRecordingLayout in operation POST /api/sessions. This means that if one Session is gonna be recorded more than once, each recording layout may be customize adding a new field recordingLayout in the call to POST /api/recordings/start of the API REST, which will overwrite the default one globally configured during POST /api/sessions

  • Other breaking changes

    • OpenVidu Server default port from 8443 to 4443
    • OpenVidu Server configuration property openvidu.recording.free-access is now openvidu.recording.public-access

NEW FEATURES

  • OpenVidu Browser new methods

    • Session.publish(): now returns a Promise so you can tell if the method was successful or not.

    • Session.signal(): now returns a Promise so you can tell if the method was successful or not.

    • Subcriber.subscribeToAudio() and Subscriber.subscribeToVideo(): new methods that allows you to mute the audio or video tracks of a remote stream.

    • OpenVidu.initPubliher(): now expects properties as interface PublisherProperties. They include:

        {
            audioSource: undefined, // The source of audio. If undefined default audio input
            videoSource: undefined, // The source of video. If undefined default video input
            publishAudio: true,          // Whether you want to start publishing with your audio unmuted or muted
            publishVideo: true,         // Whether you want to start publishing with your video enabled or not
            resolution: '640x480',     // The resolution of your video
            frameRate: 30,               // The frame rate of your video
            insertMode: 'APPEND',  // How the video will be inserted in the target element
            mirror: false       	       // Whether to mirror your local video or not
        }
      
    • Session.subscribe(): now expects properties as interface SubscriberProperties. They include:

        {
            insertMode: 'APPEND',  // How the video will be inserted in the target element
            subscribeToAudio: true, // Whether to initially subscribe to the stream's audio track or not
            subscribeToVideo: true  // Whether to initially subscribe to the stream's video track or not
        }
      
    • OpenVidu.getDevices(): now you can use certain video or audio input device when calling OpenVidu.initPublisher(), thanks to properties audioSource or videoSource of PublisherProperties object. Just set these variables to the property deviceId of any of the devices returned by this method.

    • OpenVidu.getUserMedia(): method improved. Now devs can customize a MediaStream object before calling OpenVidu.initPublisher() method, setting property audioSource or videoSource to a MediaStreamTrack object (see docs for further information)

  • OpenVidu Browser new properties

    • Stream.frameRate: new property defining the frame rate of video streams. This property will only have value if the Publisher owning the stream has set property frameRate of PublisherProperties when calling OpenVidu.initPublisher()

  • OpenVidu Browser events

    • New events accessDialogOpened and accessDialogClosed: dispatched by Publisher objects when the browser asks the user to grant permissions to camera or michrophone by opening a pop-up. You can use them to warn your users about it.
    • New events recordingStarted and recordingStopped: dispatched by Session object when the recording of a Session starts and stops. You can customize which clients will receive this event thanks to new property openvidu.recording.notification (see OpenVidu Server configuration)
    • Events publisherStartSpeaking and publisherStopSpeaking improved: more customizable thanks to OpenVidu.setAdvancedConfiguration() and better overall performance.
    • Events streamDestroyed, connectionDestroyed and sessionDisconnected have new property reason. This gives more information about why the events have been dispatched so you can take specific actions depending on the context: maybe a stream has been destroyed because the user publishing has deliberately diposed it or maybe the network connection has unexpectedly closed (see docs for StreamEvent, ConnectionEvent and SessionDisconnectedEvent)

  • Other improvements in OpenVidu Browser

  • OpenVidu Server new features

BUG FIXES

  • Now when any participant unexpectedly disconnects from a session (for example, due to a network failure), connectionDestroyed event is sent to the rest of participants with property reason set to networkDisconnect.
  • When OpenVidu Server is stopped, it will try to gracefully finish every in progress session and recording. This way no recording file will end corrupted upon OpenVidu Server termination (this cannot be granted if the process crashes or is forcibly terminated)
  • Now both STUN and TURN OpenVidu Server configuration parameters can be set up at the same time with no overwritings.
  • Tons of small fixes and code refactoring that makes OpenVidu more stable and easy to test and develop

@jenkinsopenvidu jenkinsopenvidu released this Apr 19, 2018 · 488 commits to master since this release

Assets 5

Release v1.9.0

CUSTOM LAYOUT RECORDING

Now you can create your own layouts for Session recording process. They are implemented with HTML/CSS/JS files, just as your OpenVidu application client-side.


  1. Create your layout with HTML/CSS/JS files and put them in a path accessible to openvidu-server. There must be an index.html file as entrypoint for your custom layout:

    • WHAT SHOULD YOUR JS CODE DO: by making use of openvidu-browser-1.9.0.js library, you need to connect a recorder participant to the session. This means:

      1. Your layout must create the Session object like this:
      var session = OV.initSession('wss://' + location.hostname + ':8443/' + SESSION_ID + '?secret=' + SECRET + '&recorder=true');

      Being SESSION_ID and SECRET two parameters that will be url-encoded under ids sessionId and secret respectively. So, for example:

      var url = new URL(window.location.href);
      var SESSION_ID = url.searchParams.get("sessionId");
      var SECRET = url.searchParams.get("secret");
      var session = OV.initSession('wss://' + location.hostname + ':8443/' + SESSION_ID + '?secret=' + SECRET + '&recorder=true');
      1. You will need to subscribe to, at least, two events: streamCreated and streamDestroyed of Session object. That way you can update your video layout when any user starts or stops publishing. To sum up, this would be the simplest code you need to properly start your recorder participant:
      var OV = new OpenVidu();
      
      var url = new URL(window.location.href);
      var SESSION_ID = url.searchParams.get("sessionId");
      var SECRET = url.searchParams.get("secret");
      var session = OV.initSession('wss://' + location.hostname + ':8443/' + SESSION_ID + '?secret=' + SECRET + '&recorder=true');
      
      session.on("streamCreated", (event) => {
        session.subscribe(event.stream, 'html-id-where-insert-video');
      });
      session.on("streamDestroyed", (event) => {
        // The video is automatically removed by default but you can do whatever
        // you want here to update your layout when any user stops publishing
      });
      
      session.connect(null, (error) => {
        if (error) {
          console.error(error);
        }
      });
    • HOW TO IDENTIFY YOUR USERS: you can identify them by making use of property Stream.connection.data of the Stream object retrieved in Session event "streamCreated". That way you may know which particular user should be displayed in which particular HTML element of your layout. For example:

      session.on("streamCreated", (event) => {
        var stream = event.stream;
        if (stream.connection.data === 'userBigVideo') {
          session.subscribe(stream, 'big-video-div');
        } else if (stream.connection.data === 'userSmallVideo') {
          session.subscribe(stream, 'small-video-div');
        }
      });

  1. Add new properties when launching openvidu-server (openvidu.recording.custom-layout and a new -v option if using Docker images):

    • openvidu-server-1.9.0.jar:
      java -jar \
        -Dopenvidu.recording=true \
        -Dopenvidu.recording.path=/PATH/TO/VIDEO/FILES \
        -Dopenvidu.recording.custom-layout: /PATH/TO/INDEX/CUSTOM/LAYOUT \
      openvidu-server-1.9.0.jar
      
    • openvidu-server-kms:1.9.0:
      docker run -p 8443:8443 --rm \
        -v /var/run/docker.sock:/var/run/docker.sock \
        -v /PATH/TO/VIDEO/FILES:/PATH/TO/VIDEO/FILES \
        -v /PATH/TO/INDEX/CUSTOM/LAYOUT:/PATH/TO/INDEX/CUSTOM/LAYOUT \
        -e MY_UID=$(id -u $USER) \
        -e openvidu.recording=true \
        -e openvidu.recording.path=/PATH/TO/VIDEO/FILES \
        -e openvidu.recording.custom-layout=/PATH/TO/INDEX/CUSTOM/LAYOUT \
      openvidu/openvidu-server-kms:1.9.0
      
    • openvidu-server:1.9.0 (KMS running as a native service in the same machine):
      docker run --net="host" -p 8443:8443 --rm \
        -v /var/run/docker.sock:/var/run/docker.sock \
        -v /PATH/TO/VIDEO/FILES:/PATH/TO/VIDEO/FILES \
        -v /PATH/TO/INDEX/CUSTOM/LAYOUT:/PATH/TO/INDEX/CUSTOM/LAYOUT \
        -e MY_UID=$(id -u $USER) \
        -e openvidu.recording=true \
        -e openvidu.recording.path=/PATH/TO/VIDEO/FILES \
        -e openvidu.recording.custom-layout=/PATH/TO/INDEX/CUSTOM/LAYOUT \
      openvidu/openvidu-server:1.9.0
      

  1. Configure your sessions to use your custom layout:

    Do exactly the same process explained here, but changing archiveLayout from BEST_FIT to CUSTOM.

    • If you are using the API REST, just change json body parameter "archiveLayout":"BEST_FIT" to "archiveLayout":"CUSTOM".
    • If you are using openvidu-java-client or openvidu-node-client, change SessionProperties.Builder().archiveLayout(ArchiveLayout.BEST_FIT) to SessionProperties.Builder().archiveLayout(ArchiveLayout.CUSTOM).

CONFIGURING MULIPLE CUSTOM LAYOUTS

You can implement as many custom recording layouts as you want. Simply store each one of them (each one with its own index.html entrypoint file) in a subfolder under path /PATH/TO/INDEX/CUSTOM/LAYOUT. Then, when configuring your sessions as stated above in point 3, just add a new parameter besides changing archiveLayout property:

  • If you are using the API REST, add an additional field to json body: "archiveLayout":"CUSTOM", "customLayout":"RELATIVE/PATH/TO/INDEX"
  • If you are using openvidu-java-client or openvidu-node-client, create SessionProperties object with a new step: new SessionProperties.Builder() .archiveLayout(ArchiveLayout.CUSTOM).customLayout("RELATIVE/PATH/TO/INDEX").build())

Path RELATIVE/PATH/TO/INDEX is the path from openvidu-server configuration property openvidu.recording.custom-layout to the specific index.html you want to use for a particular session recording. So, if you have the following folder tree structure:

/opt
+-- /openvidu
|   +-- /my_custom_layouts
|       +-- index.html
|       +-- /layout1
|           +-- index.html
|       +-- /layout2
|           +-- index.html
/etc
    ...

You should start openvidu-server with property openvidu.recording.custom-layout=/opt/openvidu/my_custom_layouts and you can use any of the 3 index.html files for recording any of your sessions. To use the outer layout, just configure archiveLayout to CUSTOM. To use any of the inner layouts, also configure customLayout to layout1 or layout2.


SAMPLE index.html

This is literally the simplest HTML for a custom recording layout. Use it as a template for building more complex ones.

<html>

<head><script src="openvidu-browser-1.9.0.min.js"></script></head>

<body>
    <div id="videos"></div>
</body>

<script>
    var url = new URL(window.location.href);
    var SESSION_ID = url.searchParams.get("sessionId");
    var SECRET = url.searchParams.get("secret");

    var OV = new OpenVidu();
    var session = OV.initSession('wss://localhost:8443/' + SESSION_ID + '?secret=' + SECRET + '&recorder=true');

    session.on("streamCreated", (event) => {
        session.subscribe(event.stream, 'videos');
    });
    session.on("streamDestroyed", (event) => {});
    session.connect(null, (error) => {
        if (error) {
            console.error(error);
        }
    });
</script>

</html>

@jenkinsopenvidu jenkinsopenvidu released this Mar 19, 2018 · 513 commits to master since this release

Assets 5

Release v1.9.0-beta-1

SAFARI SUPPORT

We are glad to announce the first version of OpenVidu compatible with Safari on the most recent versions of Mac and iOS. There's some work to do yet, and as this version may be unstable it will remain as a beta for now.