license.h

#ifndef FACE_SDK_LICENSE_H
#define FACE_SDK_LICENSE_H

#include <face_sdk_base/export.h>
#include <face_sdk_base/data_container.h>

#include <memory>
#include <vector>
#include <functional>

#define FACE_SDK_REMOTE_LICENSE_DEFAULT "FACE_SDK_REMOTE_LICENSE_DEFAULT"
#define FACE_SDK_REMOTE_LICENSE_TOKEN "FACE_SDK_REMOTE_LICENSE_TOKEN"
#define FACE_SDK_REMOTE_LICENSE_TIME_BOUND "FACE_SDK_REMOTE_LICENSE_TIME_BOUND"

namespace face_sdk
{
    class FACE_SDK_EXPORT license
    {
    public:
        virtual ~license() = default;

        virtual std::string get_license_info() const = 0;

        virtual bool is_time_bound() const = 0;
    };

    std::shared_ptr<face_sdk::license> FACE_SDK_EXPORT load_licence_from_file();

    std::shared_ptr<face_sdk::license> FACE_SDK_EXPORT load_licence_from_file(const std::string &license_file);

    std::shared_ptr<face_sdk::license> FACE_SDK_EXPORT load_licence_from_data(const std::vector<uint8_t> &data);

    std::vector<uint8_t> FACE_SDK_EXPORT generate_license_request(std::vector<uint32_t> gpu_ids = std::vector<uint32_t>());


    std::vector<uint8_t> FACE_SDK_EXPORT generate_time_bound_license_request();

    class FACE_SDK_EXPORT license_callback
    {
    public:
        virtual ~license_callback() = default;

        virtual std::vector<uint8_t> on_load() = 0;

        virtual void on_updated(const std::vector<uint8_t> &license_data) = 0;
    };

    class FACE_SDK_EXPORT remote_license : public face_sdk::license
    {
    public:
        ~remote_license() override = default;

        virtual void force_update() = 0;
    };

    std::shared_ptr<face_sdk::remote_license> FACE_SDK_EXPORT make_remote_license(const std::string &token);

    std::shared_ptr<face_sdk::remote_license> FACE_SDK_EXPORT make_remote_license(const std::string &token,
                                                                                  const std::string &filename);

    std::shared_ptr<face_sdk::remote_license> FACE_SDK_EXPORT make_remote_license(const std::string &token,
                                                                                  const std::shared_ptr<face_sdk::license_callback> &callback);

    std::shared_ptr<face_sdk::remote_license> FACE_SDK_EXPORT make_remote_license(const std::string &token,
                                                                                  const std::vector<uint8_t> &request,
                                                                                  const std::shared_ptr<face_sdk::license_callback> &callback);


    std::shared_ptr<face_sdk::remote_license> FACE_SDK_EXPORT make_remote_license(const std::string &token, 
                                                                                  bool time_bound);

    std::shared_ptr<face_sdk::remote_license> FACE_SDK_EXPORT make_remote_license(const std::string &token,
                                                                                  const std::string &filename,
                                                                                  bool time_bound);

    std::shared_ptr<face_sdk::remote_license> FACE_SDK_EXPORT make_remote_license(const std::string &token,
                                                                                  const std::shared_ptr<face_sdk::license_callback> &callback,
                                                                                  bool time_bound);

    std::shared_ptr<face_sdk::remote_license> FACE_SDK_EXPORT make_remote_license(const std::string &token,
                                                                                  const std::vector<uint8_t> &request,
                                                                                  const std::shared_ptr<face_sdk::license_callback> &callback,
                                                                                  bool time_bound);

    std::shared_ptr<face_sdk::license> FACE_SDK_EXPORT make_default_license();

}

#endif