.png%3Falt%3Dmedia%26token%3D7a462e28-86e3-4286-bb93-5239fe58f32e)
.png%3Falt%3Dmedia%26token%3D7a462e28-86e3-4286-bb93-5239fe58f32e)
Advanced Features
Take a look at the Thinfinity VirtualUI advanced features:
When using VirtualUI, it is often necessary to be aware of some features and capabilities of the device from which end users are accessing our application.
The VirtualUI class has a property called BrowserInfo, which contains data about the browser being used. This information can assist us in delivering the best possible user experience.
In the list below we will find a detailed reference of the information that BrowserInfo will deliver:
Attribute | Description |
Username | Returns the logged-on username. |
IPAddress | Returns the client's ip address. |
Location | Returns the URL of the current application. |
UniqueBrowserId | Identifies an instance of a browser. Each time an end-user opens the application from a different browser window, this identifier will be have a different value. |
UserAgent | Returns the browser's User Agent string. This value is very important to identify which browser type is used, if the remote device is a mobile, etc. |
An important value to consider is the UserAgent property. When establishing a connection, the browser sends VirtualUI a data string indicating its brand and version, which OS it is running on, and the brand and model of the device that is being used. This value is known as the userAgent. Using this value we can infer, for example, if the user is connecting from a mobile device and then modify some specific feature, layout or functionality of our application to better suit that device.
Information relative to the available screen space:
Attribute | Description |
BrowserWidth | Returns the width of the HTML element containing the VirtualUI viewer, in pixels. |
BrowserHeigth | Returns the height of the HTML element containing the VirtualUI viewer, in pixels. |
ScreenWidth | Returns the width of the end-user's device screen, in pixels. |
ScreenHeight | Returns the height of the end-user's device screen, in pixels. |
ScreenResolution | Returns the application screen resolution defined in the application profile. |
ViewWidth | Returns the width of the VirtualUI viewer, in pixels. |
ViewHeight | Returns the height of the VirtualUI viewer, in pixels. |
Orientation | Returns the browser's orientation. |
It is also worth mentioning that when using VirtualUI, the desktop size is dynamic. This means that the space available to display the application is correlated to the available space in the browser screen and it is not limited to a fixed desktop size space —as it would happen, for example, in an RDP connection, where the desktop size is defined when the connection is established.
The following C# example shows how to center a window of our application on this virtual desktop as needed, previously controlling its size if it exceeds the available space:
using Cybele.Thinfinity;...
...
...
private VirtualUI vui;
public Form1()
{
InitializeComponent();
vui = new VirtualUI();}
private void CenterThisWindow(object sender, EventArgs e)
{
this.WindowState = FormWindowState.Normal;
if (vui.BrowserInfo.ViewHeight < (this.Height + 20)) {
this.Height = vui.BrowserInfo.ViewHeight - 20;
}
if (vui.BrowserInfo.ViewWidth < (this.Width + 20))
{
this.Width = vui.BrowserInfo.ViewWidth - 20;
}
this.Top = (vui.BrowserInfo.ViewHeight - this.Height) / 2;
this.Left = (vui.BrowserInfo.ViewWidth - this.Width) / 2;
}
ClientSettings is an additional interface available in the Thinfinity VirtualUI Library that allows developers to remotely and programmatically configure particular browser settings. These settings are related to the cursor visibility and some specific touch action behaviors.
The table below shows a detailed reference of the ClientSettings interface current properties:
Property | Use | | |
CursorVisible | Used to set the mouse pointer to 'show' or 'hide'. Type: Boolean Default value: True Available in all Library Versions. | | |
MouseMoveGestureStyle | Defines whether the mouse movement is read as relative or absolute in touch devices. Type: Enum Values: MM_STYLE_RELATIVE = 0 MM_STYLE_ABSOLUTE = 1 Default value: MM_STYLE_RELATIVE Available in all Library Versions. | | |
MouseMoveGestureAction | Indicates if the dragging should be interpreted as scrolling or turning of the mouse wheel, affecting only the component on which the action is triggered. Type: Enum Values: MM_ACTION_MOVE = 0, MM_ACTION_WHEEL = 1 Default value: MM_ACTION_MOVE Available in all Library Versions. | | |
UseViewportSize | Indicates which measure values will be used to define the application's screen size. Type: Boolean Values: True: use the viewport size False: use a window screen based size. Default value: False Available only in Javascript. | | |
DockMenu | Manages the visibility of the bottom menu and its options. Available only in Javascript | | |
| Enabled | Boolean. Enables/disables the complete Dock Menu. Type: Boolean Default value: True | |
| Pinned | Indicates when the DockMenu is pinned (visible, fixed) or unpinned (with autohide) Type: Boolean Default value: False | |
| Items | Name/value pairs item collection. | |
| | WindowList | Enables/disables the "Windows list" option. Type: Boolean Default value: True |
| | ErrorReporting | Enables/disables the "Error Reporting" option. Type: Boolean Default value: True |
| | Keyboard | Enables/disables the "Keyboard" option (mobile only). Type: Boolean Default value: True |
| | FullScreen | Enables/disables the "Full Screen" option (mobile only, if supported). Type: Boolean Default value: True |
As mentioned previously, these properties were created to provide a better end-user experience when using touch devices.
When using a touch device, it is unusual for a mouse pointer to be displayed. Instead, finger gestures are interpreted by the device as different commands, acting on the element or elements that are located where the gesture is made.
But this is not always the best way, especially when the applications were not designed for these gestures. Most of the times, the best solution to this issue is to show the pointer and simulate the mouse actions using the captured gestures.
The properties that we have presented above will help us define the ideal settings to enjoy the best possible and intuitive user experience for our application.
The following example shows how to recognize a touch or mobile device, and to change the pointer behavior when it's detected. Warning: The detection list is not complete:
vui = new VirtualUI();
userAgent = vui.BrowserInfo.UserAgent.ToLower();
if ((userAgent.IndexOf("touch") != -1) || (userAgent.IndexOf("mobile") != -1) ||
(userAgent.IndexOf("iphone") != -1) || (userAgent.IndexOf("ipod") != -1) ||
(userAgent.IndexOf("ipad") != -1) || (userAgent.IndexOf("android") != -1) ||
(userAgent.IndexOf(" cros ") != -1)) {
vui.ClientSettings.MouseMoveGestureStyle = MouseMoveGestureStyle.MM_STYLE_ABSOLUTE;
vui.ClientSettings.MouseMoveGestureAction = MouseMoveGestureAction.MM_ACTION_WHEEL;
}
Thinfinity VirtualUI allows you to protect the published applications by applying Active Directory (AD) objects to each one of them. In order to be able to see and execute an application in the Thinfinity VirtualUI environment, either the application must have anonymous access or the end-user must provide credentials that satisfy the AD objects assigned to that application.
Thinfinity VirtualUI lets you activate one or more authentication methods, allowing for the mapping of credentials to AD objects, which in turn will grant access to the applications that had the same AD objects applied. Also, the end-user identification is passed on to the application in order to allow a Single Sign-On.
Read the following sections to learn how to implement the available authentication methods in VirtualUI web-enabled applications.
Read more:
Thinfinity VirtualUI allows you to enable one or more authentication methods at a time. There are two possible ways to ask for credentials:
· Using the standard Web Browser authentication dialog
· Showing a log-in page
The Standard Web Browser Authentication (aka Basic Authentication) is, in the context of an HTTP/HTTPS transaction, a method for the HTTP User Agent (the Web Browser) to provide end-user credentials when a request is started. The standard Web Browser authentication dialog is provided by each Web Browser and it looks like this:
This dialog is available when you use only one of the authentication access methods that require user and password: Windows Logon, RADIUS or External DLL.
Also, you can use a login page. The login page provided (login.html) was created to dynamically show all configured authentication methods in your Thinfinity VirtualUI Server. Every login option will be present only if the proper authentication method is configured.
For example, if only the 'Windows Logon' method is configured, the page will look like this:
But if you enable all predefined methods, your login will show something like this:
You can modify this page to adapt it to your branding and/or integration needs. Check out the login.html section to learn how.
Read more:
Each published application without anonymous access requires the assignment of one or more Active Directory objects which define the users that can see and execute it.
Thinfinity VirtualUI implements a mapping mechanism to transform end-user credentials to AD objects. Only applications that match these AD objects will be granted access to the end-user.
When you enable an authentication method, you must add the mapping rules that will allow you to link the user ID with an AD object. This is done by specifying an external user ID mask and its linked AD objects.
Depending on the selected authentication method, Thinfinity VirtualUI uses the identification provided provided by the user to scan the mapping rule list and obtains the associated AD objects. If the matching process returns one or more AD objects, all applications with the same AD object are enabled to be seen and accessed by the end-user.
Read more:
Thinfinity VirtualUI allows you to use the following authentication methods.
Windows Logon
This option enables Active Directory credentials. This method is enabled by default.
RADIUS
Remote Authentication Dial-In User Service (RADIUS) is a networking protocol and software that provides centralized Authentication, Authorization, and Accounting (AAA) management for users who remotely connect to a network service, in this case the Thinfinity VirtualUI Server.
OAuth 2.0
OAuth 2.0 (or OAuth/2) is an open standard for authorization and authentication, commonly used as a way for Internet users to log into third party websites using their social network (Facebook, Google, LinkedIn, etc.) account without exposing their password.
External DLL
A custom authentication method implemented by you or a third party with our authentication API and referenced in the Thinfinity VirtualUI server.
Anonymous Authentication
You can also allow users to access applications anonymously. When this access is combined with other authentication methods, the anonymous access applications will be shown along with a 'Sign in' link for users to enter credentials.
All these methods will be enabled and configured in the Thinfinity VirtualUI Server Manager: choose the methods in the 'Authentication' tab and configure the mapping in the 'Mappings' subtab.
Read more:
Windows Logon means that the end-user will have to enter Windows Activate Directory credentials in order to gain access to a set of applications defined in Thinfinity VirtualUI.
The profiles matching the credentials provided in their the 'Permissions' tab will be the profiles shown to the authenticated user, along with those with the 'Allow Anonymous Access' option checked in their 'Permissions' tab
Windows Logon is enabled by default in the 'Authentication' tab of the Thinfinity VirtualUI Server Manager. Toggle its availability as an authentication method by checking or unchecking it.
Read more:
RADIUS as an authentication method means that the user will have to enter their RADIUS credentials in order to gain access to a set of applications defined in Thinfinity VirtualUI.
RADIUS can be added in the 'Authentication' tab of the Thinfinity VirtualUI Server Manager. Toggle its availability as an authentication method by checking or unchecking it.
When you add RADIUS as an authentication method you will be required to provide the RADIUS account relevant information.
The user definition is completed through the mapping between the user ID returned by RADIUS and a user registered for this Authentication ID Mask. The RADIUS credentials are mapped to Active Directory Objects in the 'Mappings' tab. Those Active Directory objects should satisfy the permission access rules of the applications that they are expected to get access to.
Read more:
OAuth 2.0 is a standard authentication method used mostly in social web sites. The user will have to enter their OAuth 2.0 (Facebook, Dropbox, LinkedIn, Google or other) credentials in order to gain access to a set of applications defined in Thinfinity VirtualUI.
An OAuth 2.0 authentication method can be added in the 'Authentication' tab of the Thinfinity VirtualUI Server Manager. Toggle their availability as an authentication method by checking or unchecking them.
When you add an OAuth 2.0 method you will be required to provide the relevant information. Check the complete reference in the OAuth 2.0 Authentication Method Settings. This information is also reflected in the OAuth2Models.ini file, distributed with the installation.
The user definition is completed through the mapping between the user ID returned by the selected OAuth 2.0 method (in the examples mentioned it's always the email) and a user registered for this Authentication ID Mask. The OAuth 2.0 method's credentials are mapped to Active Directory Objects in the 'Mappings' tab. Those Active Directory objects should satisfy the permission access rules of the applications that they are expected to get access to.
Read more:
5.8.3.3.1. OAuth2Models.ini
OAuth2Models.ini is a file is distributed with the Thinfinity VirtualUI installation that has all the information of the default available logins:
[Google]
ClientID =
ClientSecret =
AuthorizationParameters = scope=https://www.googleapis.com/auth/userinfo.email&approval_prompt=auto
AuthorizationURL = https://accounts.google.com/o/oauth2/auth
TokenValidationURL = https://accounts.google.com/o/oauth2/token
ProfileValidationURL = https://www.googleapis.com/oauth2/v1/userinfo
UsernameField = email
[Facebook]
ClientID =
ClientSecret =
AuthorizationParameters = scope=email
AuthorizationURL = https://www.facebook.com/dialog/oauth
TokenValidationURL = https://graph.facebook.com/oauth/access_token
ProfileValidationURL = https://graph.facebook.com/me?
UsernameField = email
[LinkedIn]
ClientID =
ClientSecret =
AuthorizationURL = https://www.linkedin.com/uas/oauth2/authorization
AuthorizationParameters = state=HIJK98sDT88jnS23S&scope=r_emailaddress
TokenValidationURL = https://www.linkedin.com/uas/oauth2/accessToken
ProfileValidationURL = https://api.linkedin.com/v1/people/~:(emailAddress)?format=json
UsernameField = emailAddress
[Dropbox]
ClientID =
ClientSecret =
AuthorizationURL = https://www.dropbox.com/1/oauth2/authorize
AuthorizationParameters =
TokenValidationURL = https://api.dropboxapi.com/1/oauth2/token
ProfileValidationURL = https://api.dropboxapi.com/1/account/info
UsernameField = email
Use this file as a template and edit it in order to add new authentication methods or ask your authentication provider for different data.
Read more:
5.8.3.3.2. CSS for SSO Options
In the login.css file, included in the 'web\css' folder of the Thinfinity VirtualUI installation, you will find the style for the login buttons.
#google { background-color:#4285F4; }
#google .imgbtn { background-image: url(../images/sso/google.png); }
#facebook { background-color:#2f4e9e; }
#facebook .imgbtn { background-image: url(../images/sso/facebook.png); }
#yahoo { background-color:#6839af; }
#yahoo .imgbtn { background-image: url(../images/sso/yahoo.png); background-size: 30px; }
#linkedin { background-color:#00A0DC; }
#linkedin .imgbtn { background-image: url(../images/sso/linkedin.png); }
#dropbox { background-color:#007ee6; }
#dropbox .imgbtn { background-image: url(../images/sso/dropbox.png); background-size: 30px; }
You can change the logo and/or background color of the login buttons for the Oauth 2.0 authentication methods.
Each pair of entries corresponds to one authentication method. The ID (#google, #facebook) must match the Virtual Path established in the Oauth 2.0 Authentication Method Settings. With the installation, these parameters are matching by default, but make sure to change it in both places if you do.
The first line of each pair defines the button color, and the second one the button image.
Read more:
Thinfinity VirtualUI allows you to integrate your own custom authentication method. In order to do this, use the Thinfinity VirtualUI Authentication API.
The External DLL authentication method can be added in the 'Authentication' tab of the Thinfinity VirtualUI Server Manager. Toggle its availability as an authentication method by checking or unchecking it.
When you add an External DLL authentication method you will be required to reference the .dll in the 'External DLL' option. Check the complete reference in the External DLL Authentication Method Settings.
The user definition is completed through the mapping between the user ID returned by the external DLL and an Active Directory Objects mapped for this Authentication ID Mask.
Read more:
5.8.3.4.1. Authentication API
Thinfinity VirtualUI provides you with an API that you can use to develop your own authentication method and integrate it with VirtualUI.
Choose the code sample of your language of preference and add it to your implementation:
Delphi:
function ValidateUser(
const UserName, Password, Metadata: PWideChar;
SecurityRole, WinUser, WinPass, CustomData: PWideChar;
var Handled: Boolean): Cardinal; stdcall;
Input:
Username & Password | The credentials that you are trying to validate with the external authentication |
Metadata | A JSON with the remote browser/user information: URL, IP, Cookie UBRWID and the product's name |
Output:
SecurityRole | Specifies the Windows mapping of the authenticated user (UserName and Password). This SecurityRole can either be a Windows user or group, and it will be used to check which profiles it has access to |
WinUser, WinPass | (optional) Credentials of a mapped Windows user. Will be used to run the application instance. |
CustomData | (optional) Data for passing on to the application |
Handled | Returns whether the login could be handled by the DLL. |
C++:
THINFINITY_API DWORD __stdcall ValidateUser(LPWSTR lpUserName, LPWSTR lpPassword, LPWSTR lpMetadata,
LPWSTR lpSecurityRole, LPWSTR lpWinUser, LPWSTR lpWinPass, LPWSTR lpCustomData,
PBOOLEAN pHandled)
Input:
lpUserName & lpPassword | The credentials that you are trying to validate with the external authentication |
lpMetadata | A JSON with the remote browser/user information: URL, IP, Cookie UBRWID and the product's name |
Output:
lpSecurityRole | Specifies the Windows mapping of the authenticated user (UserName and Password). This SecurityRole can either be a Windows user or group, and it will be used to check which profiles it has access to |
lpWinUser, lpWinPass | (optional) Credentials of a mapped Windows user. Will be used to run the application instance. |
lpCustomData | Data for passing on to the application |
pHandled | Returns whether the login could be handled by the DLL. |
C#:
[DllExport("ValidateUser", CallingConvention = CallingConvention.StdCall)]
[return: MarshalAs(UnmanagedType.I4)]
public static Int32 ValidateUser(
[In, MarshalAs(UnmanagedType.LPWStr)] string lpUserName,
[In, MarshalAs(UnmanagedType.LPWStr)] string lpPassword,
[In, MarshalAs(UnmanagedType.LPWStr)] string lpMetadata,
[In, Out, MarshalAs(UnmanagedType.LPWStr)] StringBuilder lpSecurityRole,
[In, Out, MarshalAs(UnmanagedType.LPWStr)] StringBuilder lpWinUser,
[In, Out, MarshalAs(UnmanagedType.LPWStr)] StringBuilder lpWinPass,
[In, Out, MarshalAs(UnmanagedType.LPWStr)] StringBuilder lpCustomData,
[Out] bool pHandled);
Input:
lpUserName & lpPassword | Specifies the Windows mapping of the authenticated user (UserName and Password). This SecurityRole can either be a Windows user or group, and it will be used to check which profiles it has access to |
lpMetadata | A JSON with the remote browser/user information: URL, IP, Cookie UBRWID and the product's name |
Output:
lpSecurityRole | The authenticated username |
lpWinUser, lpWinPass | (optional) Credentials of a mapped Windows user. Will be used to run the application instance. |
lpCustomData | Data for passing on to the application |
pHandled | Returns whether the login could be handled by the DLL. |
Read more:
In Thinfinity VirtualUI, each application instance may run under a unique Windows User ID or under a shared one. In the first case, the application may access private folders and private registry entries but, as most applications provide their own credential system (usually based on a database), it is a common practice to run the application instance under a single shared Windows User ID. In this case, all application instances share the same user profile’s folders and the same “current user” key in the registry.
Additionally, in both cases, all users may have access to shared folders that it might be desirable to hide from them.
Thinfinity VirtualUI addresses these potential drawbacks by providing the File System and Registry Virtualization feature.
The main purposes of the Registry and File System virtualization are:
· To show only relevant folders.
· To provide private folders based on the application's credential system.
· To provide registry keys based on the application's credential system.
Read more:
File System Virtualization helps developers publish only relevant shared folders and provide authentication-based private folders. Additionally, shared folders can be redirected to safer places in the disk and/or be write protected.
Virtualization involves two steps. The first one is the File System mapping design, when the developer creates the relationship between real paths and the redirected path tree that the end-user will see and access. The second one, the inclusion of the created mapping definition into the application program.
The file system mapping definition is a set of one to one redirection rules that link a real folder to the redirected folder path.
There are two types of redirection:
· Shared: for all connected users. It can be defined as readonly.
· Private: for a single identified user.
The configuration is done through the The File System Virtualization Editor, which will be installed with the Standard or server component installation.
Read more:
In order to add a path in the Virtualization Editor, right click on the main area of the screen and choose 'New Path...'.
This will bring up the 'Edit Directory' dialog.
Field | Description |
Mode | Choose 'Shared' if you want this mapping to apply to all users. Choose 'Private' if you only want this mapping to apply to a single user. |
Read Only | Only available for Shared Mode. Check this option to make the mapped directory read only for the user. |
Directory | Choose the directory you want to show. |
Redirect to | Choose the physical path where the directory contents will be stored during the user session. |
Paths can also be expressed using the environment variables defined in Windows:
%public%, %home%, %documents%, etc
For example, you can redirect %userprofile% to %userprofile%\users as a private redirection; "user1"’s files will therefore be stored in c:\users\username\users\user1
Or you can map c:\temp to %userprofiles%\temp as a shared redirection.
Editing Paths
In order to edit a path, right click on it and choose 'Edit Path'.
You will then be able to edit the path in the 'Edit Directory' dialog.
Deleting Paths
In order to delete a path, right click on it and choose 'Delete Path'.
Read more:
Once you are done adding, editing and/or deleting paths, save this configuration by selecting 'File' - 'Save' in the main menu of the Filesystem Virtualization Editor. This configuration will be stored in a vdir file. The Filesystem Virtualization Editor allows you to create different vdir files to be used in your application.
Read more:
You can test the Filesystem virtualization outside VirtualUI (the virtualization service must be running, though). In order to test the Filesystem virtualization, choose the 'File' - 'Test' option from the main menu. This will bring up the 'Launch Application' dialog:
Field | Description |
User | Type in a testing user name. Later on, you can test using another user and verify that the files stored for each user are isolated. |
Program | Choose a program with which to test the Filesystem virtualization. It has to be a program capable of opening files. |
After selecting a user and a program to test, press the 'Launch' button. When you access the Windows file system through this application, you should only be seeing the mapped directories, by their original names.
Read more:
Registry Virtualization allows developers to store end-user information in the Windows Registry in a secure and isolated way and to provide authentication-based registry entries.
Additionally, shared registry entries can be redirected to safer places in the Windows Registry.
Similarly to File System Virtualization, Registry Virtualization also involves two steps. The first one is the mapping definition, when the developer creates the relationship between an original registry entry and a redirected registry entry. The second one, the inclusion of the created mapping definition into the application program.
The registry mapping definition is a set of one to one redirection rules that link a real entry to the redirected entry.
There are two types of redirection:
· Shared: for all connected users.
· Private: for a single identified user.
Private redirection entries include the identified user ID appended to the redirected entry.
The configuration is done through the Registry Virtualization Editor, which will be installed with the Standard or server component installation.
Read more:
In order to add a registry redirection, right click on one of the Server trees and choose 'Add Redirection'.
This will bring up the 'Edit Key Redirection' dialog:
Field | Description |
Mode | Choose 'Shared' if you want this key redirection to apply to all users. Choose 'Private' if you only want this key redirection to apply to a single user. |
Source | Choose the source registry key you want to redirect. |
Destination | Choose a registry destination key. |
Editing Redirections
In order to edit a key redirection, right click on it and choose 'Edit Redirection'.
You will then be able to edit the redirection in the 'Edit Key Redirection' dialog.
Deleting Redirections
In order to delete a redirection, right click on it and choose 'Delete Redirection'.
Read more:
Once you are done adding, editing and/or deleting redirections, save this configuration by selecting 'File' - 'Save' in the main menu of the Registry Virtualization Editor. This configuration will be stored in a vreg file. The Registry Virtualization Editor allows you to create different vreg files to be used with the product.
Read more:
In order to test the registry virtualization, choose the 'File' - 'Test' option from the main menu. This will bring up the 'Launch Application' dialog:
Field | Description |
User | Type in a testing user name. Later on, you can test using another user and verify that the registry changes stored for each user are isolated. |
Program | Choose a program with which to test the registry virtualization. It has to be a program that uses the registry. |
After selecting a user and a program from the test, press the 'Launch' button. This will open the selected application and create a unique key for the user in the redirected key. All the activity of this application in the registry for the source key will be reflected in the redirected key.
Read more:
In order to apply the virtualization filters created with the Filesystem Virtualization Editor or the Registry Virtualization Editor, you have to add some code to your application.
After virtualui.Start(), load and apply the created filters with the current user credentials
Delphi:
virtualui.RegistryFilter.User := 'user identification';
virtualui.RegistryFilter.CfgFile := 'file.vreg';
virtualui.RegistryFilter.Active := true;
virtualui.FilesystemFilter.User := 'user identification';
virtualui.FilesystemFilter.CfgFile := 'file.vdir';
virtualui.FilesystemFilter.Active := true;
C#:
virtualui.Start();
virtualui.RegistryFilter().User = “user identification”;
virtualui.RegistryFilter().CfgFile = “file.vreg”;
virtualui.RegistryFilter().Active = True;
virtualui.FilesystemFilter().User = “user identification”;
virtualui.FilesystemFilter().CfgFile = “file.vdir”;
virtualui.FilesystemFilter().Active = True;
C++:
virtualui->Start();
virtualui->RegistryFilter()->User = “user identification”;
virtualui->RegistryFilter()->CfgFile = “file.vreg”;
virtualui->RegistryFilter()->Active = True;
virtualui->FilesystemFilter()->User = “user identification”;
virtualui->FilesystemFilter()->CfgFile = “file.vdir”;
virtualui->FilesystemFilter()->Active = True;
In order to disable registry or filesystem filtering, set the Active property to false.
Read more:
If your product qualifies for OEM licensing, we will provide you with a Thinfinity VirtualUI OEM Licensing Library that enables OEM-licensed Companies to create and revoke end-user Thinfinity VirtualUI licenses.
There are two prerequisites:
· The application that uses the OEM Licensing Library (Thinfinity.VirtualUI.OEM.dll) must be digitally signed.
· You must have a valid OEM key.
To get an OEM key, you must provide Cybele Software with a digital certificate's thumbprint. On each licensing request, three parameters will be used to validate the requestor:
· The OEM-licensed Company's e-mail.
· The provided OEM key.
· The digital certificate's fingerprint, taken from the digital certificate that signs the executable making the OEM library call.
The generated OEM key and the digital certificate's thumbprint, along with your customer identification (e-mail), will be used to securely validate the licensing requests your application will make.
Read more:
visThe OEM library provides two functions to create a license and two functions to revoke a license:
· CreateLicenseW (Unicode version) and CreateLicenseA (ANSI version).
· RevokeLicenseW (Unicode version) and RevokeLicenseA (ANSI version).
In order to test the license creation and activation process, you can enable the SandboxMode in the OEM.ini file.
[LICENSE]
SandboxMode = True
The OEM.ini file should be placed in both the bin32 and bin64 paths under the Thinfinity VirtualUI installation folder and in the user's application executable file folder.
The software will first look for the file in the executable's directory (either the application's or any server's). If it doesn't find it there, there are two alternatives:
- For the virtualizer, which is in ibin, it will search in bin64 and, afterwards, in bin32
- For the rest of the cases. it searches for it in the parent directory. That is, if something runs in bin32 or bin64 it can use an oem.ini from their parent directory.
Adding External Methods
In a Delphi program we must first declare the external functions in their ANSI or Unicode version.
ANSI:
function CreateLicenseA(const email, oemkey, customerid: PAnsiChar;
units: DWORD; serial: PAnsiChar): integer; stdcall;
external 'Thinfinity.VirtualUI.OEM.dll';
function RevokeLicenseA(const email, oemkey, serial: PAnsiChar): integer; stdcall;
external 'Thinfinity.VirtualUI.OEM.dll';
Unicode:
function CreateLicenseW(const email, oemkey, customerid: PWideChar;
units: DWORD; serial: PWideChar): integer; stdcall;
external 'Thinfinity.VirtualUI.OEM.dll';
function RevokeLicenseW(const email, oemkey, serial: PWideChar): integer; stdcall;
external 'Thinfinity.VirtualUI.OEM.dll';
In order to access external library functions in a C# program, please declare:
[DllImport("Thinfinity.VirtualUI.OEM.dll",
CallingConvention = CallingConvention.StdCall, CharSet = CharSet.Unicode)]
private static extern int CreateLicenseW(string email, string oemkey,
string customerid, int units, StringBuilder serial);
[DllImport("Thinfinity.VirtualUI.OEM.dll",
CallingConvention = CallingConvention.StdCall, CharSet = CharSet.Unicode)]
private static extern int RevokeLicenseW(string email, string oemkey, string serial);
Read more:
In order to create a new Thinfinity VirtualUI license you must use the corresponding CreateLicense method with the following parameters:
Email | in | OEM-licensed Company´s e-mail |
OEMKey | in | OEM Key. |
CustomerID | in | Arbitrary customer identification for the new license. This can be an e-mail address, a serial number or any other customer identification. |
Units | in | Number of units to enable in this license. Each unit contains a predefined number of concurrent users. If your OEM license has 5 users per unit, and you assign 2 units to the product license, the customer will have 10 concurrent users in total. |
Serial | out | Serial number of the successfully generated license. |
A call to the CreateLicense function will return one of the following error codes:
0 | No error. The "Serial" parameter will contain the generated serial number. |
-1 | General error in license server. |
-2 | Incorrect Email or OEM Key. |
-3 | No more units available. |
-4 | OEM License expired. |
-5 | General error. Cannot create license. |
-10 | Invalid response received from license server. |
-20 | Malformed response received from license server. |
-100 | General error in library. |
-101 | Application invalid: not digitally signed. |
>200 | HTTP status code. |
The following example shows how to create a license using Delphi. Please note that you must replace CreateLicenseW by CreateLicenseA when using ANSI chars.
procedure CreateLicense;
var
result: Integer;
serial: WideString;
begin
serial := StringOfChar(' ', 128);
result := CreateLicenseW(PChar('OEM_EMAIL'), PChar('OEM_KEY'),
PChar('CUSTOMER_ID'), UNIT_COUNT, PWideChar(serial)); // Check result
end;
And this is how you create it using C#:
private void CreateLicense()