OpenVidu Platform main repository
APACHE-2.0 License
Bot releases are visible (Hide)
Published by jenkinsopenvidu over 5 years ago
Published by jenkinsopenvidu over 5 years ago
Published by jenkinsopenvidu almost 6 years ago
Published by jenkinsopenvidu almost 6 years ago
Published by jenkinsopenvidu about 6 years ago
Published by jenkinsopenvidu about 6 years ago
Backend clients are now compatible with REST API 2.3.0, adding methods:
Session.close()
: close a Session from your backendSession.forceDisconnect()
: force some user to leave a SessionSession.forceUnpublish()
: force some user to unpublish a Publisher from a SessionSession.fetch()
: bring Session information from OpenVidu ServerOpenVidu.fetch()
: bring information from every active Session from OpenVidu ServerYou 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
.
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)Session.publish
, Session.unpublish
and Session.publish
for the same Publisher object (having unpublished audio or video in between the calls)Published by jenkinsopenvidu over 6 years ago
Published by jenkinsopenvidu over 6 years ago
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.
Published by jenkinsopenvidu over 6 years ago
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.
Published by jenkinsopenvidu over 6 years ago
This is the first breaking change update for OpenVidu, which brings in lots of new features and internal improvements.
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
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
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}
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).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).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
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"}
.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
8443
to 4443
openvidu.recording.free-access
is now openvidu.recording.public-access
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
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.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)publisherStartSpeaking
and publisherStopSpeaking
improved: more customizable thanks to OpenVidu.setAdvancedConfiguration() and better overall performance.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
name
for recordings: you can now specify which name should OpenVidu Server give to each one of your recording files. You can do it by using the REST API (by setting body parameter "name" in POST /api/recordings/start), openvidu-java-client (by using RecordingProperties.Builder.name()) or openvidu-node-client (by setting property RecordingProperties.name)sessionId
. You can take advantage of this new property to facilitate the mapping between OpenVidu Server 'session' entities and your own 'session' entities. You can set it by using the REST API (by setting body parameter "customSessionId" in POST /api/sessions), openvidu-java-client (by using SessionProperties.Builder.customSessionId()) or openvidu-node-client (by setting property SessionProperties.customSessionId)recordingStarted
and recordingStopped
, property reason
for events sessionDestroyed
, participantLeft
and webrtcConnectionDestroyed
.connectionDestroyed
event is sent to the rest of participants with property reason
set to networkDisconnect
.Published by jenkinsopenvidu over 6 years ago
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.
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:
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');
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');
}
});
Add new properties when launching openvidu-server (openvidu.recording.custom-layout
and a new -v
option if using Docker images):
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
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
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
Configure your sessions to use your custom layout:
Do exactly the same process explained here, but changing archiveLayout
from BEST_FIT
to CUSTOM
.
"archiveLayout":"BEST_FIT"
to "archiveLayout":"CUSTOM"
.SessionProperties.Builder().archiveLayout(ArchiveLayout.BEST_FIT)
to SessionProperties.Builder().archiveLayout(ArchiveLayout.CUSTOM)
.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:
"archiveLayout":"CUSTOM", "customLayout":"RELATIVE/PATH/TO/INDEX"
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
.
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>
Published by jenkinsopenvidu over 6 years ago
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.
Published by jenkinsopenvidu over 6 years ago
New event 'videoElementDestroyed' for Subscribers and Publishers: openvidu-browser triggers this event once the library has automatically removed the HTML video from DOM.
New errors defined: BROWSER_NOT_SUPPORTED
(on Session.connect()
method) and SCREEN_SHARING_NOT_SUPORTED
(on OpenVIdu.initPublisher()
method with 'screen' option)
LocalRecorder API: record any Stream directly from the browser:
var OV = new OpenVidu();
var publisher = OV.initPublisher(âelementIdâ, publisherOptions);
var localRecorder = OV.initLocalRecorder(publisher.stream);
localRecorder.record(); // Record video....
localRecorder.stop(); // End recording
localRecorder.preview('preview-div'); // Preview recording in element with id 'preview-div'
localRecorder.download(); // Save the video file
localRecorder.uploadAsBinary("https://my-http-endpoint.com"); // Upload to an http endpoint
docker run -p 8443:8443 openvidu/testapp
# Access the app through https://localhost:8443
openvidu.cdr
property is set to 'false'OpenVidu.initPublisher()
was called before OpenVidu.initSession()
: now it is possible to initialize a Publisher object without initializing or connecting to a Session. This can be useful for using OpenVidu Browser local recording feature without video-call capabilities or just to use the simple API for 'getUserMedia' that OpenVidu Browser implements.streamCreated
event (was sometimes being called twice for Subscriber objects when a Publisher and a Subscriber joined a Session at the exact same time).Release v1.7.0
Published by jenkinsopenvidu almost 7 years ago
Release v1.5.0
Call Detail Record
Dynamic change of Publisher without leaving the Session:
Session.unpublish(oldPubliser);
newPublisher = OpenVidu.initPublisher(newOptions);
Session.publish(newPublisher);
Published by jenkinsopenvidu almost 7 years ago
Release v1.4.0
Published by jenkinsopenvidu almost 7 years ago
Release v1.3.0
Published by jenkinsopenvidu almost 7 years ago
Release v1.2.0
Published by jenkinsopenvidu almost 7 years ago
Release v1.1.2
Published by jenkinsopenvidu about 7 years ago
Release v1.1.1