Vidyo FAQs

This article lists the subnets for the following environments:

Vidyo.io (prod.vidyo.io)

Vidyo.io EU(eu.prod.vidyo.io)

Vidyo.io Staging (vidyostaging.io)

In addition, ports are listed in this section:

Ports

With vidyo.io, the connection will beinitiated from the client/endpoint side. This means that in most networkenvironments, Vidyo.io applications will work without requiring the network team to modify the configuration. Keepin mind, however, that in someenvironments which are more restrictive outbound, the network team may need to make changes that allow vidyo.io to work.

The tables below shows a setup forstatefulconnections to Vidyo.io.

Vidyo.io (prod.vidyo.io)

Production Subnets (Current)

The following table lists the current vidyo.io production subnets.

35.190.112.0/27

35.234.160.0/26

35.235.0.0/28

35.192.192.0/25

35.234.176.0/25

35.235.32.0/26

35.203.232.0/27

35.234.192.0/26

35.235.48.0/27

35.227.0.0/26

35.234.208.0/28

35.243.0.64/26

35.227.128.0/24

35.234.224.0/27

35.243.8.0/26

35.230.240.0/26

35.234.240.0/26

Added (October 2018)

The following table lists the subnets that were added in October, 2018. They ARE INCLUDED in the Production Subnets (Current) table at the beginning of this article.

35.203.232.0/27

35.243.0.64/26

Added (November 2018)

The following table lists the subnets that were added in November, 2018. They ARE INCLUDED in the Production Subnets (Current) table at the beginning of this article.

35.243.8.0/26

Deprecated (September 2018)

The following table lists the subnets that were deprecated in September, 2018. They areNOT INCLUDED in the Production Subnets (Current) table at the beginning of this article.

173.231.176.206/32

206.191.153.80/32

206.191.153.81/32

Vidyo.io Staging Subnets (Current)

The following table lists the current vidyo.io staging subnets.

35.190.112.32/28

35.234.160.64/27

35.235.0.16/28

35.192.192.192/27

35.234.176.192/26

35.235.32.64/26

35.203.232.32/28

35.234.192.128/27

35.235.48.32/28

35.227.0.64/27

35.234.208.16/28

35.243.0.32/27

35.227.129.192/26

35.234.224.64/28

35.243.8.64/27

35.230.240.64/26

35.234.240.64/27

Vidyo.io EU(eu.prod.vidyo.io)

EU Production Subnets (Current)

The following table lists the current vidyo.io EU production subnets.

35.203.232.0/27

35.234.160.0/26

35.235.32.0/26

Added (October 2018)

The following table lists the subnet that was added in October, 2018. They ARE INCLUDED in the EU Production Subnets (Current) table above.

35.203.232.0/27

Deprecated (September 2018)

The following table lists the subnets that were deprecated in September, 2018. They areNOT INCLUDED in the EU Production Subnets (Current) table above.

35.157.45.253/32

52.59.162.158/32

For All VidyoCloud Environments:

We host clients on AWS CDN which does not guarantee static IPs. AWS subnets can be found here: https://docs.aws.amazon.com/general/latest/gr/aws-ip-ranges.html.

Ports

The following table lists the ports, IPs, and ranges.

443

TCP/UDP

HTTPS/TURN

50,000-53,000

UDP

Media

60,000-61,000

UDP

Media (WebRTC only)

Media ports are negotiated between the endpoint and the vidyo.io servers.

Some firewalls may misclassifythe media traffic and apply a UDP default timeout. In these cases, calls will always drop at exactly the same time. To avoid call timeouts, change thedefault (0:02:00 2 minutes) to a time that is longer than the longest potential call.

Consumed minutes are based on a per-participant minute. Each participant in a call consumes minutes while connected in a call. For example, if you have a call with 4 participants connected for 5 minutes, you would consume 20 minutes. Any partial minutes used are rounded up to the nearest whole minute.

Token is the user metadata which is signed with the DeveloperKey and base64 encoded. The metadata must contain the username, expiration date (and an optional vCard).

Python sample generator: https://static.vidyo.io/4.1.7.2/utils/generateToken.py

python3 generateToken.py --key=rUlaMASgt1Byi4Kp3sKYDeQzo --appID=ApplicationID --userName=user1 --vCardFile=vcard-example.xml --expiresInSecs=10000

Java sample generator: https://static.vidyo.io/4.1.7.2/utils/generateToken.jar

java -jar generateToken.jar --key=rUlaMASgt1Byi4Kp3sKYDeQzo --appID=ApplicationID --userName=user1 --vCardFile=vcard-example.xml --expiresInSecs=10000

find sample here : https://github.com/Vidyo/generateToken-java

Node.js sample generator: https://static.vidyo.io/4.1.7.2/utils/generateToken.js

node generateToken.js --key=rUlaMASgt1Byi4Kp3sKYDeQzo --appID=ApplicationID --userName=user1 --vCardFile=vcard-example.xml --expiresInSecs=10000

C# sample generator: https://github.com/Vidyo/generateToken-c-sharp

GenerateToken.exe --key=rUlaMASgt1Byi4Kp3sKYDeQzo --appID=ApplicationID --userName=user1 --

In this video we explain how to authenticate your app with the vidyo.io service using token based authentication.

(Unauthorized access is a violation of law in certain jurisdictions).

Conference in vidyo.io

InVidyo.iothere are no predefined users or conferences. For every endpoint wishing to connect, youmust generate an access token. Togenerate an access token, add code for a preferred username and expiration time(see Tokens onthe Developers Documentation page). After you generate a token on yourback-end server, pass italong with the resourceId to the endpoint application. All of the endpoints connecting to the same resourceId become participants in a live conference; the resourceId string does not have to be provisioned ahead of time.

Token

A token is a short-lived authentication credential which grants access to the Vidyo.ioservice on your behalf. When an endpoint requests access to the service, the application back end generates a token and passes it on to the client application.

For each application, youmust create aDeveloperKeyandApplicationIDin the API Key section of theVidyo.iosite and securely store it in yourapplication's back end. Then, each time you wantto grant access to theVidyo.ioservice, yougenerate aTokenfrom theDeveloperKeyandApplicationIDas described below and pass it to yourendpoint application or the VidyoConnector application.

Developer Key

A DeveloperKey is a shared secret betweenVidyo.ioand yourback-end application. Use the DeveloperKeyto generate access tokens on the customer back end;do not send the DeveloperKeyto the endpoint itself. Access to the Developer Key mustbe restricted; every token it signs can be used for access and billing.

ApplicationID

ApplicationID identifies the developer to theVidyo.ioplatform. The developer can automatically provision any user, such as user1@ApplicationID, when generating the token.

With the release of iOS 12.x - and in particular 12.1, Apple made some changes to the AVAudioSession which effects how Vidyo handles audio routing. This change has caused a critical issue with older versions of the VidyoClient iOS SDK (pre 4.1.23) which manifests as a consistent application crash when connecting to Vidyo calls.

This issue was addressed in 4.1.23 and it is Vidyo's recommendation that any client seeing this issue immediately upgrade to the latest VidyoClient iOS SDK.

If a vidyo.io user using a binary client (either desktop or mobile) joins a video conference before one native WebRTC user on a Chrome browser joins the same conference, the WebRTC user's tile will appear black. This is due to a bug which has surfaced in version72.0.3626.109 of the Chrome browser.

Workaround

If this occurs, the WebRTC (browser) user should mute and then unmute their camera. Doing so will make the WebRTC user visible to all the participants in the conference.

Products Affected

Vidyo.io users using native WebRTC on Chrome version 72.0.3626.109

How to Avoid This Issue

The WebRTC clients join the conference first and then the binary clients join.

The binary clients join the conference first and then more than one WebRTC client joins.

Next Steps

Vidyo has slated this issue to be fixed in an upcoming release. If any other changes occur, Vidyo will provide details in this alert notification.

Update [Solved]

The issue has been fixed via updating the VidyoClient.js file in the 4.1.25.30 version, customers should be consuming it from:

https://static.vidyo.io/4.1.25.30/javascript/VidyoClient/WebRTC/VidyoClient.js

or

https://static.vidyo.io/latest/javascript/VidyoClient/WebRTC/VidyoClient.js

The Vidyo.io iOS SDK currently does not contain Swift language bindings, but that would not prevent a developer from integrating Vidyo.io into a Swift application. This can easily be done using an Objective-C bridging header. The steps to do so are outlined below:

Create an empty project named VidyoConnectorSwift.

Download the latest Vidyo.io iOS SDK package: https://static.vidyo.io/latest/package/VidyoClient-iOSSDK.zip

Extract the package and place VidyoClientIOS.framework in the VidyoConnectorSwift directory (parallel to VidyoConnectorSwift.xcodeproj). (The framework should be placed inside the working project directory to be easily linked.)

In the “General -> Linked Frameworks and libraries” settings, add VidyoClientIOS.framework as well as the following required iOS frameworks:

SystemConfiguration.framework

UIKit.framework

CoreMedia.framework

CoreLocation.framework

AudioToolbox.framework

AVFoundation.framework

Create a new header file called VidyoConnectorSwift-Bridge-Header.h in the VidyoConnectorSwift directory, which will be the Objective-C bridging header. In “Build Settings -> Swift Compiler - General -> Objective-C Bridging Header”. (If you don’t see “Swift Compiler - General” - switch to “Show all build settings” as the filter.)

Populate this field with the file name, including path: VidyoConnectorSwift/VidyoConnectorSwift-Bridge-Header.h

Open the header file and populate it as follows:

#import "Foundation/Foundation.h"

#import "VidyoClientIOS.framework/Headers/Lmi/VidyoClient/VidyoConnector_Objc.h"

VidyoClientIOS.framework is located in your working directory so make sure that the path is correct and relative.

Initialize the Vidyo Client library in the view controller and build the project to ensure that your framework is linked:

override func viewDidLoad() {

super.viewDidLoad()

VCConnectorPkg.vcInitialize()

}

The project should build without errors.

Add privacy permissions for the camera and microphone in the Info.plist file.

Privacy - Microphone Usage Description

Privacy - Camera Usage Description

Enable Keychain Sharing, which is required for framework keychain access: Capabilities -> Keychain sharing -> ON

Add one more KeyChain Group: “+”

Clear the field and enter “VidyoLicense”

Now that the Vidyo.io framework has been integrated, you are ready to build a video chat application using Swift! For reference, take a look at the Swift sample in GitHub: https://github.com/Vidyo/customview-swift-ios

This video demonstrates, step-by-step, how to build a mobile video chat application for Androidin undernine minutes.

Vidyo.io sessions always connect to an SFU.

Both users navigated to the demo section on the vidyo website.

Launched the sample app using the launch button

Both had the status displayed as connected but were not able to see each other.

What to try:

It is possible that you are using tokens generated from different API keys. All of the parties will be in the same room (Resource Id) if the tokens are generated from the same API key. Is each party that is connecting using the demo from their own login to Vidyo.io (and hence their own API key)? From the demo page, generate x amount of links (one for each participant), share a unique link (with a unique token) with each participant, and connect to the same Resource Id.

Overview

This document intends for vidyo.io beginner. You can have the knowledge for building simple video chat application. If you have developed your application on other company solution and VidyoWorks API, you will experience how you can more easily develop video chat application than other company solution and VidyoWorks API.

Required software

Xcode

VideyoClientIOS framework

Download the IOS PACKAGE from https://developer.vidyo.io/packages

Copy the VidyoClientIOS.framework in IOS PACKAGE to your project folder.

Create the new project

Xcode project

Open the Xcode and click “Create a new Xcode project” menu.

We click “Single View Application” item.

This project name defines “VidyoIODemo”. We should set the appropriate value on the Team, Organization name, Organization Identify. We develop this application with Objective-C as language.

Create a New Folder for this project and name New Folder “VidyoIODemo”.

Set Deployment Target to iOS 8 for backwards compatibility. And we add vidyo.io framework in vidyoIODemo project. Click “+” icon on Embedded Binaries item.

Click “Add Other..” button.

Select “VidyoClientIOS.framework” file and click Open button.

Select “Create folder references” and click “Finish” button.

Note You have to download IOS PACKAGE from https://vidyo.io and copy “VidyoClientIOS.framework “ file in this package to vidyoIODemo project folder.

IOS PACKAGE folder vidyoIODemo project folder

Set Build Settings

Update some items on Build Settings.

Set the entitlement file for Code signing. It's going to be parallel to this project folder and file name is VidyoIODemo.entitlements. ( Input “$(PROJECT_DIR)/../ VidyoIODemo.entitlements”)

Note We have to set ”Keychain Access Groups” in VidyoIODemo.entitlements. One is “VidyoLicense”. Another is App ID.

Update some search paths. Framework Search Paths is “$(PROJECT_DIR)/../”. We set Header Search Paths to the header path. Headers are located within the framework. This path is “$(PROJECT_DIR)/../VidyoClientIOS.framework/Headers”.

info.plist

Update the info.plist file. Add two privacy settings. For camera call, we add “Privacy - Camera Usage Description” and set “video chat” as value. For microphone call, we add “Privacy - Microphone Usage Description” and set “video chat” as value.

UI Building

UI for video render

Start building UI that will render video in a simple UI View.

We click Main.storyboard and input “uiview” in filter. View object is displayed. And we layout it on UI.

Button UI

We layout two buttons. We Input “button” in filter. Xcode will display Button object. And we put it underneath the UI and input “Connect”. One more, we put another button object on right side of UI and input “Disconnect”. Next we click the green cycle.

Set “Reset to Suggested Constraints” in pull down menu for locking in those UI elements.

Implement source code

Define interfaces

Open the header file (ViewController.h) for linking those UI elements to code.

Set view for video render

We connect View object which video will be rendered to header file and name “videoView”.

Set Button

Next, we connect Button object to header file. And we select “Action” in Connection item and name “Connect”.

We connect another Button object to header file. And we select “Action” in Connection item and name “Disconnect”.

Our application needs to call VidyoConnector under Objective-C. So we open ViewController.h.

Next, we import “Lmi/VidyoClient/VidyoConnector_Objc.h”. And we add “<IConnect>” for inheriting an interface called “IConnect”

ViewController.hExpand source

Implement the video chat code

ViewDidLoad Function

Open “ViewController.m” and we add a member of “*c” which is variable type Connector pointer. And we initialize Vidyo Client Library in viewDidLoad function. we Input “[VidyoClientConnector Initialize];”.

Next, we call “c = [Connector alloc]” for constructing the Connector object. This first argument will be a reference to the video view object. We set ViewStyle argument to ” CONNECTORVIEWSTYLE_Default” and set RemoteParticipants argument to 16 as max remote participants. We set LogFileFilter and LogFileName arguments to blank for demo application. UserData argument is not retrieved. So this will be 0.

ViewController.mExpand source

viewDIdAppear function

Implement “viewDidAppear method. At first, we call base class which is “[super viewDidAppear:animated];”.

We call ShowViewAt method in Connector object. We set the reference to the videoView Object in the first argument and set X and Y argument to 0 offset. We set Width argument to “videoView.frame.size.width” and Height argument to “videoView.frame.size.height”.

ViewController.mExpand source

Connect function

Implement “Connect” Button function. This method is called by pushing “Connect” button. We call Connect method of Connector object in this method. At the first argument is set “ prod.vidyo.io as host. We set the next argument to the Token that is generated previously. In the real applications case, back-end server will generate a Token.

(Token: https://developer.vidyo.io/documentation/4-1-14-10/getting-started#Tokens )

We set DisplayName argument to “DemoUser” and ResourceId argument to “DemoRoom”. This application connects to “DemoRoom” when the Connect method is executed. The Connect argument is expecting an IConnect object. We have already inherited @interface from IConnect object. So we can just set this argument to “self”

ViewController.mExpand source

Disconnect method will call disconnect method of Connector object.

IConnect interface

Implement three method of IConnect interface. The first is OnSuccess method that is called when the connection is successful. The second is OnDisconnect method that is called when the connection is disconnected for any reason. The last is OnFailure method that is called when the connection has failed.

We need to implement nothing code inside of these methods for this demo. But in the real application, we need to implement something code for response to those three methods.

ViewController.mExpand source

Build and Execute the video chat application

Set the target to “Generic iOS Device” and then we start the build process (product->Build menu). We confirm that the build process has succeeded. And we load it on to an iOS device. This application will be started on iOS device. Push “Connect” button and confirm start a video session. And push “Disconnect” button and end a video session.

Reference

Video Clip - Vidyo.io | Build an iOS Video Chat App in Minutes

https://www.youtube.com/watch?v=0YqTC4FLWcc

Sample Code

This sample code is used in this document. But you have to do two items previously.

Copy the VidyoClientIOS.framework into this sample code folder.

Set a value to token in ViewController.m

https://github.com/Vidyo/helloworld-vidyo.io-ios

When building a web-based video app using the VidyoClient.js library, you should link to the latest version instead of linking to an explicit version. By linking to latest, your app will automatically pull down the newest version of the VidyoClient.js file. This ensures your application will includethe latest bug fixes (e.g., for browser compatibility, etc.) and all the newest features without needing to make changes to your code.

You can quickly and easily make these modifications as outlined in the following example:

Previous Code:

https://static.vidyo.io/4.1.25.23/javascript/VidyoClient/VidyoClient.js

Modified Code For Instant Upgrades and Releases:

https://static.vidyo.io/latest/javascript/VidyoClient/VidyoClient.js

The Resource ID (i.e. room name) identifier used in the VidyoConnectorConnect API, is a UTF-8 string that can be a max length of 900 bytes.

In the 4.1.25 VidyoClient release, High DPI support was introduced. This may cause a change in the scaling of the rendered video in your .NET application, as the dimensions of the video panel is measured in points rather than pixels. Therefore, you should use the new VidyoConnectorShowViewAtPoints API, rather than VidyoConnectorShowViewAt. The differences are explained below:

VidyoConnectorShowViewAt uses pixels for its arguments. Consequentially, passing in the height / width of a WindowsFormPanel (who's height and width is in points) will cause the video view to appear as a different size than it should be.

VidyoConnectorShowViewAtPoints, on the other hand, accepts points for all of it's arguments. This means that in the case of a WPF application using a WindowsFormPanel, that passing in the height and width of the panel will result in the panel's view size appearing correctly.

To avoid exposing app IDs and developer keys, generate Vidyo.io tokenson the server side of the application and then pass them onto the client. Vidyo.io provides detailed information about generating tokens in Python, Java, JavaScript, and C# on the Developers Documentation page.

The following example generates a token in Python:

python3 generateToken.py --key=INSERT_YOUR_KEY --appID=INSERT_YOUR_APP_ID --userName=user1 --expiresInSecs=10000

A few things to keep in mind:

The userName in the generator mustbe unique for each participant in the video call.

The userName field cannotcontain any spaces or special characters.

The token mustbe unique for each participant in the call; this is always thecase for unique UserNames.

What happens if the token expires in the middle of a video chat?

Tokens are used to gain entry into a resource (room) so as long as the token is not expired (and otherwise valid), the participant can connect. Therefore, once a participant is connected, then the token may expire without any consequences. The participant will remain connected.

In order for the Vidyo io library to work correctly in Windows Applications it is required that the application have High DPI awareness per-monitor enabled. See https://support.vidyo.io/hc/en-us/articles/360018101793-Windows-applications-Screen-Sharing-Manifest-file-settings for details on how to enable per-monitor High DPI Awareness.

Windows applications in both C++ and C# require certain items added to their app manifests to allow them to properly share their screens.

In a C++ application inside the VCXProj file you will need to add an application manifest xml file. In a C# application you will need to add a app.manifest file. In both cases ensure the following xml is added to it:

to enable High DPI awareness per monitor - which is required for screen sharing on Windows:

<application xmlns="urn:schemas-microsoft-com:asm.v3">

<windowsSettings>

<dpiAware xmlns="http://schemas.microsoft.com/SMI/2005/WindowsSettings">

True/PM

</dpiAware>

</windowsSettings>

</application>

and to ensure that the compatibility mode is set:

<compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1">

<application>

<!-- Windows 10 -->

<supportedOS Id="{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}"/>

<!-- Windows 8.1 -->

<supportedOS Id="{1f676c76-80e1-4239-95bb-83d0f6d0da78}"/>

<!-- Windows 7 -->

<supportedOS Id="{35138b9a-5d96-4fbd-8e2d-a2440225f93a}"/>

<!-- Windows 8 -->

<supportedOS Id="{4a2f28e3-53b9-4441-ba9c-d69d4a4a6e38}"/>

</application>

</compatibility>

The Vidyo client library makes a decision in regards to what resolution and frame rate is rendered by the local camera and sent to remote participants in a call. This decision is based on a number of factors including the device's CPU, available bandwidth, size of the view in the UI to render to, battery life, etc.

On mobile platforms (iOS/Android), battery life and temperature of the device are quite important factors in the decision making, for obvious reasons. In certain use cases, a developer may want to override the default behavior of the library and try to push the device harder to yield a greater resolution and frame rate. This can be done by implementing the following code. Note, that this example is for Android, but it would be the same logic on iOS. Also, please be aware that taking this action will drain the battery quicker than the default settings and the device is likely to heat up as well.

1. After construction of the Connector object, set the CPU tradeoff profile to high and register for local camera events:

mVidyoConnector = new Connector(mVideoFrame, Connector.ConnectorViewStyle.VIDYO_CONNECTORVIEWSTYLE_Default, 7, "info@VidyoClient info@VidyoConnector warning","",0);

mVidyoConnector.setCpuTradeOffProfile(Connector.ConnectorTradeOffProfile.VIDYO_CONNECTORTRADEOFFPROFILE_High);

if (!mVidyoConnector.registerLocalCameraEventListener(this)) {

mLogger.Log("VidyoConnector RegisterLocalCameraEventListener failed");

}

2. Inherit and implement theConnector.IRegisterLocalCameraEventListener interface

public class MainActivity extends Activity implements

Connector.IConnect,

Connector.IRegisterLocalCameraEventListener,

IVideoFrameListener {

...

@Override

public void onLocalCameraAdded(LocalCamera localCamera) {}

@Override

public void onLocalCameraRemoved(LocalCamera localCamera) {}

@Override

public void onLocalCameraSelected(LocalCamera localCamera) {}

@Override

public void onLocalCameraStateUpdated(LocalCamera localCamera, Device.DeviceState deviceState) {}

3. In the onLocalCameraSelected callback, set the framerate and resolution tradeoff profiles to high. It is important to set both to high as these profiles are coupled in the library.

@Override

public void onLocalCameraSelected(LocalCamera localCamera) {

if (localCamera != null) {

localCamera.setFramerateTradeOffProfile(LocalCamera.LocalCameraTradeOffProfile.VIDYO_LOCALCAMERATRADEOFFPROFILE_High);

localCamera.setResolutionTradeOffProfile(LocalCamera.LocalCameraTradeOffProfile.VIDYO_LOCALCAMERATRADEOFFPROFILE_High);

}

}

When debugging an issue or creating a support ticket ( [email protected] ), acquiring the log files is important. Below find where log files can be attained, depending on platform and/or browser:

Web browser:

Chrome/Firefox/Safari:browser console logs

IE:C:\Users\%USERNAME\%\AppData\Local\Temp\VidyoClient.log

Native platforms:

Windows: C:\Users\%USERNAME\%\AppData\Local\Temp\VidyoClient.log

macOS: /tmp/VidyoClient.log

iOS: Xcode console output

Android: Android Studio logcat

Also, see below related articles:

https://support.vidyo.io/hc/en-us/articles/115003128907-Configure-logging-in-your-native-application

https://support.vidyo.io/hc/en-us/articles/360018663134-Increasing-logger-verbosity-for-Chrome-Endpoints

https://support.vidyo.io/hc/en-us/articles/115003202733-How-to-set-the-console-log-level-for-Firefox

To increase console logging verbosity for Chrome endpoints - You can use the constructor of the VidyoConnector to change the logging level for example:

VC.CreateVidyoConnector({

viewId: "renderer", // Div ID where the composited video will be rendered, see VidyoConnector.html;

viewStyle: "VIDYO_CONNECTORVIEWSTYLE_Default", // Visual style of the composited renderer

remoteParticipants: 8, // Maximum number of participants to render

logFileFilter: "<insert filter string here>",

logFileName:"",

userData:""

})

You will pass a filter string which is created using aspace-separated (or comma-separated) sequence of names of log levels, each optionally followed by a category. Categories are separated from levels by the character '@'.

Either a level or category may be specified as 'all' or '*' (interchangeably), meaning all levels or categories. A level specified without a category is equivalent to a level@*.

The levels are: 'fatal', 'error', 'warning', 'info', 'debug', 'sent', 'received', 'enter', and 'leave'.

Valid categories are:VidyoClient, VidyoJingle, VidyoSDP, VidyoResourceManager, VidyoConnector, VidyoApplication, VidyoDevelopment

The level may be prefixed by '-' or '!' (interchangeably), meaning to remove the given level (or levels, see below) from the given category. The string 'none' is equivalent to '-all'.

The first level in the list may be prefixed by '+'. If the first level begins with a '+' or '-'/'!', the string is used to modify the listener's existing levels and categories. Otherwise, unless theaddparameter is true, the levels and categories specified in the string replace all existing levels and categories for the listener. The leading character '+' may be present before other levels, but is ignored.

Unless they are preceded by '=', level names imply other levels as well. In particular, each of the levels 'fatal', 'error', 'warning', 'info', and 'debug' implies the levels higher than it, when specified positively; 'sent' and 'received' always imply each other; and 'enter' and 'leave' always imply each other.

See VidyoConnectorGetLogCategories for determining the names and descriptions of registered categories.

Level names are case-insensitive; category names are case-sensitive.

Example: 'all' - all levels, all categories.

Example: 'all -enter' - all categories, all levels but enter and leave.

Example: '*@VidyoClient' - all levels for the VidyoClient category.

Example: '-*@VidyoClient' - remove all levels from the VidyoClient category.

Example: 'debug' - all categories, fatal, error, warning, info, and debug levels.

Example: '=debug' - all categories, debug level only.

Example: 'all -=enter' - all categories, all levels but enter (leave is still included).

Example: 'error@VidyoClient' - fatal and error only for the VidyoClient category.

Example: 'warning debug@VidyoClient' - fatal, error, and warning for all categories; additionally, info and debug for the VidyoClient category.

You should set string in logFileFilter when creating a Vidyo connector using CreateVidyoConnector().

A space-separated (or comma-separated) sequence of names of log levels, each optionally followed by a category. Categories are separated from levels by the character '@'.

Either a level or category may be specified as 'all' or '*' (interchangeably), meaning all levels or categories. A level specified without a category is equivalent to a level@*.

The levels are: 'fatal', 'error', 'warning', 'info', 'debug', 'sent', 'received', 'enter', and 'leave'.

The level may be prefixed by '-' or '!' (interchangeably), meaning to remove the given level (or levels, see below) from the given category. The string 'none' is equivalent to '-all'.

The first level in the list may be prefixed by '+'. If the first level begins with a '+' or '-'/'!', the string is used to modify the listener's existing levels and categories. Otherwise, unless theaddparameter is true, the levels and categories specified in the string replace all existing levels and categories for the listener. The leading character '+' may be present before other levels, but is ignored.

Unless they are preceded by '=', level names imply other levels as well. In particular, each of the levels 'fatal', 'error', 'warning', 'info', and 'debug' implies the levels higher than it, when specified positively; 'sent' and 'received' always imply each other; and 'enter' and 'leave' always imply each other.

See VidyoConnectorGetLogCategories for determining the names and descriptions of registered categories.

Level names are case-insensitive; category names are case-sensitive.

Example: 'all' - all levels, all categories.

Example: 'all -enter' - all categories, all levels but enter and leave.

Example: '*@VidyoClient' - all levels for the VidyoClient category.

Example: '-*@VidyoClient' - remove all levels from the VidyoClient category.

Example: 'debug' - all categories, fatal, error, warning, info, and debug levels.

Example: '=debug' - all categories, debug level only.

Example: 'all -=enter' - all categories, all levels but enter (leave is still included).

Example: 'error@VidyoClient' - fatal and error only for the VidyoClient category.

Example: 'warning debug@VidyoClient' - fatal, error, and warning for all categories; additionally, info and debug for the VidyoClient category.

You can control how much WebRTC related logging is outputted to the Firefox console by passing one of the following values as the webrtcLogLevelupon loading the VidyoClient:

'info' (default)

'error'

'none

For example, in our WebSDK sample, you will find the following lines of code in VidyoConnector.html:

webrtcLogLevel = '&webrtcLogLevel=info';

script.src = 'https://static.vidyo.io/4.1.17.5/javascript/VidyoClient/VidyoClient.js?onload=onVidyoClientLoaded&webrtc=' + webrtc + '&plugin=' + plugin + webrtcLogLevel;

So if you do not want any WebRTC console logging, you can change the value as follows:

webrtcLogLevel = '&webrtcLogLevel=none';

Important Notice!

Read more below:

Vidyo's native WebRTCis a redesign and enhancement of Vidyo's WebRTC solution, which improves the scalability, quality, stability, and performance in your vidyo.io browser experience.The WebRTC client now directly interacts with the vidyo.io infrastructure without needing to go through transcoding gateways.

In vidyo.io version 4.1.24, Vidyo has significantly enhanced the way we support WebRTC calls by offering full native WebRTC support for Google Chrome. Therefore, in order for your users to continue to make video calls using Chrome, you must update your application to the latest vidyo.io SDK and possibly make changes to your code.

Note: To maintain Chrome support in the vidyo.io application, you must upgradeto version 4.1.24.15 or later. The vidyo.io service will no longer accept connections from Chrome; unless you are using version 4.1.24.15 or later.

Upgrade Your SDK

Vidyo Client library versions prior to 4.1.24.15 have been deprecated for Chrome.

Starting with version 4.1.24.15, the Vidyo Client library will automatically route Chrome users to native WebRTC.

Verify and Update Your Code

The previous WebRTC APIs allowed you to pass arguments either by dictionary or directly. The new WebRTC APIs now only support dictionary notation. Therefore, you must ensure that all vidyo.io API calls you make pass in their arguments as dictionary objects.

You can quickly and easily make these modifications as outlined in the following example:

Previous API Call (ShowViewAt):

vidyoConnector.ShowViewAt(divId, offsetLeft, offsetTop, w, h);

Modified API Call (ShowViewAt):

vidyoConnector.ShowViewAt({viewId: divId, x: offsetLeft, y: offsetTop, width: w, height: h});

One additional change is in regards to the ShowViewAt API itself. In previous versions of the JavaScript library, this call was optional, whereas now ShowViewAt is required to be called to properly render video.

Resources:

For more information about this release, refer to the following resources:

API Reference Guide

Documentation

Release Notes

Best Practices

To obtain the latest upgrades/releases, please refer to the Updating Your Code to Instantly Receive the Latest Upgrades/Releases article in the Best Practices section.

One of the parameters for VidyoConnectorConnect is onFailure. It is a callback that is called whenever connection fails. The full list is available with Vidyo.Io documentation.

Following are the reasons for miscellaneous errors.

VIDYO_CONNECTORFAILREASON_MiscLocalError:

The server rejected the user's request to enter the resource, due to a miscellaneous problem with the request.

Failure to initialize room resource

Unknown error while joining the room

VIDYO_CONNECTORFAILREASON_MiscRemoteError:

The server rejected the user's request to enter the resource, due to a miscellaneous problem of its own. This can happen during creating room or entering the room.

VIDYO_CONNECTORFAILREASON_MiscError:

The login failed for some other miscellaneous reason

Login was cancelled by the user

Login failed for an unknown reason

Unknown error during room creation

Unknown error during room creation

When Protected Mode is enabled on IE11 (which is the default setting), other participants will not be able to see any content that is being shared by the local participant. Instead, they will see a black tile for any shared content.

To overcome this issue, Protected Mode needs to be disabled on IE11.

This can be done in Internet Options -> Security tab -> uncheck Enable Protected Mode.

Note: Browser restart is required for this to take effect

Vidyo.io does not limit the number of participants in a single call. You can have calls that are only two people and go up from there. The number of viewable participants however is limited based upon the endpoint device’s capability as it relates to CPU, available bandwidth, and screen resolution to render the video. For example, a PC can support up to 16 participants on screen. Mobile devices will likely support less due to limited bandwidth, CPU, and screen resolution.

Vidyo.io uses automatic voice detection and switches the video tiles. The most recent active speakers will be displayed on screen and any participants not visible, will automatically get promoted into the viewable tiles when they generate audio. The result is always seeing the most recent speakers on screen.

Overview

As you develop applications that leverage Vidyo.io, you may want to include a feature for recording and distributing recordings for private or public viewing. You may also want to include SIP-enabled participants in your calls. By integrating the Media Bridge Docker image with your Vidyo application, you can record and distribute or live-stream multiple Vidyo conferences across your organization's network simultaneously. You can also incorporate SIP-enabled video conferencing systems into your recordings and live streams.

What's Docker?

Docker is a robust software container platform you install on a dedicated server and use to run the Media Bridge image. The Media Bridge image provides record/playback functionality you might want to integrate with your Vidyo.io-based application. Docker provides the thorough resources and documentation you need to integrate basic or extensive Media Bridge features. See the Docker Overview here.

What's Media Bridge?

Media Bridge is a downloadable Docker image that provides the following:

Recorder for the archiving of Vidyo.io-based video conferences

Streamer for the distribution of Vidyo.io-based video conferences

Gateway for SIP-enabled systems

From Docker, you pull the Media Bridge image, create a config file, create a container, drop in your config file, then start recording.

Before You Begin

Before you begin, ensure that your Linux server is configured with a running Docker Engine.

What you will need

A Linux server running Ubuntu 14.04 or newer.

The Docker Engine package installed and running on your Ubuntu Linux server.

The complete Docker Documentation set.

Access tokens to vidyo.io (see How to generate a token ).

Server platformsother than Ubuntu Linux 14.04+ have not been tested; theymight not run smoothly or predictably inyour deployment.

Set-up

To set up your server with Media Bridgefor managing video conference recordings, follow these steps:

Install the Media Bridgedocker image:

docker pull vidyo/mediabridge

Create a recording configuration file (see Recording Configuration File ).

Create a container from theMedia Bridgeimage:

docker run -d --name my_mediabridge vidyo/mediabridge /sbin/my_init

Copy your config file to the container:

docker cp config my_mediabridge:/opt/vidyo

To record or live-stream multiple Vidyo conferences simultaneously, you need to create and deploy a separate Docker container for each recording and live stream.

Start a Recording

To start the container, enter:

docker exec -d my_mediabridge /opt/vidyo/connect

Monitor a Recording

You can check whether an ongoing recording is still in progress by checking its process ID. To do so, enter the following command:

docker exec -it my_mediabridge pgrep -x call

If a recording is active, the command returns the process ID; otherwise, it returns nothing.

Stop a Recording

The recording stops automatically when the last participant leaves the room. When you are done, run:docker stopanddocker rmto release the resources used by the container.

To force the recording to stop with a SIGINT call, enter:

docker exec my_mediabridge pkill -x --signal INT call

Retrieve a Recording

By default, the recording is saved to a file named recording.flvat this path:

/opt/vidyo folder

To retrieve the recording, enter:

docker cp my_mediabridge:/opt/vidyo/recording.flv $HOME

To override this, use the destination option described in the Recording Configuration File Options table below.

Include SIP-enabled systems

To make a SIP outbound call, set the destination key in the config file to the full SIP URI:

destination=sip:[email protected]

To receive an incoming SIP call, leave the destination key empty:

destination=

To start the Docker container for SIP calls, use the-pparameter to map host ports to the container for both media and signaling. For example, if themediaPortskey in the config file is set to50000-50100, the Docker command is:

docker run -d --name sipCall -p 50000-50100:50000-50100/udp -p 5060:5060/udp vidyo/mediabridge

You must map SIP signaling UDP port5060from the host to the container.

Convert FLV Files to MP4 Format

You can use FFMPEG to convert an FLV file to MP4. The FFMPEG conversion command isffmpeg -i <flv file name> -c:v copy -c:a aac -strinct -2 <mp4 file name>. You can download FFMPEG at:https://ffmpeg.org/https://ffmpeg.org/

Install a Customer Certificate Authority

To install a customer certificate authority, the Certificate Authority (CA) file has to be copied to the/opt/vidyofolder in the Docker container. The file name must beca-certificates.crt. For example, assuming the CA file is namedca.crtand the container is namedrecorder, issue the commanddocker cp ca.crt recorder:/opt/vidyo/ca-certificates.crt. Do this before starting any recording using Customer Certificate Authority.

When a recorder first establishes a connection, it verifies the server's certificate. If the certificate fails verification, the recorder's log contains the following error message:

call [47]: XmppGateway ERROR gwXmpp xmpp.c:723 LoginCompleted failed result 2

Troubleshooting

If you encounter a problem, retrieve the log file gw.log from the container at this path and use it to troubleshoot:

/var/log

To enable full logging, addlog=full|debug|info,|warn|error|none. The default isdebug.

Resource Requirements

To ensure Media Bridge has sufficient resources for smooth HD streaming and playback, use the following CPU and memory reservation guidelines for each deployed Media Bridge container. If you are running multiple recordings or live streams, ensure you have reserved sufficient resources as outlined here for each deployed container.

Resolution (fps)

CPU [GHz]

RAM [GB]

HD @ 720p (30)

2.2

2

HD @ 1080p (30)

4.0

4

Recording Configuration File

The recording configuration file is a plain text file with key-value pairs. Name this file config and place it at this path:

/opt/vidyo

Each key-value pair must be on a separate line.

The key is separated from the value with an equal (=) sign only; do not use spaces in key-value pairs.

Use a # before comments; text appearing on a line after a # is ignored at runtime.

The following table describes the options available for the recording configuration file.

Recording Configuration File Options

Option

Description

width

The width of the video stream.

height

The height of the video stream.

fps

The frame rate of the video stream in frames per second.

kbps

The bandwidth of the recording in kilo-bits per second.

layout

Setto 1 fora basic layout, setto 2 fora presenter layout, where the current speaker occupies alarger tile than the rest, set to3 fora film strip layout, where the current speaker occupiesmost of the screen andotherparticipants appear in a film strip at the bottom.

maxParticipants

The maximum number of participants tobe rendered in the video stream. Minimum is 1, maximum is 8.

overlay

When set to 1, Media Bridgedisplays each participant's name as an overlay in the video stream.

videoCodec

You can set the video codec to the following lossy compression standards:H264,H263,VP8,VP9. The default setting isH264.

Note: FLV format only supports H264 and H263 video codecs. Recordings configured for unsupported codecs fail to start.

audioCodec

You can set the audio codec to the following lossy compression standards:AAC(32K kHZ),PCM(11.025K kHZ),OPUS(48K kHZ),SILK8(8K kHz),SILK16(16K kHz),SPEEX(32K kHz). The default setting isAAC.

Note: FLV format only supports AAC and PCM audio codecs. Recordings configured for unsupported codecs fail to start.

presentationAllowed

When set to 0, Media Bridgeignores presentations during the conference. When set to 1, Media Bridgerecords presentations instead of the main video streams.

presWidth

The maximum width of the presentation stream.

presHeight

The maximum height of the presentation stream.

presFps

The frame rate of the presentation stream in frames per second.

presKbps

The bandwidth used for the presentation stream in kilo-bits per second.

destination

This can be a file name, a folder name, or an RTMP URI. When you set this field to a folder name, Media Bridge randomly generates the file name. This directs the recording to a central storage location you mount inside the docker container (use the-voption). Media Bridge supports FLV and MKV video file formats with the following syntax:flv:/filename.flvormkv:/filename.mkv. When you set this field to an RTMP URI such asrtmp://a.rtmp.youtube.com/live2/my_stream_name, Media Bridge streams the recording to that destination. No permanent record is stored.

resourceId

The vidyo.io resource to connect to and record.

token

The access token to the vidyo.io system.

host

The vidyo.io host name to connect to. Make sure that this host name can be resolved inside your container. This can be done using the --add-host parameter when creating the container.

mediaPorts

The ports used to send and receive media from the SIP endpoint (e.g.mediaPorts=50000-50100). When you start the Docker container, map these ports to the same port numbers on the host via the-pparameter.

publicIp

The IP address of the host. It must be reachable by the SIP endpoint participating in the call (e.g.publicIp=1.2.3.4).

Sample configuration file for a recording targeted to a folder

#main video/audio settings

width=1280

height=720

fps=30

kbps=2000

layout=1

maxParticipants=8

overlay=1

videoCodec=H264

audioCodec=AAC

#Presentation settings

presentationAllowed=1 #0 - ignore presentations 1 - replace main video with presentation

presWidth=1280

presHeight=720

presFps=5

presKbps=300

destination="flv:/opt/vidyo/recording.flv"

#vidyo.io connection info

resourceId="my_room"

token="cHJvdmlzaW9uAHVzZXIwQGRlZmF1bHQuZGVmYXVsdC5jb20ANjQ4NzU0NjY0NjIAPHZDYXJkIHhtbG5zPSd2Y2FyZC10ZW1wJz48Rk4+RnVsbCBVc2VybmFtZTA8L0ZOPjxOSUNLTkFNRT51c2VyMDwvTklDS05BTUU+PC92Q2FyZD4AOWRiN2QxN2ZjMTNiOTc2ZTIxZjcwMjY4NmNjNzdkMzEwOTM2ODBkOTk3ZWJhN2Y2OTQ1ZmEwNTA5Njc4MWZlOTU1YTlmM2M4ODExNGQ5YzIwMjFhNjhlNmJlOGMwMmY1"

host="prod.vidyo.io"

#SIP gateway info

mediaPorts="min_port_number-max_port_number"

publicIp="host_ip_address"

Sample configuration file for a live stream targeted to an RTMP server

#main video/audio settings

width=1280

height=720

fps=30

kbps=2000

layout=1

maxParticipants=8

overlay=1

videoCodec=H264

audioCodec=AAC

#Presentation settings

presentationAllowed=1 #0 - ignore presentations 1 - replace main video with presentation

presWidth=1280

presHeight=720

presFps=5

presKbps=300

destination="rtmp://a.rtmp.youtube.com/live2/my_stream_name

#vidyo.io connection info

resourceId="my_room"

token="cHJvdmlzaW9uAHVzZXIwQGRlZmF1bHQuZGVmYXVsdC5jb20ANjQ4NzU0NjY0NjIAPHZDYXJkIHhtbG5zPSd2Y2FyZC10ZW1wJz48Rk4+RnVsbCBVc2VybmFtZTA8L0ZOPjxOSUNLTkFNRT51c2VyMDwvTklDS05BTUU+PC92Q2FyZD4AOWRiN2QxN2ZjMTNiOTc2ZTIxZjcwMjY4NmNjNzdkMzEwOTM2ODBkOTk3ZWJhN2Y2OTQ1ZmEwNTA5Njc4MWZlOTU1YTlmM2M4ODExNGQ5YzIwMjFhNjhlNmJlOGMwMmY1"

host="prod.vidyo.io"

#SIP gateway info

mediaPorts="min_port_number-max_port_number"

publicIp="host_ip_address"

http://support.vidyocloud.com

Vidyo is Pleased to Announce vidyo.io Client Version 4.1.25

In vidyo.io client version 4.1.25, Vidyoishappy to introduce a number of enhancements includingupdating the OpenSSL version,supporting Unicode characters, adding an API to limit bitrate on WebRTC, and providing the ability to enable and disable location requests. Read below for more information about these beneficial updates.

What's New?

OpenSSL Update

Forimproved security, this release supports the latest version of OpenSSL, which is OpenSSL 1.0.2p.

Support for Unicode Characters for Display Names

Display names are the names of the participants that appear overlaid on each tile during a video call. With the addition of support for Unicode characters, these display names can now appear correctly in Chinese, Japanese, and other languages.

API to Limit Bitrate on WebRTC

We now support SetMaxBitrate for WebRTC clients. Using this API allows you to limit the maximum transmit bandwidth.

Enable and Disable Location Requests

There may be times when you’d prefer that your web application not query your customers for location permissions. This is now possible with version 4.1.25, as you now have the ability to disable native WebRTC from making a location request.

Reminder

Sign up for service announcements at the Vidyo Status Page by selectingSubscribeat the top right. You can now visit this site anytime to view past and current cloud-related announcements.

Want More Info?

Toget additional details about the new features and the known and resolved issues for this release, see the Release Notes: vidyo.io version 4.1.2.5 article onthe Vidyo.io Support Center.

Need Help?

If you would like further information or need additional assistance, please contact VidyoCloud Support at 1-844-488-2227 or +1-201-620-6955.

The VidyoCloud Support Team

Phone 1-844-488-2227 or +1-201-620-6955 if calling from outside the USA

Email [email protected]

Online

The contents of this Product Bulletin do not in any way modify the terms of the agreement(s) under which this product is provided.

As of release 4.1.17.5, Windows Forms and WPF application development using C# is fully supported by Vidyo.io. This version of the Windows SDK contains C# wrapper classes combined with a dll containing our native library to make this possible:

VidyoClient-WindowsSDK/include/csharp/*.cs : C# wrapper classes

VidyoClient-WindowsSDK/lib/windows/Win32/Release/libVidyoClient.dll : dll for 32 bit configurations

VidyoClient-WindowsSDK/lib/windows/x64/Release/libVidyoClient.dll : dll for 64 bit configurations

In order to integrate Vidyo.io into your C# Windows application, you need to include the C# files mentioned above into your project and placelibVidyoClient.dll into your PATH or the directory where your executable is built (bin/debug or bin/release).

The UI element that should be used to render video is aSystem.Windows.Forms.Panel. An example of how it would be used in a Windows Forms app is shown below:

System.Windows.Forms.Panel videoPanel;

Connector connector = new Connector(videoPanel.Handle, Connector.ConnectorViewStyle.ConnectorviewstyleDefault, 15, "info@VidyoConnector info@VidyoClient warning", "", 0);

connector.ShowViewAt(videoPanel.Handle, 0, 0, (uint)videoPanel.Width, (uint)videoPanel.Height);

A VidyoConnector WPF reference application can be found on the Vidyo GitHub page here:

https://github.com/Vidyo/VidyoConnector-WPF

When you usea Vidyo.io native app, you take full advantage of Vidyo's unique and patterned technologies. Consider the following:

Vidyo.io leverages Scalable Video Coding (SVC) to encode video into separate layers. The amount of video layer information can be increased or decreased as needed to deliver the optimal video stream by varying resolution and frame rate.

The Vidyo.io routing core technology receives video from all endpoints and adapts the outbound video for each endpoint receiving video. It dynamically changes the amount of video sent to each endpoint based upon available bandwidth, CPU strength, and screen resolution.

Mobile devices have smaller screen resolution and limited processing capability. The Vidyo.io routing core selectively forwards a slimmed down stream that is ideal for each mobile device.

When you are using a web app, Vidyo hasimplemented web plugins to continue leveraging our revolutionary technology. Unfortunately, browsers such asChrome and, more recently, FireFox deprecated plugins, so we are using WebRTC for these browsers. While WebRTC is a great technology, it cannot meet the quality we provide with SVC (see above). If the video quality is very important for your case, here is what Vidyorecommends:

Consider developingnative apps.

If you need to develop aweb app, Safari and Internet Explorer (IE) work the best as they continue to supportplugins.

If neither native apps nor web apps optimized for Safari/IE are practical, optimize your code for Chrome or FireFoxwithWebRTC.

You can includelogic in your app to fall back toWebRTCwhen betteroptionsarenot available.

Overview

This document intends for vidyo.io beginner. You can have the knowledge for building simple video chat application. If you have developed your application by other company solution and VidyoWorks API, you will experience how you can more easily develop video chat application than others.

Required software

Android Studio

Android Package of Vidyo.io

It can be downloaded from https://developer.vidyo.io/packages

Getting Started

Create a new Android Studio Project

Start Android Studio and click "Start a new Android Studio project"

Set Application name and location

Select Minimum Android SDK

The Vidyo.io SDK supports the Android 4.4+.

Add an Empty Activity

Import the Android library

Download the Android Package from https://developer.vidyo.io/packages

This Package includes the Android library and a sample that can help developers to realize many features and start quickly.

Copy all libraries into project libs directory: VidyoIODemo app "libs"

Develop the application

Configure Project

Add CAMERA and INTERNET permission in AndroidManifest.xml

Code Snippet:

<uses-permissionandroid:name="android.permission.CAMERA"/>

<uses-permissionandroid:name="android.permission.INTERNET"/>

Add source sets in the build.gradle file.

Code Snippet:

sourceSets {main { jniLibs.srcDirs = ['libs']}}

Design the UI

Use "RelativeLayout" in the activity_main.xml.

Change to Design View and remove "Hello World!" TextView.

Add 3 Operation Buttons:

START button with properties Text: Start, onClick: Start

CONNECT button with properties Text: Connect, onClick: Connect

DISCONNECT button with properties Text: Disconnect, onClick: Disconnect

Add Video Frame.

Add the FrameLayout with properties ID: videoFrame

Implement Source Code

Import package of Vidyo.io library and add private member variable of VidyoConnector and FrameLayout.

Initialize Vidyo Client.

Code Snippet:

Connector.SetApplicationUIContext(this); Connector.Initialize();

videoFrame= (FrameLayout) findViewById( R.id.videoFrame);

Implement Start method

Code Snippet:

public voidStart(View v) { vc=newVidyoConnector(videoFrame,VidyoConnector.VidyoConnectorViewStyle.VIDYO_CONNECTORVIEWSTYLE_Default,16,"","",0);

vc.ShowViewAt(videoFrame,0,0,videoFrame.getWidth(),

videoFrame.getHeight());

}

Implement Connect method

Code Snippet:

public voidConnect(View v) {

String token = "cHJvdmlzaW9uAGRlbW91c2VyX2IwOTZhNkA2OGY2MTMudmlkeW8uaW8ANjM2NjcxNjc5ODYAADI3NGEzZTUwZThkOTI2NmNlNzgyOTNmYmE2NDczYzM4NThjNGQ4OGYxMzc2MzY2MjU0ODRiMDIyZmZkMWEzY2ZmMzFkZDM0NzQ3ZjBhOGU5MTk2NjAyYzBiNGVmZDczMQ==";

vc.Connect("prod.vidyo.io", token,"DemoUser","DemoRoom",this);

}

Get a token quickly

Access to https://vidyo.io and login.

Go to menu DEVELOPERS Demo.

Click "GENERATE LINK" to get a meeting link.

The meeting link is as below:

https://static.vidyo.io/latest/connector/VidyoConnector.html?host=prod.vidyo.io&resourceId=demoRoom&displayName=demoUser_90173&token=cHJvdmlzaW9uAGRlbW91c2VyX2YyZDYyZkA2OGY2MTMudmlkeW8uaW8ANjM2NjcxNjg5MzIAAGViMTMwODVmODhiZTFlYmU3MGRhNzcyZGIwOGZiZWY4YjZmNTg0YzQ5NGYwZjE4ZTNhOTA4ZGM0M2VkOThmMzUwNTBiMTBlZjBmNGI3ZTM0ZmMxNDk5ZGQ5NTM1OTM1Mg\%3D\%3

Note:

The "\%3D" has to be replaced by "=" when use it in the code, because it is transformed from equal sign "=" as URL rule.

How to Generate a Token

Access to https://vidyo.io and login.

Go to menu DEVELOPERS Documentation "How to Generate a Token"

Implement Disconnect method

Code Snippet:

public voidDisconnect(View v) {vc.Disconnect();}

Implement IConnect Interface

Code Snippet:

public voidOnSuccess() {}

public voidOnFailure(VidyoConnector.VidyoConnectorFailReason vidyoConnectorFailReason) {}

public voidOnDisconnected(VidyoConnector.VidyoConnectorDisconnectReason vidyoConnectorDisconnectReason) {}

The connect listener can be register when vc.Connect() method is invoked, which need to implement the iConnect interface.

Build and Run the Application

At first, go to Android mobile's "Developer Options" and enable the "USB Debugging".And then connect mobile to the computer, which would be recognized by "Android Monitors" of Android Studio.

Click run button to execute application.

Click Start button and preview self.

Click Connect button to join the meeting.

Other participants can join meeting via above URL generated from Vidyo.io.

Click Disconnect button to leave the meeting.

Note: Everyone has to join the meeting via the sameresourceId.

Reference

Video Clip Vidyo.io | Build an Android Video Chat App in Minutes

https://www.youtube.com/watch?v=tbT8EEw9wNw&t=1s

The VidyoClient.js javascript library seamlessly switches between the plugin and WebRTC; the plugin is preferred. While the plugin offers generally better performance, the following table explains possible options:

Mode/Browser

Chrome

Chrome on Android *

Firefox

Safari

Safari on iOS *

IE

Edge

Plugin

no

no

no

no

no

yes

no

WebRTC

yes

beta

yes

beta

no

no

beta

* For best performance and video quality on mobile devices, we recommend using the native mobile SDKs for iOS and Android.

The iOS AVAudioSession is a tool supplied by Apple to provide granular control over the device's audio. The AvAudioSession is a singleton shared by an application's runtime. The VidyoClient and its underpinning SDK leverage the AudioSession and the AudioUnit - which provides even more granular control over the audio - to manage audio input and output for Vidyo calls. Due to the singleton nature of the AudioSession, and the VidyoClient's dependency on it, it is strongly recommended that any applications leveraging the VidyoClient's SDK not manipulate the AudioSession in any way since doing so could cause instability in the VidyoClient.

It is recommended that any interaction with the AudioSession be readonly.

If you are considering to build WebRTC vs Native Video chat app, check our pros/cons and ideal uses for different approaches.

Full blog post is https://vidyo.io/blog/how-to/build-native-web-based-video-chat-application/

Pros

Native App

Discrete app rather than browser tab

Full access to native OS and resources

Consistent performance across operating systems

WebRTC App

Generally faster to develop

No software for user to download/install

Universally accessible on different devices

Cons

Native App

Requires development knowledge for supported operating systems

Development process can take longer

WebRTC App

Can be inadvertently closed as a browser tab

Browser incompatibility

Lower degree of control

Ideal Uses

Native App

Power or frequent users

Performance sensitive applications

Video quality is critical

More than two participants

WebRTC App

Occasional users

Convenience is more important than quality

Short Calls

Two-way call

This document is to serve as guidelines only for best practice results.

Packet Loss

Packet Loss is the event where one or more packets are not received bythe intended recipient as expected due to congested network or failure in transmission.

The following should be measured and presented for packet-loss:

GREEN

Packets lost per second

No Loss - < 1\%

YELLOW

Packets lost per second

> 1\%

RED

Packets lost per second

> 5\%

Packet Latency

Latency is the measure of delay on the network, usually measured in milliseconds and for round trip time.

IDEAL

Less than 100ms

OK

100ms-250ms

WARNING

250-450ms

NO GOOD

More than (>) 450ms

NOTE: VidyoProxy will not support latency greater than (>) 200ms>

Jitter

Jitter is a measure of the variability over time of packet latency across a network. A network with constant latency has no variation (or jitter). Packet jitter is expressed as an average of the deviation from the network mean latency.

hen jitter occurs during video/audio communication the effect is lost audio, halted audio, unnatural audio.

It is highly desirable to eliminate or minimize such events during live video/audio communications.

Monitoring the jitter provides an indication of the quality of the network.

IDEAL

No Jitter, latency is relatively consistent, less than (<) 10ms

WORKABLE

Jitter less than 100ms

WARNING

Jitter 101-200ms

NO GOOD

Jitter more than (>) 200ms

Available Bandwidth

Available bandwidth is the amount of bandwidth available to the client. The client statistics show the maximum available that the client may use, not the full amount available to the client host system.

For Vidyo, the uplink bandwidth is more straight-forward. For downlink, it is very subjective, and depends on what is being viewed (the number of participants, window size, etc).

Uplink:

Best for HD Tx

1-1.2 Mbps Up/Send

Best for SD Tx

600-800 Kbps Up/Send

OK Tx

400-600 Kbps Up/Send

MED Tx

250-400 Kbps Up/Send

LOW Tx

150-250 Kbps Up/Send

NO GOOD Tx

Less than 150 Kbps Up/Send Audio Only

NOTE: Add 200 Kbps when data sharing

Downlink:

IDEAL HD Rx

4 Mbps Down/Receive

IDEAL SD Rx

2-2.4 Mbps Down/Receive

OK Rx

400 Kbps -2 Mbps Down/Receive

MED Rx

250-400 Kbps Down/Receive

LOW Rx

150-250 Kbps Down/Receive

NO GOOD Rx

Less than 150 Kbps Down/Receive Audio Only

Q:Why is Vidyo making this change?

A: Vidyo’s migration to native WebRTC now bypasses the need for WebRTC transcoding (encoding and decoding of the video stream). In doing so, the quality of WebRTC calls are improved by minimizing delays.

Q: How much time do I have to make this change?

A: We will no longer allow calls from Google Chrome on versions earlier than SDK v4.1.24 starting November 4, 2018. Be sure to get your code updated prior to this date and deployed to your users to allow uninterrupted calls on Google Chrome.

Q: Are any other platforms affected by this change?

A: This change only affects users on Google Chrome. Users who connect via iOS, Android, Windows, or macOS SDKs are not affected by this change. Additionally, users on other supported browsers including Firefox, Safari, Microsoft Edge and Internet Explorer are not affected by this change.

Q: What is involved in this change?

A: You will need to update your application to use the latest version of the vidyo.io Javascript SDK to v.4.1.24 or later. Depending on how you originally implemented your code, you may need to make minor modifications to your code. For more details, refer to this technical article.

Q: Will my users see a difference after this change?

A: Users who join video calls using Google Chrome will immediately benefit from improved video quality as there are minimal delays added by the transcoding process. Also you can obtain even higher resolutions through use of APIs.

Q: Are there any new features associated with this new version?

A: Yes. Previously the resolution of the WebRTC video was limited. Now with v.4.1.24 of the vidyo.io Javascript SDK, you can change the resolution to your preferred quality.

Q: What happens if I don’t update to the latest Javascript SDK?

A: On November 4, 2018 we will no longer connect calls from Google Chrome using prior versions to 4.1.24. It is very important to make the necessary updates prior to to this date for uninterrupted Google Chrome service for your users.

Q: Will there be any changes like this in the future?

A: The current architecture change enables native WebRTC for Google Chrome. Over time, we plan to support additional browsers in the same native (non-transcoded) fashion. However, we do not anticipate any code changes but may require you to an updated and incorporate a later version of the SDK. Vidyo always recommends keeping up to date with the latest version of the SDK to take advantage of resolved issues/bug fixes, stability improvements, and new features.

When attempting to perform a call in IE 11, the connection may fail with aVIDYO_CONNECTORFAILREASON_ConnectionLost error if Protected Mode is enabled (Internet Options > Security). The preferred way of handling this would be by setting the default certificate authority list of the VidyoConnector object. It is recommended that this API be called only when the Vidyo.io enabled app is running on IE, like so:

var userAgent = navigator.userAgent || navigator.vendor || window.opera;

// Set certificate authority list only if running in IE.

isIE = (userAgent.indexOf("MSIE") != -1 ) || (!!document.documentMode == true );

if(isIE)

{

vidyoConnector.SetCertificateAuthorityList({ certificateAuthorityList: 'default' });

}

If preferred, you may create your project using a combination of libraries and third party frameworks, as opposed to the VidyoClientIOS framework.

Import the library and header directories from the Vidyo.io iOS SDK package into your project:

VidyoClient-iOSSDK/lib

VidyoClient-iOSSDK/include

Add the following libraries and frameworks to the Linked Frameworks and Libraries settings in the General settings of the target:

libVidyoClient.a (included in Vidyo.io iOS SDK package)

libcrypto.a (included in Vidyo.io iOS SDK package)

libopus.a (included in Vidyo.io iOS SDK package)

libspeex.a (included in Vidyo.io iOS SDK package)

libsrtp.a (included in Vidyo.io iOS SDK package)

libssl.a (included in Vidyo.io iOS SDK package)

VPX.framework (included in Vidyo.io iOS SDK package)

AVFoundation.framework

AudioToolbox.framework

CoreLocation.framework

CoreMedia.framework

SystemConfiguration.framework

UIKit.framework

In the Build Settings of the target, update the Framework Search Paths, Header Search Paths, and Library Search Paths to reference the directories imported in step 1.

Go to the Vidyo.io Developers Documentationtopic Tokens and then replace https://static.vidyo.io/latest/connector/VidyoConnector.html with the address of your VidyoConnector.html location. The result should look something like:

<VIDYO CONNECTOR ADDRESS>?host= prod.vidyo.io &resourceId=<URL ENCODE(YOUR ROOM NAME)>&displayName=<URL ENCODE(YOUR DISPLAY NAME)>&token=<URL ENCODE(YOUR TOKEN)>

As of VidyoClient release 4.1.17.5, the iOS and Android packages (available here ) contain C# bindings which can be used to build a Xamarin app for these platforms. The bindings are a combination of the C# source files located in the include/csharp directory and one of the following:

iOS: lib/ios/libVidyoClient.dylib

Android: the .so and .jar files located at lib/android

There are multiple types of Xamarin apps that can be created:

Xamarin.iOS: an iOS app whose UI is built using a Storyboard, similar to what is found in Xcode

A sample showing a simple Vidyo.io integration can be found here.

Xamarin.Android: an Android app whose UI is build using an xml builder similar to what is found in Android Studio.

A sample showing a simple Vidyo.io integration can be found here.

Xamarin Forms: a cross-platform application for iOS and Android, which contains a common XAML UI builder.

The VidyoConnector app built using Xamarin Forms can be found here.

More info can be found in the Xamarin section under Getting Started in the developer guide.

You should contact the Vidyo.io sales team to discuss your application. Our team is very knowledgeable with healthcare provider needs and can help you get started on the right foot.

While preparing an app for submission to Apple'sApp Store, developers must remove code that isn't for iOS devices, and that applies to the x86-based architectures of the iOS Simulator. The quickest next step is to search online for how to strip those architectures, including the search terms "lipo" and "App Store."

This is the downside of providing an Xcode framework that supports both iOS devices and the iOS Simulator, but it's not unique to the framework that Vidyo provides. The framework is relatively easy to use during development, but it requires an additional step for App Store submissions.

Alternatively, you couldbuild your app using the provided static libraries (plus additional Apple third-party frameworks) in the VidyoClient-iOSSDK package rather than those ofthe VidyoClientIOS.framework. Click here for more info.

Suggested steps:

Add a Run Script step to the Build Phases for the appropriate Target. See the descriptionfor this process here: https://www.hockeyapp.net/help/runscriptbuildphase/

Strip the unwanted architectures by populating the new Run Script with the script in this article: http://ikennd.ac/blog/2015/02/stripping-unwanted-architectures-from-dynamic-libraries-in-xcode/

Clean in Xcode: Product > Clean

Build in Xcode: Product > Build

Deploy to app store

We are officially supporting Android SDK 4.4 (API level 19) and above which should cover a very high percentage of Android users.

The Keyboard Noise Suppression feature in vidyo.io employs patented algorithms that isolate the human vocal component of a participant's audio signal, thereby minimizing keyboard and other background noise from a participant's audio signal. All noise suppression is enabled by default in vidyo.io applications.

Although noise reduction is enabled by default, you can disable and re-enable this functionality in your code using theAudioSignalType enumeration of the VidyoDevice class.

The syntax is:VidyoDeviceAudioSignalType.

See VidyoDevice - AudioSignalType in the vidyo.io Reference Guide for values and descriptions for including or excluding background noise reduction in your vidyo.io application.

An extension is required to enable window sharing on WebRTC. When the VidyoClient library is loaded, a callback method onVidyoClientLoaded is called which provides a status parameter. Dependent on the browser that the app is loaded in (Firefox or Chrome), one of two fields will be set, which will provide a link to download the extension:

status.downloadPathWebRTCExtensionChrome (click here to access)

status.downloadPathWebRTCExtensionFirefox (this download URL will vary)

After installing the extension and running the app, the browser will pop up it’s own share selection dialog onceRegisterLocalWindowShareEventListeneris called and the result of the user selection will be available in theonAddedevent.

You canuse Vidyo.io's Group Chat feature to reachmuted call participants who are experiencingtechnical issues with video or audio throughput. These chat messages are sent via TCP, so as long as the other party is still connected to a room, any muted users continue toreceive them. You can send aspecially formatted message (e.g. in JSON) in the chat message to control the devices of remote participants.

Firefox 52 was released on March 7, 2017and has officially dropped NPAPI support.

Tocontinue to force FireFoxtoload plugins, do the following:

Enter: about:config in the URL bar

Add a new preference namedplugin.load_flash_only (right-click New > Boolean), set it to FALSE.

This worksfor version 52, and perhaps 53. You can also switch to the Firefox 52 ESR release, which supportsNPAPI until the release of Firefox 59 ESR.

For more information, click here.

Vidyo.io can be integrated into an Electron app, which allows a developer to build a native Windows or Mac appusing HTML/JS/CSS. This will leverage all of the benefits of the Vidyo.io SDK with respect to a WebRTC implementation in the browser.

The following project in GitHub shows how to run the VidyoConnector web app as a native Windowsor Mac app using Electron:

https://github.com/Vidyo/VidyoConnector-electron

Though it is in the roadmap to add some levels of room moderation to Vidyo.io, at the present moment it isnotsupported directly via its API.

However, an easy way to incorporate moderation is to leverage the Group Chat feature tosend controlmessages which have some specific meaning. For example, if you wish to disconnect a particular participant from a call, you may send a message such as "Disconnect : <PARTICIPANT_USER_NAME>". All participants in the room will receive this message, but only the application of<PARTICIPANT_USER_NAME>would act upon the disconnect request. In contrast, all "standard" chat messages may be prefaced by some other predefined string, such as "GroupChat", so such a message may look something like this : "GroupChat : who knew thatvideo chat integration can bethis easy?!"

The recommended way of getting participants' user names is by registering for participant events with the VidyoConnectorRegisterParticipantEventListener API and get the participant->userId value from theOnParticipantJoined callbacks. For example, a userId value of"[email protected]" contains a user name of "roger19".

Examples of how to use Group Chat can be found in the "Group Chat" section of developer.vidyo.io.