This SDK is a commercial product. You have 30 days to test it for free, with every feature available. After that a license key is needed.

## Trial period

The trial starts the first time the library is used on a machine, and lasts 30 days. Nothing has to be registered, and no feature is disabled during that time.

`AbbController.LicenseInfo` tells you where you stand. `EvaluationDaysLeft` counts the days remaining, and becomes negative once the trial has expired.

## Register a license

Buy a license ([see pricing](/order)) and we send you a license key with the name of your organization. Pass both to the static method `RegisterLicense` of `AbbController`, once, before the first connection.

**C# : License**
```csharp
using UnderAutomation.ABB;
using UnderAutomation.ABB.License;

public class License
{
    static void Main()
    {
        /**/
        // Register the license once, before the first connection
        AbbController.RegisterLicense("YourCompanyName", "YOUR_LICENSE_KEY");

        LicenseInfo info = AbbController.LicenseInfo;

        // Number of trial days remaining, null when the product is licensed
        int? evaluationDaysLeft = info.EvaluationDaysLeft;

        bool licenseValid = info.State == LicenseState.Licensed;

        // A readable description of the current state
        Console.WriteLine(info);
        /**/

        /**/
        // Check the license once at startup, rather than catching the exception
        // on every connection
        if (!AbbController.LicenseInfo.IsLicensed)
        {
            Console.WriteLine(AbbController.LicenseInfo);
            return;
        }
        /**/

        /**/
        // Without a key the library runs in its 30 day trial period.
        // Connect throws an InvalidLicenseException once the trial has expired.
        try
        {
            AbbController robot = new AbbController();
            robot.Connect("192.168.0.1");
        }
        catch (InvalidLicenseException ex)
        {
            Console.WriteLine(ex.Message);
            Console.WriteLine(ex.LicenseInfo.State);
        }
        /**/
    }
}
```

**Python : License**
```python
from underautomation.abb.abb_controller import AbbController
from underautomation.abb.license.license_state import LicenseState
from UnderAutomation.ABB.License import InvalidLicenseException

##
# Register the license once, before the first connection
AbbController.register_license("YourCompanyName", "YOUR_LICENSE_KEY")

robot = AbbController()
info = robot.license_info

# Number of trial days remaining, None when the product is licensed
evaluation_days_left = info.evaluation_days_left

license_valid = info.state == LicenseState.Licensed

# A readable description of the current state
print(info)
##

##
# Check the license once at startup, rather than catching the exception
# on every connection
if not info.is_licensed:
    print(info)
    raise SystemExit(0)
##

##
# Without a key the library runs in its 30 day trial period.
# connect raises an InvalidLicenseException once the trial has expired.
try:
    robot = AbbController()
    robot.connect("192.168.0.1")
except InvalidLicenseException as ex:
    # The exception comes from the .NET runtime, so its members keep their original names
    print(ex.Message)
    print(ex.LicenseInfo.State)
##
```

**Matlab : License**
```matlab
NET.addAssembly(fullfile(pwd, 'net48', 'UnderAutomation.ABB.dll'));
import UnderAutomation.ABB.*

%%
% Register the license once, before the first connection
AbbController.RegisterLicense('YourCompanyName', 'YOUR_LICENSE_KEY');

info = AbbController.LicenseInfo;

% A readable description of the current state
disp(char(info.ToString()));

% Check the license once at startup
if ~info.IsLicensed
    error(char(info.ToString()));
end
%%
```

The registration is static: it applies to the whole application, not to one `AbbController` instance. You can register a key even after the trial period has ended.

`AbbController.LicenseInfo` returns the current state at any moment. Its `ToString()` gives a readable description, which is what an `InvalidLicenseException` carries as its message.

## License states

| `LicenseState`      | Meaning                                                                    | The library runs |
| ------------------- | -------------------------------------------------------------------------- | ---------------- |
| `None`              | No key has been registered and no trial could be started                   | no               |
| `Trial`             | The 30 day trial period is running                                         | yes              |
| `ExtraTrial`        | An extended trial key has been registered                                  | yes              |
| `Expired`           | The trial period is over                                                   | no               |
| `Invalid`           | The organization name and the key do not go together                       | no               |
| `MaintenanceNeeded` | The key is valid, but this release is newer than the maintenance it covers | no               |
| `Licensed`          | The product is licensed                                                    | yes              |

`IsLicensed` is true for `Licensed`, `Trial` and `ExtraTrial`.

A license includes a number of maintenance years. `MaintenanceExpirationDate` is the date up to which a release can be used with that key. Versions released after that date report `MaintenanceNeeded`. The versions you already use keep working, a new key is only needed to move to a newer release.

## What happens without a valid license

`AbbController.Connect` checks the license before opening the connection and throws an `InvalidLicenseException` when it is not valid. The exception message says why, and its `LicenseInfo` property carries the full state.

Test `IsLicensed` at startup rather than catching the exception on every connection, as the code above does.

## Source license

The Standard and Pro licenses deliver the obfuscated DLL. The Source license also delivers the full C# code of the library and its Visual Studio solution, to change and build it yourself, within the limits of the [license agreement](/abb/eula).

## Try it in the demo application

Everything on this page can be tried without writing code, in the **License** page of the [demo application](/abb/documentation/demo-app).

![License page of the ABB SDK demo application](/abb/WinformsScreenshots/License.jpg)

Its C# source is [LicenseControl.cs](https://github.com/underautomation/ABB.NET/blob/main/UnderAutomation.ABB.Showcase.Forms/Components/LicenseControl.cs).

## API reference

**Members of License.LicenseInfo**
```csharp
public sealed class LicenseInfo {
    // Create a new LicenseInfo instance to retrieve informations about a pair of identifier/key
    // This class should not be used to register your product. Please use static function RegisterLicense to specify your license.
    public LicenseInfo(string licenseIdentifier, string licenseKey)

    // Remaining days of the trial period. Null if the product is licensed. It could be negative if the trial period is ended since several days.
    public int? EvaluationDaysLeft { get; }

    // The date the trial period starts. If the product is licensed, the date of the library first use.
    public DateTime EvaluationStartDate { get; }

    // True if the license state is Licensed, Trial or ExtraTrial ; false otherwise
    public bool IsLicensed { get; }

    // The date you get the license
    public DateTime? LicenseIssuedDate { get; }

    // The license key supplied by UnderAutomation (null for trial period)
    public string LicenseKey { get; }

    // Name of your organisation
    public string Licensee { get; }

    // The date your maintenance contract end and you no longer can use this license with newer versions.
    public DateTime? MaintenanceExpirationDate { get; }

    // Number of maintenance years included in your license
    public int MaintenanceYears { get; }

    // Commercial name of this .NET Software library
    public string Product { get; }

    // The date this version of the product was released.
    public DateTime ProductReleaseDate { get; }

    // The current license state
    public LicenseState State { get; }

    // A human description of the license
    public override string ToString()

    // The date the product will expire. Null if the product is licensed.
    public DateTime? TrialPeriodExpirationDate { get; }
}
```

**Members of License.LicenseState**
```csharp
public enum LicenseState {
    // The trial period as expired, you no more can use the library
    Expired = 3

    // The library is in an extra trial period, you can use the library
    ExtraTrial = 2

    // The pair License Identifier and License Key are incompatible, you cannot use the library
    Invalid = 0

    // Congratulations, the library is licensed.
    Licensed = 5

    // Your license does not allow you to use such a recent release. Please buy maintenance to use this version
    MaintenanceNeeded = 4

    // No license has been provided
    None = -1

    // The library is in a trial period, you can use the library
    Trial = 1
}
```

**Members of License.InvalidLicenseException**
```csharp
public class InvalidLicenseException : Exception, ISerializable {
    // The license that causes this exception
    public LicenseInfo LicenseInfo { get; }
}
```