| KEYZY C++ Client Library 1.9.0 To develop software that is compiled with a C++ compiler and utilizes the KEYZY service (www.keyzy.io)

Loading...
Searching...
No Matches
Getting started with Keyzy C++ Client Library

# General overview of Keyzy C++ Client Library

The main idea behind the Keyzy C++ Client library is to offer simple methods for activating and validating your product's license management. Additionally, it provides functionality for registering trial licenses.

To activate and validate licenses, you need to utilize the following classes:

- KeyzyLicenseActivator
- KeyzyLicenseValidator

These classes provide the necessary functionality for license activation and validation within the Keyzy C++ Client library.

To deposit licenses from directly client-side, you will need to utilize the LicenseDepositHandler class. This class enables the depositing of licenses from the KEYZY service to the client device.

The KeyzyLicenseActivator class utilizes the ProductData structure as an input argument in its constructor. This allows the system to identify the specific product on the server side for license activation and validation purposes. By providing the relevant product information through the ProductData structure, the system can accurately handle the licensing operations associated with that product.

struct ProductData
{
ProductData() : _useHostIdInOffilneActivation(true) {}
ProductData(std::string appId, std::string apiKey, std::string productCode,
std::string cryptionKey, bool useHostIdInOfflineActivation = true)
: _appId(appId)
, _apiKey(apiKey)
, _productCode(productCode)
, _cryptionKey(cryptionKey)
, _useHostIdInOffilneActivation(useHostIdInOfflineActivation) {}
std::string _appId;
std::string _apiKey;
std::string _productCode;
std::string _cryptionKey; /** Offline activation schema only */
bool _useHostIdInOffilneActivation; /** Default set to "true" */
};

- You can obtain an appId and apiKey pair from the "App Keys" section of the Keyzy Admin Panel at App Keys .
- The product code can be obtained from the "Products" section of the Keyzy Admin Panel at Products .
- If you are using the offline activation/validation schema, you will need to set the _cryptionKey member. You can retrieve this key from the "Products" section of the Keyzy Admin Panel at Products as well.

# Product activation process

The product activation process should be performed only once for each run of the software, usually when users launch your application for the first time. The Keyzy C++ Client Library will internally store the provided data and use it for license validation purposes.

KeyzyLicenseActivator class provides the following methods that should be uses to activate or deactivate a license:

- LicenseStatus activateOnline(const std::string& serialNumber);
- LicenseStatus deactivateOnline();
- LicenseStatus activateSemiOnline(const std::string& serialNumber);
- LicenseStatus activateSemiOnline();
- LicenseStatus deactivateSemiOnline();
- LicenseStatus activateOffline(const std::string& licenseFilePath);
- bool deactivateOffline();

# License validation process

## Online license validation

The online validation process uses a serial number, which can be provided by the user or obtained through the LicenseDepositHandler along with other information such as ProductData or HostId. The information is used to send an HTTP POST request to the KEYZY Service to validate the license.

You need to call the LicenseStatus validateOnline() function from the KeyzyLicenseValidator class. If the serial number is valid, this function will return the value LicenseStatus::VALID.

## Offline license validation

The offline validation process uses a license file provided by the KeyzyLicenseActivator class and does not require an internet connection.

You need to call the LicenseStatus validateOffline() function from KeyzyLicenseValidator class. If the license file is valid, this function will return the value LicenseStatus::VALID.

Semi-Online activation schema uses the offline validation process as well.

## Dealer information

After a successful validateOnline() or validateOffline(), the dealer name is available from KeyzyLicenseValidator for dealer-distributed licenses: getDealerName() returns the dealer's display name (empty string when the license has no dealer). It is populated by the online and offline flows alike.

## All error statuses

> Network-layer statuses. CONNECTION_ERROR and the NETWORK_* statuses below are returned by any method that performs a network request — validateOnline(), activateOnline(), activateSemiOnline(), downloadLicenseFile(), upgradeLicense(), deactivateOnline(), registerTrialLicense(), registerOfflineDistributedLicense() — when the call fails at the network layer (no HTTP response received). They let your application show the end user a specific, actionable message instead of a generic "connection problem."

Status | Explanation
--- | ---
LicenseStatus::EXPIRED | A locally-stored trial has expired. Returned by validateTrialLicense() from KeyzyLicenseValidator. (Client-side)
LicenseStatus::NOT_AUTHORIZED | The appId / apiKey pair is wrong or not authorized. Returned by validateOnline() from KeyzyLicenseValidator. (Server-side)
LicenseStatus::SERIAL_INVALID | The serial number is invalid or not registered. Returned by validateOnline() (KeyzyLicenseValidator) and downloadLicenseFile() (KeyzyLicenseManager). (Server-side)
LicenseStatus::PRODUCT_NOT_EXIST | The product code does not exist. Returned by validateOnline() and downloadLicenseFile(). (Server-side)
LicenseStatus::PRODUCT_NOT_EXIST_FOR_USER | The product code does not exist. Returned by validateOnline() and downloadLicenseFile(). (Server-side)
LicenseStatus::PRODUCT_NOT_ACTIVE | The product exists but is not active. Returned by validateOnline() and downloadLicenseFile(). (Server-side)
LicenseStatus::SKU_NOT_EXIST | The SKU does not exist. Returned by validateOnline() and downloadLicenseFile(). (Server-side)
LicenseStatus::SKU_NOT_ACTIVE | The SKU exists but is not active. Returned by validateOnline() and downloadLicenseFile(). (Server-side)
LicenseStatus::REACHED_MAX_NUMBER_OF_HOST | The license has reached its maximum number of activated devices (hosts). Returned by validateOnline() and downloadLicenseFile(). (Server-side)
LicenseStatus::PRODUCT_NOT_EXIST_FOR_SKU | The product exists but is not part of the SKU linked to this license. Returned by validateOnline() and downloadLicenseFile(). (Server-side)
LicenseStatus::ACTIVATION_DEACTIVATED | This device's activation was deactivated (revoked) on the server. Returned by validateOnline() and downloadLicenseFile(). (Server-side)
LicenseStatus::SUBSCRIPTION_LICENSE_EXPIRED | The subscription license has expired (its end date has passed). Returned by validateOnline() and downloadLicenseFile(). (Server-side)
LicenseStatus::SUBSCRIPTION_LICENSE_NOT_STARTED | The subscription license has not started yet (future start date). Returned by validateOnline() and downloadLicenseFile(). (Server-side)
LicenseStatus::TRIAL_LICENSE_EXPIRED | The server-side trial license has expired. (Distinct from EXPIRED, which is a local trial check.) Returned by validateOnline() and downloadLicenseFile(). (Server-side)
LicenseStatus::TRIAL_LICENSE_NOT_STARTED | The server-side trial license has not started yet (future start date). Returned by validateOnline() and downloadLicenseFile(). (Server-side)
LicenseStatus::CANNOT_KEEP_SERIAL | The SDK could not save the serial number to the device (write failed). Happens locally, before any server contact. (Client-side)
LicenseStatus::CANNOT_KEEP_LICENSE_FILE | The SDK could not save the license file to the device (write failed — often a wrong or unwritable target path). Happens locally. (Client-side)
LicenseStatus::ACTIVATION_DELETED | The activation was successfully removed from the KEYZY servers. A success status, returned by the deactivation flow. (Server-side)
LicenseStatus::CLIENT_SERIAL_DOES_NOT_EXIST | No serial number is stored on the device. (Client-side)
LicenseStatus::CONNECTION_ERROR | Network or firewall error (umbrella). Returned when the connection fails at the network layer and no more specific NETWORK_* status applies.
LicenseStatus::NETWORK_DNS_FAILED | DNS resolution failed (DoH and OS resolver both failed). Likely no internet, or DNS blocked. Ask the user to check their internet connection.
LicenseStatus::NETWORK_REFUSED | TCP connection refused — typically a firewall blocking outbound HTTPS. Ask the user to check their firewall settings.
LicenseStatus::NETWORK_TIMEOUT | Connection timed out. With no HTTP 407, this is usually a firewall blocking outbound HTTPS or a proxy silently dropping the connection. Ask the user to check firewall/proxy settings.
LicenseStatus::NETWORK_TLS_FAILED | TLS handshake failed — corporate SSL inspection, MITM, or a wrong system clock. Ask the user to check the system date/time and any security software.
LicenseStatus::NETWORK_PROXY_REQUIRED | HTTP 407: the network requires an authenticated proxy. Ask the user to contact their IT department to whitelist api.keyzy.io, or to configure proxy credentials at the OS level.
LicenseStatus::NETWORK_HOSTS_TAMPERED | The OS resolver returned a private/loopback IP for api.keyzy.io — a strong sign of hosts-file / DNS manipulation. Advise the user to check their hosts file.
LicenseStatus::TOO_MANY_REQUESTS | The client sent too many requests in a short time and was rate-limited (HTTP 429). (Server-side)
LicenseStatus::NO_ACTIVE_SUBSCRIPTION | The account holder has a subscription problem on the KEYZY side (i.e. your own KEYZY plan is inactive — not the end user's license). (Server-side)
LicenseStatus::CURRENT_LICENSE_DOES_NOT_EXIST | During an upgrade, the source (current) license serial does not exist on the KEYZY servers. (Server-side)
LicenseStatus::UPGRADE_LICENSE_DOES_NOT_EXIST | During an upgrade, the target (upgrade) license serial does not exist on the KEYZY servers. (Server-side)
LicenseStatus::UPGRADE_LICENSE_DOES_NOT_MATCH | The target license is not a valid upgrade path for the current license. (Server-side)
LicenseStatus::ANOTHER_TRIAL_LICENSE_ALREADY_ACTIVATED | A trial has already been activated on this device; a second trial is blocked. (Server-side)
LicenseStatus::SKU_NUMBER_VALIDATION | The sku_number parameter failed validation (HTTP 422). (Server-side)
LicenseStatus::PRODUCT_CODE_VALIDATION | The product_code parameter failed validation (HTTP 422). (Server-side)
LicenseStatus::NAME_VALIDATION | The name parameter failed validation (HTTP 422). (Server-side)
LicenseStatus::EMAIL_VALIDATION | The email parameter failed validation. Rejected server-side (HTTP 422) or client-side (empty email in register* calls). (Server-side & Client-side)
LicenseStatus::SERIAL_VALIDATION | The serial parameter failed validation (HTTP 422 on register). (Server-side)
LicenseStatus::CODE_VALIDATION | The code parameter failed validation (HTTP 422 on register-trial). (Server-side)
LicenseStatus::NO_FREE_LICENSES | No unassigned (free) licenses remain in this SKU's pool to register. Returned by registration flows (including trial registration) when the pool is exhausted — generate more licenses for the SKU. (Server-side)
LicenseStatus::NAME_OR_EMAIL_VALIDATION | Deprecated since the 2026-04-20 server hardening — never produced by the current server. Kept for ABI compatibility.
LicenseStatus::LICENSE_NOT_EXIST_NOT_ASSIGNED_DEALER_ALREADY_DEPOSITED | Register-offline-distributed-license flow: the license does not exist, is not assigned to a dealer, or has already been deposited. (Server-side)
LicenseStatus::INVALID | The license is invalid or could not be verified — generic failure when no more specific status applies.

# Example of register offline distributed license process

Demonstrates depositing an offline license by the client side. It updated the name and the email address of an offline license.

#include <KeyzyLicenseActivator.h>
#include <iostream> // for std::cout
using namespace Keyzy;
int main()
{
ProductData data;
const std::string serialNumber = "****-****-****-****-****";
data._appId = "********";
data._apiKey = "****************************************";
data._productCode = "********-****-****-****-************";
data._cryptionKey = "********************************";
std::unique_ptr<KeyzyLicenseActivator> pLicenseActivator = std::make_unique<KeyzyLicenseActivator>(data);
std::shared_ptr<LicenseDepositHandler> pLicenseDepositHandler = pLicenseActivator->getLicenseDepositHandler();
LicenseStatus registerDistributedLicenseStatus = LicenseStatus::VALID;
registerDistributedLicenseStatus = pLicenseDepositHandler->registerOfflineDistributedLicense(serialNumber, "John Doe", "john@doe.com");
if (registerDistributedLicenseStatus != LicenseStatus::VALID) {
std::cout << errorStatuses(registerDistributedLicenseStatus) << std::endl;
} else {
std::cout << "The license successfully registered.";
}
return 0;
}
// please find errorStatuses() function below of this page

# Example of register trial license process

Demonstrates depositing a trial license from the client side. Sends a trial license request with the provided SKU number to the KEYZY service. If a free trial license is available for the given SKU number, KEYZY deposits the license and responds with the information.

#include <KeyzyLicenseActivator.h>
#include <iostream> // for std::cout
using namespace Keyzy;
int main()
{
ProductData data;
std::string serialNumber = "";
data._appId = "********";
data._apiKey = "****************************************";
data._productCode = "********-****-****-****-************";
data._cryptionKey = "********************************";
std::unique_ptr<KeyzyLicenseActivator> pLicenseActivator = std::make_unique<KeyzyLicenseActivator>(data);
std::shared_ptr<LicenseDepositHandler> pLicenseDepositHandler = pLicenseActivator->getLicenseDepositHandler();
LicenseStatus registerTrialStatus = LicenseStatus::VALID;
LicenseInfo licenseInfo;
registerTrialStatus = pLicenseDepositHandler->registerTrial(licenseInfo, "your-sku-number", "optional-licensee-name");
if (registerTrialStatus != LicenseStatus::VALID) {
std::cout << errorStatuses(registerTrialStatus) << std::endl;
} else {
std::cout << "Start Time : " << licenseInfo._startTime << std::endl;
std::cout << "End Time : " << licenseInfo._endTime << std::endl;
std::cout << "Serial Number : " << licenseInfo._serialNumber << std::endl;
serialNumber = licenseInfo._serialNumber;
}
return 0;
}
// please find errorStatuses() function below of this page

# Example of upgrade license process

The upgradeLicense() method only performs the upgrade on the KEYZY server. It does not activate or validate the new license, and does not store the target serial on the device. To activate the target serial afterward, use one of the activation methods (e.g. activateOnline, activateSemiOnline).

## Upgrade using stored serial (recommended)

If the source serial is already stored on the device (from a previous activation), you only need to provide the target serial:

#include <iostream> // for std::cout
#include <KeyzyLicenseActivator.h>
using namespace Keyzy;
std::string errorStatuses(LicenseStatus status);
int main()
{
// fill ProductData struct to identify specific product
ProductData data;
data._appId = "xxxxxxxx";
data._apiKey = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";
data._productCode = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx";
// Get an activator object
std::unique_ptr<KeyzyLicenseActivator> pLicenseActivator = std::make_unique<KeyzyLicenseActivator>(data);
// Source serial is read from the device automatically
LicenseStatus status = pLicenseActivator->upgradeLicense("TARG-ETSE-RIAL-XXXX-XXXX");
std::cout << "Upgrade License Status: " << errorStatuses(status) << std::endl;
if (status == LicenseStatus::VALID) {
// Activate the target serial on the device
status = pLicenseActivator->activateOnline("TARG-ETSE-RIAL-XXXX-XXXX");
std::cout << "Activation Status: " << errorStatuses(status) << std::endl;
}
}
// please find errorStatuses() function below of this page

## Upgrade with explicit source and target serials

You can also provide both serials explicitly:

#include <iostream> // for std::cout
#include <KeyzyLicenseActivator.h>
using namespace Keyzy;
std::string errorStatuses(LicenseStatus status);
int main()
{
// fill ProductData struct to identify specific product
ProductData data;
data._appId = "xxxxxxxx";
data._apiKey = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";
data._productCode = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx";
// Get an activator object
std::unique_ptr<KeyzyLicenseActivator> pLicenseActivator = std::make_unique<KeyzyLicenseActivator>(data);
LicenseStatus status = pLicenseActivator->upgradeLicense("SOUR-CESE-RIAL-XXXX-XXXX", "TARG-ETSE-RIAL-XXXX-XXXX");
std::cout << "Upgrade License Status: " << errorStatuses(status) << std::endl;
if (status == LicenseStatus::VALID) {
// Activate the target serial on the device
status = pLicenseActivator->activateOnline("TARG-ETSE-RIAL-XXXX-XXXX");
std::cout << "Activation Status: " << errorStatuses(status) << std::endl;
}
}
// please find errorStatuses() function below of this page

# Example of depositing a trial license using the LicenseDepositHandle class

#include <iostream> // for std::cout
#include <KeyzyLicenseActivator.h>
using namespace Keyzy;
std::string errorStatuses(LicenseStatus status);
int main()
{
// fill ProductData struct to identify specific product
ProductData data;
data._appId = "xxxxxxxx";
data._apiKey = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";
data._productCode = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx";
data._cryptionKey = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";
// Get an activator object
std::unique_ptr<KeyzyLicenseActivator> pLicenseActivator =
std::make_unique<KeyzyLicenseActivator>(data);
// Get a deposit handler object
std::shared_ptr<LicenseDepositHandler> pLicenseDepositHandler =
pLicenseActivator->getLicenseDepositHandler();
// Get a status enum object
LicenseStatus registerTrialStatus = LicenseStatus::VALID;
// Get a license info object
LicenseInfo licenseInfo;
// Perform the registration process
registerTrialStatus = pLicenseDepositHandler->registerTrial(licenseInfo, "your-sku-number", "optional-licensee-name", "optional-licensee-email");
// Check the result
if (registerTrialStatus != LicenseStatus::VALID) {
// Error
std::cout << errorStatuses(registerTrialStatus) << std::endl;
} else {
std::cout << "Start Time : " << licenseInfo._startTime << std::endl;
std::cout << "End Time : " << licenseInfo._endTime << std::endl;
std::cout << "Serial Number : " << licenseInfo._serialNumber << std::endl;
// Get the serial number to use in one of the activation process
serialNumber = licenseInfo._serialNumber;
}
}
// please find errorStatuses() function below of this page

# Example of online license validation and activation process

#include <iostream> // for std::cout
#include <KeyzyLicenseActivator.h>
using namespace Keyzy;
std::string errorStatuses(LicenseStatus status);
int main()
{
// fill ProductData struct to identify specific product
ProductData data;
data._appId = "xxxxxxxx";
data._apiKey = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";
data._productCode = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx";
// Get an activator object
std::unique_ptr<KeyzyLicenseActivator> pLicenseActivator =
std::make_unique<KeyzyLicenseActivator>(data);
// Get a validator object
std::shared_ptr<KeyzyLicenseValidator> pLicenseValidator =
pLicenseActivator->getLicenseValidator();
const std::string serialNumber = "XXXX-XXXX-XXXX-XXXX-XXXX";
LicenseStatus status = LicenseStatus::VALID;
if (pLicenseValidator->validateOnline() != LicenseStatus::VALID) {
// bring serial number input window to the user
status = pLicenseActivator->activateOnline(serialNumber);
std::cout << std::endl;
std::cout << "Online Activation Status: " << errorStatuses(status) << std::endl << std::endl;
std::cout << "Licensee's Name: " << pLicenseValidator->getLicenseeName() << std::endl;
std::cout << "Licensee's Email: " << pLicenseValidator->getLicenseeEmail() << std::endl;
std::cout << "Version: " << pLicenseValidator->getVersion() << std::endl;
std::cout << "Sku: " << pLicenseValidator->getSku() << std::endl;
std::cout << "License Type: " << pLicenseValidator->getLicenseType() << std::endl;
std::cout << "Start Time: " << pLicenseValidator->getStartTime() << std::endl;
std::cout << "End Time: " << pLicenseValidator->getEndTime() << std::endl;
std::cout << "Info: " << pLicenseValidator->getInfo() << std::endl;
std::cout << "Dealer Name: " << pLicenseValidator->getDealerName() << std::endl;
} else {
std::cout << "Licensee's Name: " << pLicenseValidator->getLicenseeName() << std::endl;
std::cout << "Licensee's Email: " << pLicenseValidator->getLicenseeEmail() << std::endl;
std::cout << "Version: " << pLicenseValidator->getVersion() << std::endl;
std::cout << "Sku: " << pLicenseValidator->getSku() << std::endl;
std::cout << "License Type: " << pLicenseValidator->getLicenseType() << std::endl;
std::cout << "Start Time: " << pLicenseValidator->getStartTime() << std::endl;
std::cout << "End Time: " << pLicenseValidator->getEndTime() << std::endl;
std::cout << "Info: " << pLicenseValidator->getInfo() << std::endl;
std::cout << "Dealer Name: " << pLicenseValidator->getDealerName() << std::endl;
std::cout << "Online Validation Status: " << errorStatuses(status) << std::endl << std::endl;
}
status = pLicenseActivator->deactivateOnline();
std::cout << "Online Deactivation Status: " << errorStatuses(status) << std::endl << std::endl;
}
// please find errorStatuses() function below of this page

# Example of offline license validation and activation process

#include <iostream> // for std::cout
#include <KeyzyLicenseActivator.h>
#include <KeyzyLicenseValidator.h>
using namespace Keyzy;
std::string errorStatuses(LicenseStatus status);
int main()
{
// fill ProductData struct to identify specific product
ProductData data;
data._appId = "xxxxxxxx";
data._apiKey = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";
data._productCode = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx";
data._cryptionKey = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";
// Get an activator object
std::unique_ptr<KeyzyLicenseActivator> pLicenseActivator =
std::make_unique<KeyzyLicenseActivator>(data);
// Get a validator object
std::shared_ptr<KeyzyLicenseValidator> pLicenseValidator =
pLicenseActivator->getLicenseValidator();
LicenseStatus status = LicenseStatus::VALID;
if (pLicenseValidator->validateOffline() != LicenseStatus::VALID) {
status = pLicenseActivator->activateOffline("/Users/user111/Downloads/license_file.lic");
std::cout << "Offline Activation Status: " << errorStatuses(status) << std::endl << std::endl;
std::cout << "Licensee Name: " << pLicenseValidator->getLicenseeName() << std::endl;
std::cout << "Licensee Email: " << pLicenseValidator->getLicenseeEmail() << std::endl;
std::cout << "Version: " << pLicenseValidator->getVersion() << std::endl;
std::cout << "Sku: " << pLicenseValidator->getSku() << std::endl;
std::cout << "License Type: " << pLicenseValidator->getLicenseType() << std::endl;
std::cout << "Start Time: " << pLicenseValidator->getStartTime() << std::endl;
std::cout << "End Time: " << pLicenseValidator->getEndTime() << std::endl;
std::cout << "Info: " << pLicenseValidator->getInfo() << std::endl;
std::cout << "Dealer Name: " << pLicenseValidator->getDealerName() << std::endl;
} else {
std::cout << "Licensee Name: " << pLicenseValidator->getLicenseeName() << std::endl;
std::cout << "Licensee Email: " << pLicenseValidator->getLicenseeEmail() << std::endl;
std::cout << "Version: " << pLicenseValidator->getVersion() << std::endl;
std::cout << "Sku: " << pLicenseValidator->getSku() << std::endl;
std::cout << "License Type: " << pLicenseValidator->getLicenseType() << std::endl;
std::cout << "Start Time: " << pLicenseValidator->getStartTime() << std::endl;
std::cout << "End Time: " << pLicenseValidator->getEndTime() << std::endl;
std::cout << "Info: " << pLicenseValidator->getInfo() << std::endl;
std::cout << "Dealer Name: " << pLicenseValidator->getDealerName() << std::endl;
}
// This won't deactivate the license in KEYZY servers. Only delete the license file locally.
bool res = pLicenseActivator->deactivateOffline();
if (!res)
status = LicenseStatus::INVALID;
else
status = LicenseStatus::ACTIVATION_DELETED;
std::cout << "Offline Deactivation Status: " << errorStatuses(status) << std::endl << std::endl;
}
// please find errorStatuses() function below of this page

# Full example (Online Activation, Semi-Online Activation, Offline Activation, Trial Due Date Activation)

#include <KeyzyLicenseActivator.h>
#include <KeyzyLicenseValidator.h>
#include <iostream> // for std::cout
using namespace Keyzy;
std::string errorStatuses(LicenseStatus status);
int main()
{
ProductData data;
data._appId = "xxxxxxxx";
data._apiKey = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";
data._productCode = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx";
data._cryptionKey = "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX";
std::unique_ptr<KeyzyLicenseActivator> pLicenseActivator = std::make_unique<KeyzyLicenseActivator>(data);
std::shared_ptr<KeyzyLicenseValidator> pLicenseValidator = pLicenseActivator->getLicenseValidator();
LicenseStatus status = LicenseStatus::VALID;
// bring serial number input window to the user
std::string serialNumber = "";
// ------
// online
// ------
if (pLicenseValidator->validateOnline() != LicenseStatus::VALID) {
// bring serial number input window to the user
status = pLicenseActivator->activateOnline(serialNumber);
std::cout << std::endl;
std::cout << "Online Activation Status: " << errorStatuses(status) << std::endl << std::endl;
std::cout << "Licensee's Name: " << pLicenseValidator->getLicenseeName() << std::endl;
std::cout << "Licensee's Email: " << pLicenseValidator->getLicenseeEmail() << std::endl;
std::cout << "Version: " << pLicenseValidator->getVersion() << std::endl;
std::cout << "Sku: " << pLicenseValidator->getSku() << std::endl;
std::cout << "License Type: " << pLicenseValidator->getLicenseType() << std::endl;
std::cout << "Start Time: " << pLicenseValidator->getStartTime() << std::endl;
std::cout << "End Time: " << pLicenseValidator->getEndTime() << std::endl;
std::cout << "Info: " << pLicenseValidator->getInfo() << std::endl;
std::cout << "Dealer Name: " << pLicenseValidator->getDealerName() << std::endl;
} else {
std::cout << "Licensee's Name: " << pLicenseValidator->getLicenseeName() << std::endl;
std::cout << "Licensee's Email: " << pLicenseValidator->getLicenseeEmail() << std::endl;
std::cout << "Version: " << pLicenseValidator->getVersion() << std::endl;
std::cout << "Sku: " << pLicenseValidator->getSku() << std::endl;
std::cout << "License Type: " << pLicenseValidator->getLicenseType() << std::endl;
std::cout << "Start Time: " << pLicenseValidator->getStartTime() << std::endl;
std::cout << "End Time: " << pLicenseValidator->getEndTime() << std::endl;
std::cout << "Info: " << pLicenseValidator->getInfo() << std::endl;
std::cout << "Dealer Name: " << pLicenseValidator->getDealerName() << std::endl;
std::cout << "Online Validation Status: " << errorStatuses(status) << std::endl << std::endl;
}
status = pLicenseActivator->deactivateOnline();
std::cout << "Online Deactivation Status: " << errorStatuses(status) << std::endl << std::endl;
// -----------
// semi-online
// -----------
if (pLicenseValidator->validateOffline() != LicenseStatus::VALID) {
status = pLicenseActivator->activateSemiOnline(serialNumber);
std::cout << "Semi Online Activation Status: " << errorStatuses(status) << std::endl << std::endl;
std::cout << "Version: " << pLicenseValidator->getVersion() << std::endl;
std::cout << "Sku: " << pLicenseValidator->getSku() << std::endl;
std::cout << "License Type: " << pLicenseValidator->getLicenseType() << std::endl;
std::cout << "Start Time: " << pLicenseValidator->getStartTime() << std::endl;
std::cout << "End Time: " << pLicenseValidator->getEndTime() << std::endl;
std::cout << "Info: " << pLicenseValidator->getInfo() << std::endl;
std::cout << "Dealer Name: " << pLicenseValidator->getDealerName() << std::endl;
}
if (status == LicenseStatus::VALID) {
// You may need to use semi-online activation without giving a serial number.
// First two cases are:
// 1- You may choose to renew weekly the offline license of the users with Semi Online activation.
// You don't want to ask the serial number again and again.
// 2- You may set Offline License Life (recommended) to 30 days. After 30 days, the offline license
// will be INVALID. Then you will need to activate it again without a serial number.
status = pLicenseActivator->activateSemiOnline();
std::cout << "Semi Online Renew Activation Status: " << errorStatuses(status) << std::endl << std::endl;
std::cout << "Version: " << pLicenseValidator->getVersion() << std::endl;
std::cout << "Licensee's Name: " << pLicenseValidator->getLicenseeName() << std::endl;
std::cout << "Licensee's Email: " << pLicenseValidator->getLicenseeEmail() << std::endl;
std::cout << "Sku: " << pLicenseValidator->getSku() << std::endl;
std::cout << "License Type: " << pLicenseValidator->getLicenseType() << std::endl;
std::cout << "Start Time: " << pLicenseValidator->getStartTime() << std::endl;
std::cout << "End Time: " << pLicenseValidator->getEndTime() << std::endl;
std::cout << "Info: " << pLicenseValidator->getInfo() << std::endl;
std::cout << "Dealer Name: " << pLicenseValidator->getDealerName() << std::endl;
}
status = pLicenseActivator->deactivateSemiOnline();
std::cout << "Semi Online Deactivation Status: " << errorStatuses(status) << std::endl << std::endl;
// Now, the license status is not valid. The license is deleted from the device.
// If you try to use semi online activation without a serial number. You’ll have an error.
if (status != LicenseStatus::VALID) {
status = pLicenseActivator->activateSemiOnline();
std::cout << "Semi Online Renew Activation Status 2 (Error expected): " << errorStatuses(status) << std::endl << std::endl;
}
// -------
// offline
// -------
if (pLicenseValidator->validateOffline() != LicenseStatus::VALID) {
status = pLicenseActivator->activateOffline("/Users/user111/Downloads/license_file.lic");
std::cout << "Offline Activation Status: " << errorStatuses(status) << std::endl << std::endl;
std::cout << "Licensee Name: " << pLicenseValidator->getLicenseeName() << std::endl;
std::cout << "Licensee Email: " << pLicenseValidator->getLicenseeEmail() << std::endl;
std::cout << "Version: " << pLicenseValidator->getVersion() << std::endl;
std::cout << "Sku: " << pLicenseValidator->getSku() << std::endl;
std::cout << "License Type: " << pLicenseValidator->getLicenseType() << std::endl;
std::cout << "Start Time: " << pLicenseValidator->getStartTime() << std::endl;
std::cout << "End Time: " << pLicenseValidator->getEndTime() << std::endl;
std::cout << "Info: " << pLicenseValidator->getInfo() << std::endl;
std::cout << "Dealer Name: " << pLicenseValidator->getDealerName() << std::endl;
} else {
std::cout << "Licensee Name: " << pLicenseValidator->getLicenseeName() << std::endl;
std::cout << "Licensee Email: " << pLicenseValidator->getLicenseeEmail() << std::endl;
std::cout << "Version: " << pLicenseValidator->getVersion() << std::endl;
std::cout << "Sku: " << pLicenseValidator->getSku() << std::endl;
std::cout << "License Type: " << pLicenseValidator->getLicenseType() << std::endl;
std::cout << "Start Time: " << pLicenseValidator->getStartTime() << std::endl;
std::cout << "End Time: " << pLicenseValidator->getEndTime() << std::endl;
std::cout << "Info: " << pLicenseValidator->getInfo() << std::endl;
std::cout << "Dealer Name: " << pLicenseValidator->getDealerName() << std::endl;
}
bool res = pLicenseActivator->deactivateOffline();
if (!res)
status = LicenseStatus::INVALID;
else
status = LicenseStatus::ACTIVATION_DELETED;
std::cout << "Offline Deactivation Status: " << errorStatuses(status) << std::endl << std::endl;
// ------------
// client-trial
// This trial license only stored in the client side
// There is no relationship with KEYZY servers
// ------------
if (pLicenseValidator->validateTrialLicense() != LicenseStatus::VALID) {
std::time_t t = std::time(0); // get time now
std::tm trialExpiryTime = *std::localtime(&t); // get local time
trialExpiryTime.tm_hour += 24 * 30; // add 30 days
mktime(&trialExpiryTime);
status = pLicenseActivator->activateClientTrial(trialExpiryTime);
std::cout << "Client Trial Activation Status: " << errorStatuses(status) << std::endl << std::endl;
}
bool resTrial = pLicenseActivator->deactivateClientTrial();
std::cout << "Client Trial Deactivation Status: " << resTrial << std::endl << std::endl;
}
// please find errorStatuses() function below of this page

# Error function

Find the error function for all examples following.

std::string errorStatuses(LicenseStatus status)
{
switch(status) {
case LicenseStatus::EXPIRED:
return "Expired";
case LicenseStatus::INVALID:
return "Invalid";
case LicenseStatus::NOT_AUTHORIZED:
return "Not authorized";
case LicenseStatus::SERIAL_INVALID:
return "Serial invalid";
case LicenseStatus::PRODUCT_NOT_EXIST:
return "Product does not exist";
case LicenseStatus::PRODUCT_NOT_EXIST_FOR_USER:
return "Product does not exist";
case LicenseStatus::PRODUCT_NOT_ACTIVE:
return "Product is not active";
case LicenseStatus::SKU_NOT_EXIST:
return "SKU does not exist";
case LicenseStatus::SKU_NOT_ACTIVE:
return "SKU is not active";
case LicenseStatus::REACHED_MAX_NUMBER_OF_HOST:
return "Reached maximum number of host";
case LicenseStatus::PRODUCT_NOT_EXIST_FOR_SKU:
return "Product does not exist for this SKU";
case LicenseStatus::ACTIVATION_DEACTIVATED:
return "Activation is deactivated";
case LicenseStatus::SUBSCRIPTION_LICENSE_EXPIRED:
return "Subscription license expired!";
case LicenseStatus::SUBSCRIPTION_LICENSE_NOT_STARTED:
return "Subscription license not started!";
case LicenseStatus::TRIAL_LICENSE_EXPIRED:
return "Trial license expired!";
case LicenseStatus::TRIAL_LICENSE_NOT_STARTED:
return "Trial license not started!";
case LicenseStatus::CANNOT_KEEP_SERIAL:
return "Cannot keep serial!";
case LicenseStatus::CANNOT_KEEP_LICENSE_FILE:
return "Cannot keep license file!";
case LicenseStatus::ACTIVATION_DELETED:
return "Activation deleted!";
case LicenseStatus::CLIENT_SERIAL_DOES_NOT_EXIST:
return "Client serial does not exist!";
case LicenseStatus::CONNECTION_ERROR:
return "Connection Error!";
case LicenseStatus::NETWORK_DNS_FAILED:
return "Cannot reach the server. Please check your internet connection.";
case LicenseStatus::NETWORK_REFUSED:
return "Connection refused. Please check your firewall settings.";
case LicenseStatus::NETWORK_TIMEOUT:
return "Connection timed out. Please check your firewall or proxy settings.";
case LicenseStatus::NETWORK_TLS_FAILED:
return "Secure connection failed. Please check your system date/time and security software.";
case LicenseStatus::NETWORK_PROXY_REQUIRED:
return "A proxy is required. Please ask your IT to whitelist api.keyzy.io or configure proxy credentials.";
case LicenseStatus::NETWORK_HOSTS_TAMPERED:
return "Cannot verify the server address. Please check your hosts file.";
case LicenseStatus::TOO_MANY_REQUESTS:
return "Too Many Requests!";
case LicenseStatus::NO_ACTIVE_SUBSCRIPTION:
return "No Active Subscription!";
case LicenseStatus::CURRENT_LICENSE_DOES_NOT_EXIST:
return "Current license does not exist!";
case LicenseStatus::UPGRADE_LICENSE_DOES_NOT_EXIST:
return "Upgrade license does not exist!";
case LicenseStatus::UPGRADE_LICENSE_DOES_NOT_MATCH:
return "Upgrade license does not match for upgrade with current license!";
case LicenseStatus::ANOTHER_TRIAL_LICENSE_ALREADY_ACTIVATED:
return "Another trial license has already been activated on this device!";
case LicenseStatus::SKU_NUMBER_VALIDATION:
return "sku_number parameter cannot be validated!";
case LicenseStatus::PRODUCT_CODE_VALIDATION:
return "product_code parameter cannot be validated!";
case LicenseStatus::NAME_VALIDATION:
return "name parameter cannot be validated!";
case LicenseStatus::EMAIL_VALIDATION:
return "email parameter cannot be validated!";
case LicenseStatus::SERIAL_VALIDATION:
return "serial parameter cannot be validated!";
case LicenseStatus::CODE_VALIDATION:
return "code parameter cannot be validated!";
case LicenseStatus::NO_FREE_LICENSES:
return "You do not have any free licenses for this sku. Please generate new licenses for this sku!";
case LicenseStatus::NAME_OR_EMAIL_VALIDATION:
return "Either the name or email filed must be filled!";
case LicenseStatus::LICENSE_NOT_EXIST_NOT_ASSIGNED_DEALER_ALREADY_DEPOSITED:
return "The license does not exist or is not assigned to a dealer or is already deposited!";
case LicenseStatus::VALID: // Just in case
return "Valid";
default:
return "Unknown";
}
}