code_device/hgdriver/hgdev/scanner_manager.cpp

#include "scanner_manager.h"

#include "../../sdk/hginclude/utils.h"
#include <lang/app_language.h>
#include <iostream>
#include <fstream>
#include <string.h>
#include "../../../sdk/include/huagao/brand.h"

#include "user-opt/user.h"
#include "user-opt/offline_opt.h"
#include <sane_opt_json/device_opt.h>
#include <imgprc/imgprc_mgr.h>


#if !defined(WIN32) && !defined(_WIN64)
#endif

// kinds of scanners ...
#define SCAN_PTR(ptr)   ((hg_scanner*)ptr)

#include "hg_scanner_200.h"
#include "hg_scanner_239.h"
#include "hg_scanner_300.h"
#include "hg_scanner_302.h"


/// <summary>
/// supporting devices :
/// 
#define GET_LANG(str,b)              from_default_language(str,b)
static struct
{
    uint16_t    vid;        // vendor ID
    uint16_t    pid;        // product ID
    std::string name;       // product name - type
    std::string family;     // product model - family. In the TWAIN protocol, grouping is based on this value
    std::string rsc;        // USB resource, version-addr. e.g. "USB2.0-1"
    hg_scanner* (* create_scanner)(const char*/*name*/, const char*/*model*/, usb_io*, scanner_handle*);
}
g_supporting_devices[] = {
#ifdef OEM_LISICHENG
                           {0x31c9, 0x8200, PRODUCT_NAME_LSC_G42, PRODUCT_FAMILY_LSC_G42, "", &hg_scanner_mgr::create_scanner_g300}
                         , {0x31c9, 0x8420, PRODUCT_NAME_LSC_G42, PRODUCT_FAMILY_LSC_G42, "", &hg_scanner_mgr::create_scanner_g300}
                         , {0x31c9, 0x8429, PRODUCT_NAME_LSC_G42, PRODUCT_FAMILY_LSC_G42, "", &hg_scanner_mgr::create_scanner_empty}
                         , {0x31c9, 0x8520, PRODUCT_NAME_LSC_G52, PRODUCT_FAMILY_LSC_G52, "", &hg_scanner_mgr::create_scanner_g400}
                         , {0x31c9, 0x8529, PRODUCT_NAME_LSC_G52, PRODUCT_FAMILY_LSC_G52, "", &hg_scanner_mgr::create_scanner_g439}
                         , {0x31c9, 0x8620, PRODUCT_NAME_LSC_G62, PRODUCT_FAMILY_LSC_G62, "", &hg_scanner_mgr::create_scanner_g100}
                         , {0x31c9, 0x8629, PRODUCT_NAME_LSC_G62, PRODUCT_FAMILY_LSC_G62, "", &hg_scanner_mgr::create_scanner_g239}
                         , {0x31c9, 0x8730, PRODUCT_NAME_LSC_G73, PRODUCT_FAMILY_LSC_G73, "", &hg_scanner_mgr::create_scanner_g100}
                         , {0x31c9, 0x8739, PRODUCT_NAME_LSC_G73, PRODUCT_FAMILY_LSC_G73, "", &hg_scanner_mgr::create_scanner_g239}
                         
#elif defined(OEM_HANWANG)
                           {0x2903, 0x1000, PRODUCT_NAME_HW_G1000, PRODUCT_FAMILY_HW_G1000, "",& hg_scanner_mgr::create_scanner_g300}   // "HW-1060A" 
                         , {0x2903, 0x1002, PRODUCT_NAME_HW_G1002, PRODUCT_FAMILY_HW_G1002, "", &hg_scanner_mgr::create_scanner_g302}   // "HW-1060A" 
                         , {0x2903, 0x7000, PRODUCT_NAME_HW_G7000, PRODUCT_FAMILY_HW_G7000, "", &hg_scanner_mgr::create_scanner_g400}   // "HW-74x0WA"
                         , {0x2903, 0x7002, PRODUCT_NAME_HW_G7002, PRODUCT_FAMILY_HW_G7002, "", &hg_scanner_mgr::create_scanner_g402}   // "HW-7002"  
                         , {0x2903, 0x7039, PRODUCT_NAME_HW_G7039, PRODUCT_FAMILY_HW_G7039, "", &hg_scanner_mgr::create_scanner_g439}   // "HW-7039F" 
                         , {0x2903, 0x8000, PRODUCT_NAME_HW_G8000, PRODUCT_FAMILY_HW_G8000, "", &hg_scanner_mgr::create_scanner_g239}   // "HW-8090F" 
                         , {0x2903, 0x9000, PRODUCT_NAME_HW_G9000, PRODUCT_FAMILY_HW_G9000, "", &hg_scanner_mgr::create_scanner_g239}   // "HW-9110E" 
#elif defined(OEM_CANGTIAN)
                           {0x3072, 0x0303, PRODUCT_NAME_CT_6005, PRODUCT_FAMILY_CT_6005, "", &hg_scanner_mgr::create_scanner_g300}
                         , {0x3072, 0x0403, PRODUCT_NAME_CT_138, PRODUCT_FAMILY_CT_138, "", &hg_scanner_mgr::create_scanner_g439}
                         , {0x3072, 0x0138, PRODUCT_NAME_CT_138, PRODUCT_FAMILY_CT_138, "", &hg_scanner_mgr::create_scanner_g239}
                         , {0x3072, 0x0238, PRODUCT_NAME_CT_138, PRODUCT_FAMILY_CT_138, "", &hg_scanner_mgr::create_scanner_g239}

                         , {0x3308, 0x0138, PRODUCT_NAME_CT_138, PRODUCT_FAMILY_CT_138, "", &hg_scanner_mgr::create_scanner_g239}
                         , {0x3308, 0x0238, PRODUCT_NAME_CT_238, PRODUCT_FAMILY_CT_238, "", &hg_scanner_mgr::create_scanner_g239}
                         , {0x3308, 0x6005, PRODUCT_NAME_CT_6005, PRODUCT_FAMILY_CT_6005, "", &hg_scanner_mgr::create_scanner_g300}
                         , {0x3308, 0x6006, PRODUCT_NAME_CT_6006, PRODUCT_FAMILY_CT_6006, "", &hg_scanner_mgr::create_scanner_g239}
                        

                         
#elif defined(OEM_ZHONGJING)
                           {0X05DA, 0x9220, PRODUCT_NAME_ZJ_9200, PRODUCT_FAMILY_ZJ_9200, "",& hg_scanner_mgr::create_scanner_g439}
#elif defined(OEM_ZIGUANG)
                           {0x32ec, 0x0200, PRODUCT_NAME_ZG_200, PRODUCT_FAMILY_ZG_200, "", & hg_scanner_mgr::create_scanner_g239}
                         , {0x32ec, 0x0210, PRODUCT_NAME_ZG_210, PRODUCT_FAMILY_ZG_210, "", &hg_scanner_mgr::create_scanner_g402}
 #elif defined(OEM_NEUTRAL)
                           {0x3072, 0x100, PRODUCT_NAME_NEU_100, PRODUCT_FAMILY_NEU_100, "",& hg_scanner_mgr::create_scanner_g100}
                         , {0x3072, 0x139, PRODUCT_NAME_NEU_100, PRODUCT_FAMILY_NEU_100, "",&hg_scanner_mgr::create_scanner_g239}
                         , {0x3072, 0x200, PRODUCT_NAME_NEU_200, PRODUCT_FAMILY_NEU_200, "",&hg_scanner_mgr::create_scanner_g100}
                         , {0x3072, 0x239, PRODUCT_NAME_NEU_200, PRODUCT_FAMILY_NEU_200, "",&hg_scanner_mgr::create_scanner_g239}
                         , {0x3072, 0x300, PRODUCT_NAME_NEU_300, PRODUCT_FAMILY_NEU_300, "",&hg_scanner_mgr::create_scanner_g300}
                         , {0x3072, 0x302, PRODUCT_NAME_NEU_300, PRODUCT_FAMILY_NEU_300, "",&hg_scanner_mgr::create_scanner_g302}
                         , {0x3072, 0x339, PRODUCT_NAME_NEU_300, PRODUCT_FAMILY_NEU_300, "",&hg_scanner_mgr::create_scanner_empty}
                         , {0x3072, 0x400, PRODUCT_NAME_NEU_400, PRODUCT_FAMILY_NEU_400, "",&hg_scanner_mgr::create_scanner_g400}
                         , {0x3072, 0x402, PRODUCT_NAME_NEU_400, PRODUCT_FAMILY_NEU_400, "",&hg_scanner_mgr::create_scanner_g402}
                         , {0x3072, 0x439, PRODUCT_NAME_NEU_400, PRODUCT_FAMILY_NEU_400, "",&hg_scanner_mgr::create_scanner_g439}
                         , {0x064B, 0x7823, PRODUCT_NAME_NEU_200, PRODUCT_FAMILY_NEU_200, "",& hg_scanner_mgr::create_scanner_g100}

                         , {0x31c9, 0x8200, PRODUCT_NAME_LSC_G42, PRODUCT_FAMILY_LSC_G42, "",& hg_scanner_mgr::create_scanner_g300}
                         , {0x31c9, 0x8420, PRODUCT_NAME_LSC_G42, PRODUCT_FAMILY_LSC_G42, "",& hg_scanner_mgr::create_scanner_g300}
                         , {0x31c9, 0x8429, PRODUCT_NAME_LSC_G42, PRODUCT_FAMILY_LSC_G42, "",& hg_scanner_mgr::create_scanner_empty}
                         , {0x31c9, 0x8520, PRODUCT_NAME_LSC_G52, PRODUCT_FAMILY_LSC_G52, "",& hg_scanner_mgr::create_scanner_g400}
                         , {0x31c9, 0x8529, PRODUCT_NAME_LSC_G52, PRODUCT_FAMILY_LSC_G52, "",& hg_scanner_mgr::create_scanner_g439}
                         , {0x31c9, 0x8620, PRODUCT_NAME_LSC_G62, PRODUCT_FAMILY_LSC_G62, "",& hg_scanner_mgr::create_scanner_g100}
                         , {0x31c9, 0x8629, PRODUCT_NAME_LSC_G62, PRODUCT_FAMILY_LSC_G62, "",& hg_scanner_mgr::create_scanner_g239}
                         , {0x31c9, 0x8730, PRODUCT_NAME_LSC_G73, PRODUCT_FAMILY_LSC_G73, "",& hg_scanner_mgr::create_scanner_g100}
                         , {0x31c9, 0x8739, PRODUCT_NAME_LSC_G73, PRODUCT_FAMILY_LSC_G73, "", &hg_scanner_mgr::create_scanner_g239}

                         , {0x32ec, 0x0200, PRODUCT_NAME_ZG_200, PRODUCT_FAMILY_ZG_200, "",& hg_scanner_mgr::create_scanner_g239}
                         , {0x32ec, 0x0210, PRODUCT_NAME_ZG_210, PRODUCT_FAMILY_ZG_210, "", &hg_scanner_mgr::create_scanner_g402}

                         , {0X05DA, 0x9220, PRODUCT_NAME_ZJ_9200, PRODUCT_FAMILY_ZJ_9200, "",&hg_scanner_mgr::create_scanner_g439}

                         , {0x3308, 0x0138, PRODUCT_NAME_CT_138,  PRODUCT_FAMILY_CT_138, "", &hg_scanner_mgr::create_scanner_g239}
                         , {0x3308, 0x0238, PRODUCT_NAME_CT_238,  PRODUCT_FAMILY_CT_238, "", &hg_scanner_mgr::create_scanner_g239}
                         , {0x3072, 0x0303, PRODUCT_NAME_CT_6005, PRODUCT_FAMILY_CT_6005, "", &hg_scanner_mgr::create_scanner_g300}
                         , {0x3308, 0x6005, PRODUCT_NAME_CT_6005, PRODUCT_FAMILY_CT_6005, "", &hg_scanner_mgr::create_scanner_g300}
                         , {0x3308, 0x6006, PRODUCT_NAME_CT_6006, PRODUCT_FAMILY_CT_6006, "",& hg_scanner_mgr::create_scanner_g239}
#else
                           {0x3072, 0x100, PRODUCT_NAME_HG_G100, PRODUCT_FAMILY_HG_G100, "",& hg_scanner_mgr::create_scanner_g100}
                         , {0x3072, 0x139, PRODUCT_NAME_HG_G100, PRODUCT_FAMILY_HG_G100, "",&hg_scanner_mgr::create_scanner_g239}
                         , {0x3072, 0x200, PRODUCT_NAME_HG_G200, PRODUCT_FAMILY_HG_G200, "",&hg_scanner_mgr::create_scanner_g100}
                         , {0x3072, 0x239, PRODUCT_NAME_HG_G200, PRODUCT_FAMILY_HG_G200, "",&hg_scanner_mgr::create_scanner_g239}
                         , {0x3072, 0x300, PRODUCT_NAME_HG_G300, PRODUCT_FAMILY_HG_G300, "",&hg_scanner_mgr::create_scanner_g300}
                         , {0x3072, 0x302, PRODUCT_NAME_HG_G300, PRODUCT_FAMILY_HG_G300, "",&hg_scanner_mgr::create_scanner_g302}
                         , {0x3072, 0x339, PRODUCT_NAME_HG_G300, PRODUCT_FAMILY_HG_G300, "",&hg_scanner_mgr::create_scanner_empty}
                         , {0x3072, 0x400, PRODUCT_NAME_HG_G400, PRODUCT_FAMILY_HG_G400, "",&hg_scanner_mgr::create_scanner_g400}
                         , {0x3072, 0x402, PRODUCT_NAME_HG_G400, PRODUCT_FAMILY_HG_G400, "",&hg_scanner_mgr::create_scanner_g402}
                         , {0x3072, 0x439, PRODUCT_NAME_HG_G400, PRODUCT_FAMILY_HG_G400, "",& hg_scanner_mgr::create_scanner_g439}

                         , {0x064B, 0x7823,PRODUCT_NAME_HG_G300, PRODUCT_FAMILY_HG_G300, "",& hg_scanner_mgr::create_scanner_g300}
                         , {0x064B, 0x7823,PRODUCT_NAME_HG_G200, PRODUCT_FAMILY_HG_G200, "",& hg_scanner_mgr::create_scanner_g100}
                         , {0x064B, 0x7823,PRODUCT_NAME_HG_G400, PRODUCT_FAMILY_HG_G400, "", &hg_scanner_mgr::create_scanner_g400}
#endif                              
                         };
bool islang = false;
//static std::string g_vendor = GET_LANG(COMPANY_NAME, &islang);

#define BRAND_LOGO_SIZE                 8 * 1024

#define MOVE_TO_NEXT_STR(str)           str += strlen(str) + 1
/// </summary>



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// language option ...
class lang_opt : public sane_opt_provider
{
public:
    lang_opt()
    {
        set_where("language-option");

        const char* lang = language_option_descriptor();
        if (lang && *lang)
        {
            std::string t(lang);

            set_opt_json_text(&t[0]);
        }
    }

protected:
    virtual ~lang_opt()
    {}

public:
    virtual int set_value(const char* name, void* val) override
    {
        if (strcmp(name, "language"))
            return SCANNER_ERR_NO_DATA;

        LANATTR** pla = lang_get_supported_languages();
        int err = SCANNER_ERR_OK;

        if (!pla)
            err = SCANNER_ERR_DEVICE_NOT_SUPPORT;
        else
        {
            std::string	n(to_default_language((char*)val, nullptr)), now("");
            int	id = -1, cur = lang_get_cur_code_page();
            for (int i = 0; pla[i]; ++i)
            {
                if (pla[i]->cp == cur)
                    now = pla[i]->name;
                if (n == pla[i]->name)
                {
                    id = pla[i]->cp;
                    break;
                }
            }
            if (id == -1)
            {
                err = SCANNER_ERR_NOT_EXACT;
                ::strcpy((char*)val, now.c_str());
            }
            else if (cur != id)
            {
                err = SCANNER_ERR_CONFIGURATION_CHANGED;
                lang_set_code_page(id);
            }
        }

        return err;
    }
};
static lang_opt* g_language = nullptr;



////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 
hg_scanner_mgr* hg_scanner_mgr::inst_ = NULL;
sane_callback hg_scanner_mgr::event_callback_ = NULL;
bool          hg_scanner_mgr::async_io_enabled_ = false;
int           hg_scanner_mgr::ver_major_ = 1;
int           hg_scanner_mgr::ver_minor_ = 0;
int           hg_scanner_mgr::ver_build_ = 0;
int           hg_scanner_mgr::ver_patch_ = 1;
std::string   hg_scanner_mgr::pe_path_("");
std::string   hg_scanner_mgr::pe_name_("");
std::string   hg_scanner_mgr::last_open_msg_("");
bool          hg_scanner_mgr::read_over_with_eof_ = true;

uint32_t        hg_scanner_mgr::unique_img_id_ = 0;;
std::mutex      hg_scanner_mgr::mutex_img_id;

hg_scanner_mgr::hg_scanner_mgr() : same_ind_(1), cf_name("")
{
    std::string cfgf(utils::get_local_data_path() + PATH_SEPARATOR + "config" + PATH_SEPARATOR + "debug.cfg");
    char        buf[260] = {0};
    int         l = GetPrivateProfileStringA("devs_name", "name", "", buf, _countof(buf) - 1, cfgf.c_str());

    init_debug_config(cfgf.c_str());

    buf[l] = 0;
    cf_name = buf;
    usb_manager::instance()->register_hotplug(&hg_scanner_mgr::usb_event_handle, this);
    int code_page = lang_get_cur_code_page();
    url_en = BRAND_COMPANY_URL;
    url_link_en = BRAND_URL_COMPANY_URL;
    if (code_page == 20127)
    {
        url_en = BRAND_COMPANY_URL_EN;
        url_link_en = BRAND_URL_COMPANY_URL_EN;
    }

    user_ = new hguser();
    offline_ = new offline_opts(user_);
    g_language = new lang_opt();
}
hg_scanner_mgr::~hg_scanner_mgr()
{
    usb_manager::instance()->register_hotplug(nullptr, nullptr);
    {
        std::lock_guard<std::mutex>    lock(mutex_dev_);
        for (auto& v : online_devices_)
        {
            libusb_unref_device(v.dev);
            if (v.dev_opts)
                v.dev_opts->release();
        }
        online_devices_.clear();
    }

    usb_manager::clear();
    offline_->release();
    delete user_;

    g_language->release();
}

int hg_scanner_mgr::ui_default_callback(scanner_handle h, int ev, void* data, unsigned int* len, void* param)
{
    // if (!hg_scanner_mgr::async_io_enabled_ &&
    //     ev == SANE_EVENT_IS_MEMORY_ENOUGH)
    // {
    //     struct sysinfo si;
    //     if(sysinfo(&si) == 0)
    //         return si.freeram * si.mem_unit > *len + 200 * 1024 * 1024 ? SCANNER_ERR_OK : SCANNER_ERR_INSUFFICIENT_MEMORY;

    //     return SCANNER_ERR_OK;
    // }

    if (hg_scanner_mgr::event_callback_)
        return hg_scanner_mgr::event_callback_(h, ev, data, len, param);

    return SCANNER_ERR_OK;
}
hg_scanner_mgr* hg_scanner_mgr::instance(sane_callback cb)
{
    if (!hg_scanner_mgr::inst_)
    {
        hg_scanner_mgr::event_callback_ = cb;
        if (cb)
            hg_scanner_mgr::async_io_enabled_ = cb(NULL, SANE_EVENT_SUPPORT_ASYNC_IO, NULL, NULL, NULL) == 0;
        hg_scanner_mgr::unique_img_id_ = (uint32_t)INT_MAX + 1;
        hg_scanner_mgr::inst_ = new hg_scanner_mgr();
        utils::to_log(LOG_LEVEL_DEBUG, "async image transferring is %s\n", hg_scanner_mgr::async_io_enabled_ ? "enabled" : "disabled");
    }

    return hg_scanner_mgr::inst_;
}
void hg_scanner_mgr::clear(void)
{
    if (hg_scanner_mgr::inst_)                                                          
    {
        {
            std::lock_guard<std::mutex>    lock(hg_scanner_mgr::inst_->mutex_dev_);
            hg_scanner_mgr::event_callback_ = nullptr;
        }
        delete hg_scanner_mgr::inst_;
        hg_scanner_mgr::inst_ = NULL;
    }
}
void hg_scanner_mgr::set_version(int hh, int hl, int lh, int ll)
{
    hg_scanner_mgr::ver_major_ = hh;
    hg_scanner_mgr::ver_minor_ = hl;
    hg_scanner_mgr::ver_build_ = lh;
    hg_scanner_mgr::ver_patch_ = ll;
}
void hg_scanner_mgr::get_version(int* hh, int* hl, int* lh, int* ll)
{
    if(hh)
        *hh = hg_scanner_mgr::ver_major_;
    if(hl)
        *hl = hg_scanner_mgr::ver_minor_;
    if(lh)
        *lh = hg_scanner_mgr::ver_build_;
    if(ll)
        *ll = hg_scanner_mgr::ver_patch_;
}
void hg_scanner_mgr::set_exe_name(const char* path, const char* name)
{
    std::string cfgf(utils::get_local_data_path() + PATH_SEPARATOR + "config" + PATH_SEPARATOR + "debug.cfg");
    char        buf[260] = {0};
    int         l = 0;

    hg_scanner_mgr::pe_path_ = path ? path : "";
    hg_scanner_mgr::pe_name_ = name ? name : "";
    std::string str(utils::get_command_result("scanimage -V"));
    bool is_scanimg =false;
    is_scanimg = str >= "1.0.29" ? true : false;
    utils::to_log(LOG_LEVEL_ALL, "imgascan ver is: %s is_scanimg is:%d\n", str.c_str(),is_scanimg);
    if (name && *name)
    {
       // int ret = system("scanimage -V");
       l = GetPrivateProfileStringA("read_eof", name, "", buf, _countof(buf) - 1, cfgf.c_str());
        if (l == 0)
        {
            if(is_scanimg)
                hg_scanner_mgr::read_over_with_eof_ = STRICMP(name, "simple-scan") != 0;
            else
                hg_scanner_mgr::read_over_with_eof_ = STRICMP(name, "simple-scan") != 0 && (!is_scanimg? (STRICMP(name, "scanimage") != 0) : 1);
        }  
        else
            hg_scanner_mgr::read_over_with_eof_ = strcmp(buf, "0") != 0;
    }
    else
    {
        l = GetPrivateProfileStringA("read_eof", "first", "", buf, _countof(buf) - 1, cfgf.c_str());
        if (l == 0)
            hg_scanner_mgr::read_over_with_eof_ = true;
        else
            hg_scanner_mgr::read_over_with_eof_ = strcmp(buf, "0") != 0;
    }

    utils::to_log(LOG_LEVEL_ALL, "read image data end with EOF: %s\n", hg_scanner_mgr::read_over_with_eof_ ? "true" : "false");
}
std::string hg_scanner_mgr::get_pe_name(std::string* path)
{
    if (path)
        *path = hg_scanner_mgr::pe_path_;

    return hg_scanner_mgr::pe_name_;
}
uint32_t hg_scanner_mgr::unique_id(int type)
{
    if (type == UNIQUE_ID_IMG)
    {
        std::lock_guard<std::mutex> lock(hg_scanner_mgr::mutex_img_id);

        return hg_scanner_mgr::unique_img_id_++;
    }

    return -1;
}

hg_scanner* hg_scanner_mgr::create_scanner_empty(const char* name, const char* family, usb_io* io, scanner_handle* h)
{
    if (h)
        *h = nullptr;

    return nullptr;
}
hg_scanner* hg_scanner_mgr::create_scanner_g100(const char* name, const char* family, usb_io* io, scanner_handle* h)
{
    hg_scanner_200* s = new hg_scanner_200(name, family, 0x100, io);

    if (h)
        *h = s;

    return dynamic_cast<hg_scanner*>(s);
}
hg_scanner* hg_scanner_mgr::create_scanner_g239(const char* name, const char* family, usb_io* io, scanner_handle* h)
{
    hg_scanner_239* s = new hg_scanner_239(name, family, 0x239, io);

    if (h)
        *h = s;

    return dynamic_cast<hg_scanner*>(s);
}
hg_scanner* hg_scanner_mgr::create_scanner_g300(const char* name, const char* family, usb_io* io, scanner_handle* h)
{
    hg_scanner_300* s = new hg_scanner_300(name, family, 0x300, io);

    if (h)
        *h = s;

    return dynamic_cast<hg_scanner*>(s);
}
hg_scanner* hg_scanner_mgr::create_scanner_g400(const char* name, const char* family, usb_io* io, scanner_handle* h)
{
    hg_scanner_300* s = new hg_scanner_300(name, family, 0x400, io);

    if (h)
        *h = s;

    return dynamic_cast<hg_scanner*>(s);
}
hg_scanner* hg_scanner_mgr::create_scanner_g302(const char* name, const char* family, usb_io* io, scanner_handle* h)
{
    hg_scanner_302* s = new hg_scanner_302(name, family, 0x302, io);    // image_process needs PID 402, we should add 302 ...

    if (h)
        *h = s;

    return dynamic_cast<hg_scanner*>(s);
}
hg_scanner* hg_scanner_mgr::create_scanner_g402(const char* name, const char* family, usb_io* io, scanner_handle* h)
{
    hg_scanner_302* s = new hg_scanner_302(name, family, 0x402, io);

    if (h)
        *h = s;

    return dynamic_cast<hg_scanner*>(s);
}
hg_scanner* hg_scanner_mgr::create_scanner_g439(const char* name, const char* family, usb_io* io, scanner_handle* h)
{
    hg_scanner_239* s = new hg_scanner_239(name, family, 0x439, io);

    if (h)
        *h = s;

    return dynamic_cast<hg_scanner*>(s);
}
void hg_scanner_mgr::usb_event_handle(usb_event ev, libusb_device* device, int vid, int pid, int usb_ver_h, int usb_ver_l, bool* retry, void* user) // usb_ver_h.usb_ver_l
{
    hg_scanner_mgr* obj = (hg_scanner_mgr*)user;
    
    obj->on_hgscanner_pnp(ev, device, vid, pid, usb_ver_h, usb_ver_l, retry);
}

void hg_scanner_mgr::on_hgscanner_pnp(usb_event ev, libusb_device* device, int vid, int pid, int usb_ver_h, int usb_ver_l, bool* retry)
{
    char    model[40],
            vendor[40];
    SANE_Device_Ex de;
    int     ev_ui = 0;
    scanner_handle h = NULL;
    unsigned int len = sizeof(de);
    std::string name(""), type("");
    std::lock_guard<std::mutex>    lock(mutex_dev_);

    sprintf(model, "%x", pid);
    sprintf(vendor, "%x", vid);
    de.model = model;
    de.name = NULL;
    de.family = NULL;
    de.vendor = vendor;
    de.openned = SANE_FALSE;

    if (ev == USB_EVENT_DEVICE_ARRIVED)
    {
        int index = -1;
        for (int i = 0; i < _countof(g_supporting_devices); ++i)
        {
            // 064B 澶氬彴璁惧浣跨敤杩欎釜vid锛屾墍浠ュ姞杞芥椂涓嶄細娓呮瑕佹墦寮€鍝竴鍙拌澶囷紝鍙湁閫氳繃澶栭儴杩涜鍔犺浇鏀瑰彉瀹炰<E780B9>?
            if (g_supporting_devices[i].vid == vid && g_supporting_devices[i].pid == pid)
            {
                index = i;
                ev_ui = SANE_EVENT_DEVICE_ARRIVED;
                name = g_supporting_devices[i].name.c_str();
                type = g_supporting_devices[i].family.c_str();

                if (vid == 0x064B && !cf_name.empty())
                {
                    if (cf_name == g_supporting_devices[i].family)
                    {
                        name = g_supporting_devices[i].name.c_str();
                        type = g_supporting_devices[i].family.c_str();
                        break;
                    }
                }
                else
                    break;
            }
        }

        if (index != -1)
        {
            bool add = true;
            size_t i = 0;
            for (; i < online_devices_.size(); ++i)
            {
                if (online_devices_[i].dev == device)   // 姝ゅ鍋囧畾鍚屼竴鍙拌澶囬噸鏂拌繛鎺ュ悗锛岃澶囧璞♀€渄evice鈥濅繚鎸佷笉鍙橈紱濡傛灉鍋囪涓嶆垚绔嬶紝浼氬鑷磋澶囬噸杩炴秷鎭笉鑳芥甯告帴鏀讹紝缁戝畾鍒拌璁惧鐨剆canner瀵硅薄寰椾笉鍒伴噴鏀?
                {
                    online_devices_[i].ind = index;
                    add = false;
                    break;
                }
            }
            if (add)    // 澶勭悊瀵硅薄鈥渄evice鈥濇敼鍙樼殑鎯呮<E98EAF>?
            {
                i = 0;
                for (auto& v : online_devices_)
                {
                    if (v.ind == index &&
                        (v.scanner && !v.scanner->is_online()))
                    {
                        add = false;
                        break;
                    }
                    i++;
                }
            }

            if (add)
            {
                OLSCANNER ols;

                ols.dev = device;
                ols.ind = index;
                ols.scanner = NULL;
                ols.dev_opts = nullptr;
                ols.imgproc = nullptr;
                ols.display_name = g_supporting_devices[ols.ind].name;
                if (std::find(online_devices_.begin(), online_devices_.end(), ols.ind) != online_devices_.end())
                {
                    char buf[40];

                    sprintf(buf, " - %u", same_ind_++);
                    ols.display_name += buf;
                }
                libusb_ref_device(ols.dev);         // ref to the device of queue online_devices_
                online_devices_.push_back(ols);
                name = ols.display_name;
                utils::to_log(LOG_LEVEL_DEBUG, "%s connected.\n", name.c_str());
                type = g_supporting_devices[ols.ind].family;
            }
            else if (online_devices_[i].scanner && !online_devices_[i].scanner->is_online())
            {
                usb_io* io = NULL;

                name = online_devices_[i].display_name;
                type = g_supporting_devices[index].family;
                if (online_devices_[i].dev)
                    libusb_unref_device(online_devices_[i].dev);
                online_devices_[i].dev = device;
                libusb_ref_device(online_devices_[i].dev);
                h = online_devices_[i].scanner;
                if (pid == 0x300 || pid == 0x400)
                    std::this_thread::sleep_for(std::chrono::milliseconds(1000));
                len = usb_manager::instance()->open(device, &io);
                utils::to_log(LOG_LEVEL_WARNING, "[%04x:%04x]%s re-connected.\n", pid, vid, online_devices_[i].display_name.c_str());
                if (len == SCANNER_ERR_OK)
                {
                    online_devices_[i].scanner->reset_io(io);
                    de.openned = SANE_TRUE;
                }
                if (io)
                    io->release();
                add = false;
            }
        }
    }
    else if (ev == USB_EVENT_DEVICE_LEFT)
    {
        std::vector<OLSCANNER>::iterator it = std::find(online_devices_.begin(), online_devices_.end(), device);
        if (it != online_devices_.end())
        {
            ev_ui = SANE_EVENT_DEVICE_LEFT;
            name = it->display_name;
            type = g_supporting_devices[it->ind].family;
            h = it->scanner;
            utils::to_log(LOG_LEVEL_DEBUG, "%s Dis-connected.\n", name.c_str());
            if (it->scanner)
                it->scanner->io_disconnected();
            else
            {
                libusb_unref_device(it->dev);   // unref the device of queue online_devices_
                online_devices_.erase(it);
            }
        }
    }

    if (ev_ui)
    {
        de.name = name.c_str();
        de.family = type.c_str();
        hg_scanner_mgr::ui_default_callback(h, ev_ui, &de, &len, NULL);
    }
}
void hg_scanner_mgr::get_online_devices(std::vector<OLSCANNER>& devs)
{
    std::lock_guard<std::mutex>    lock(mutex_dev_);

    devs = online_devices_;
}

void hg_scanner_mgr::init_debug_config(const char* cfg_file)
{
    // dumping images ...
    dump_img_path_ = utils::get_local_data_path() + PATH_SEPARATOR + "imgs";
    if (GetPrivateProfileIntA("dump", "dumpusb", 0, cfg_file) == 1)
    {
        char    strbuf[260] = { 0 };
        int     getl = 0;

        dump_img_ = true;
        getl = GetPrivateProfileStringA("dump", "usb_path", "", strbuf, _countof(strbuf) - 1, cfg_file);
        if (getl)
            dump_img_path_ = strbuf;
    }

}
void hg_scanner_mgr::set_appendix_info_for_about(SANE_About* about, char*& ptr, int& count, const char* key, const char* info, const char* url)
{
#ifdef BRAND_DISPLAY_ALL_EXPAND
    if (!info || *info == 0)
        info = GET_LANG(BRAND_COMMUNICATION_FAIL,&islang);
#endif

    if (info && strlen(info))
    {
        about->appendix[count].key = ptr;
        strcpy(ptr, key);
        MOVE_TO_NEXT_STR(ptr);

        about->appendix[count].content = ptr;
        strcpy(ptr, info);
        MOVE_TO_NEXT_STR(ptr);

        if (url)
        {
            about->appendix[count++].url = ptr;
            strcpy(ptr, url);
            MOVE_TO_NEXT_STR(ptr);
        }
        else
        {
           about->appendix[count].url = NULL;
           count++;
        }    
    }
}
scanner_err hg_scanner_mgr::get_about_info(scanner_handle h, void* data, unsigned* len)
{
    hg_scanner* scanner = (hg_scanner*)h;
    unsigned    bytes = sizeof(SANE_About) + 40;
    SANE_About  tmp;
    size_t      append_cnt = 1;


    //bytes += sizeof(g_logo);
    bytes += strlen(GET_LANG(BRAND_APP_NAME, &islang)) + 8;                 append_cnt++;
    bytes += strlen(GET_LANG(BRAND_TITLE_VERSION,&islang)) + 8;             append_cnt++;
    bytes += strlen(GET_LANG(BRAND_TITLE_COPYRIGHT,&islang)) + 8;           append_cnt++;
    bytes += strlen(GET_LANG(BRAND_COPYRIGHT,&islang)) + 8;                 append_cnt++;
    bytes += strlen(GET_LANG(BRAND_TITE_MANUFACTOR,&islang)) + 8;           append_cnt++;
    bytes += strlen(GET_LANG(BRAND_TITLE_URL,&islang)) + 8;                 append_cnt++;
    bytes += strlen(GET_LANG(url_en.c_str(), &islang)) + 8;               append_cnt++;
    

    bytes += strlen(GET_LANG(url_link_en.c_str(), &islang)) + 8;          append_cnt++;
    bytes += strlen(GET_LANG(BRAND_TITLE_TEL,&islang)) + 8;                 append_cnt++;      
    bytes += strlen(GET_LANG(BRAND_COMPANY_TEL,&islang)) + 8;               append_cnt++;
    bytes += strlen(GET_LANG(BRAND_TITLE_ADDRESS,&islang)) + 8;             append_cnt++;
    bytes += strlen(GET_LANG(BRAND_COMPANY_ADDRESS,&islang)) + 8;           append_cnt++;
    bytes += strlen(GET_LANG(BRAND_TITLE_GPS,&islang)) + 8;                 append_cnt++;
    bytes += strlen(GET_LANG(BRAND_COMPANY_GPS,&islang)) + 8;               append_cnt++;
    bytes += strlen(GET_LANG(BRAND_URL_GPS,&islang)) + 8;                   append_cnt++;
    // bytes += 5 * sizeof(tmp.appendix[0]);

#ifndef BRAND_DISPLAY_ALL_EXPAND
    if (scanner)
#endif
    {
        bytes += sizeof(tmp.appendix[0]) + BRAND_INFO_MAX_LENGTH + 8 + strlen(GET_LANG(BRAND_SOFTWARE_VERSION, &islang)) + 8;
        bytes += sizeof(tmp.appendix[0]) + BRAND_INFO_MAX_LENGTH + 8 + strlen(GET_LANG(BRAND_TITLE_DEVICE_MODEL, &islang)) + 8;             append_cnt++;
        bytes += sizeof(tmp.appendix[0]) + BRAND_INFO_MAX_LENGTH + 8 + strlen(GET_LANG(BRAND_TITLE_FIRM_VERSION,&islang)) + 8;              append_cnt++;
        bytes += sizeof(tmp.appendix[0]) + BRAND_INFO_MAX_LENGTH + 8 + strlen(GET_LANG(BRAND_TITLE_SERIAL_NUM,&islang)) + 8;                append_cnt++;
        bytes += sizeof(tmp.appendix[0]) + BRAND_INFO_MAX_LENGTH + 8 + strlen(GET_LANG(BRAND_TITLE_IP,&islang)) + 8;                        append_cnt++;
        bytes += sizeof(tmp.appendix[0]) + 28 + strlen(GET_LANG(BRAND_TITLE_ROLLER_COUNT,&islang)) + 8;                                     append_cnt++;
        bytes += sizeof(tmp.appendix[0]) + 28 + strlen(GET_LANG(BRAND_TITLE_HISTORY_COUNT,&islang)) + 8;                                    append_cnt++;
        bytes += sizeof(tmp.appendix[0]) + 28 + strlen(GET_LANG(BRAND_TITLE_DEVICE_INITIAL_POWER_ON_TIME, &islang)) + 8;                    append_cnt++;
        bytes += sizeof(tmp.appendix[0]);                                                                                                   append_cnt++;
    }

    if (!data || *len < bytes)
    {
        *len = bytes;

        return SCANNER_ERR_INSUFFICIENT_MEMORY;
    }

    // filling info to flat buffer ...
    SANE_About* about = (SANE_About*)data;
    std::string info("");
    char* ptr = (char*)data + sizeof(SANE_About) + append_cnt * sizeof(about->appendix[0]);

    about->title = ptr;
    strcpy(ptr, GET_LANG(BRAND_APP_NAME,&islang));
    MOVE_TO_NEXT_STR(ptr);

    about->version = ptr;
    sprintf(ptr, "%d.%d.%d.%d", hg_scanner_mgr::ver_major_, hg_scanner_mgr::ver_minor_, hg_scanner_mgr::ver_build_, hg_scanner_mgr::ver_patch_);
    MOVE_TO_NEXT_STR(ptr);

    about->copyright = ptr;
    std::string s  = GET_LANG(BRAND_COPYRIGHT, &islang);
    strcpy(ptr, s.c_str());
    MOVE_TO_NEXT_STR(ptr);

    //about->logo_bytes = sizeof(g_logo);;
    //about->logo = ptr;
    //memcpy(ptr, g_logo, about->logo_bytes);
    ptr += about->logo_bytes + 1;

    int count = 0, rolls = 0, ret = SCANNER_ERR_OK;
#ifdef TEST 
    set_appendix_info_for_about(about, ptr, count, GET_LANG(BRAND_SOFTWARE_VERSION, &islang), BRAND_SOFTWARE_VERSION_TEST, NULL);
#endif
    std::string g_vendor = GET_LANG(COMPANY_NAME, &islang);
    set_appendix_info_for_about(about, ptr, count, GET_LANG(BRAND_TITE_MANUFACTOR,&islang), g_vendor.c_str(), NULL);
    set_appendix_info_for_about(about, ptr, count, GET_LANG(BRAND_TITLE_URL,&islang), GET_LANG(url_en.c_str(), &islang), GET_LANG(url_link_en.c_str(), &islang));
    set_appendix_info_for_about(about, ptr, count, GET_LANG(BRAND_TITLE_TEL,&islang), GET_LANG(BRAND_COMPANY_TEL,&islang), NULL);
    set_appendix_info_for_about(about, ptr, count, GET_LANG(BRAND_TITLE_ADDRESS,&islang), GET_LANG(BRAND_COMPANY_ADDRESS,&islang), NULL);
    if (strlen(BRAND_TITLE_GPS) > 1)
    {
        set_appendix_info_for_about(about, ptr, count, GET_LANG(BRAND_TITLE_GPS, &islang), GET_LANG(BRAND_COMPANY_GPS, &islang), GET_LANG(BRAND_URL_GPS, &islang));

    }

    if (scanner)
    {      
        set_appendix_info_for_about(about, ptr, count, GET_LANG(BRAND_TITLE_FIRM_VERSION,&islang), scanner->get_firmware_version().c_str(), NULL);
        set_appendix_info_for_about(about, ptr, count, GET_LANG(BRAND_TITLE_SERIAL_NUM,&islang), scanner->get_serial_num().c_str(), NULL);
        info = scanner->get_ip();
        if (info.length() > 10 && !info.empty())
            set_appendix_info_for_about(about, ptr, count, GET_LANG(BRAND_TITLE_IP,&islang), info.c_str(), NULL);
        info.clear();
        info = scanner->get_device_model();
        if (!info.empty())
            set_appendix_info_for_about(about, ptr, count, GET_LANG(BRAND_TITLE_DEVICE_MODEL, &islang), info.c_str(), NULL);
        ret = scanner->get_devs_time(info);
        if (ret == SCANNER_ERR_OK && !info.empty())
        {
            set_appendix_info_for_about(about, ptr, count, GET_LANG(BRAND_TITLE_ROLLER_COUNT, &islang), info.c_str(), NULL);
        }
        ret = scanner->get_roller_num(rolls);
        if (ret == SCANNER_ERR_OK)
        {
            char buf[40];
            sprintf(buf, "%u", rolls);
            set_appendix_info_for_about(about, ptr, count, GET_LANG(BRAND_TITLE_ROLLER_COUNT,&islang), buf, NULL);
        }
#ifdef BRAND_DISPLAY_ALL_EXPAND
        else
            set_appendix_info_for_about(about, ptr, count, GET_LANG(BRAND_TITLE_ROLLER_COUNT,&islang), rolls == -1 ? GET_LANG(BRAND_COMMUNICATION_FAIL,&islang) : GET_LANG(BRAND_DEVICE_NOT_SUPPORT,&islang), NULL);
#endif

        ret = scanner->get_history_scan_count(rolls);
        if (ret == SCANNER_ERR_OK)
        {
            char buf[40];
            sprintf(buf, "%u", rolls);
            set_appendix_info_for_about(about, ptr, count, GET_LANG(BRAND_TITLE_HISTORY_COUNT,&islang), buf, NULL);
        }
#ifdef BRAND_DISPLAY_ALL_EXPAND
        else
            set_appendix_info_for_about(about, ptr, count, GET_LANG(BRAND_TITLE_HISTORY_COUNT,&islang), rolls == -1 ? GET_LANG(BRAND_COMMUNICATION_FAIL,&islang) : GET_LANG(BRAND_DEVICE_NOT_SUPPORT,&islang), NULL);
#endif
    }
#ifdef BRAND_DISPLAY_ALL_EXPAND
    else
    {
        set_appendix_info_for_about(about, ptr, count, GET_LANG(BRAND_TITLE_FIRM_VERSION,&islang), GET_LANG(BRAND_NO_DEVICE,&islang), NULL);
        set_appendix_info_for_about(about, ptr, count, GET_LANG(BRAND_TITLE_SERIAL_NUM,&islang), GET_LANG(BRAND_NO_DEVICE,&islang), NULL);
        set_appendix_info_for_about(about, ptr, count, GET_LANG(BRAND_TITLE_IP,&islang), GET_LANG(BRAND_NO_DEVICE,&islang), NULL);
        set_appendix_info_for_about(about, ptr, count, GET_LANG(BRAND_TITLE_ROLLER_COUNT,&islang), GET_LANG(BRAND_NO_DEVICE,&islang), NULL);
        set_appendix_info_for_about(about, ptr, count, GET_LANG(BRAND_TITLE_HISTORY_COUNT,&islang), GET_LANG(BRAND_NO_DEVICE,&islang), NULL);
    }
#endif

    about->appendix[count].key = NULL;
    about->appendix[count].content = NULL;
    about->appendix[count].url = NULL;

    return SCANNER_ERR_OK;
}
imgproc_mgr* hg_scanner_mgr::create_image_processor(device_option* devopts)
{
    imgproc_mgr* proc = new imgproc_mgr(devopts, dump_img_, dump_img_path_.c_str());
    std::string path(utils::get_module_full_path(MODULE_NAME_SCANNER));
    size_t      pos = path.rfind(PATH_SEPARATOR[0]);

    if (pos++ == std::string::npos)
        pos = 0;
    path.erase(pos);
    path += std::string("imgproc") + PATH_SEPARATOR;

    // load image-processors ...
    proc->load_processor(path.c_str());

    return proc;
}

scanner_err hg_scanner_mgr::hg_scanner_enum(ScannerInfo* scanner_list, long* count, bool local_only)
{
    std::vector<OLSCANNER> devusbuf;
    long        size = *count;
    scanner_err      ret = SCANNER_ERR_OK;
    std::string g_vendor(from_default_language(COMPANY_NAME, nullptr));
    get_online_devices(devusbuf);
    *count = devusbuf.size();
	if (*count > size)
	{
        ret = SCANNER_ERR_INSUFFICIENT_MEMORY;
	}
    else
    {
        for (size_t i = 0; i < devusbuf.size(); i++)
        {
            scanner_list->vid = g_supporting_devices[devusbuf[i].ind].vid;
            scanner_list->pid = g_supporting_devices[devusbuf[i].ind].pid;
            strcpy(scanner_list->name, devusbuf[i].display_name.c_str());
            strcpy(scanner_list->model, g_supporting_devices[devusbuf[i].ind].family.c_str());
            strcpy(scanner_list->type, g_supporting_devices[devusbuf[i].ind].name.c_str());
            strcpy(scanner_list->vendor, g_vendor.c_str());
            scanner_list++;
        }
    }

	return ret;
}
scanner_err hg_scanner_mgr::hg_scanner_open(scanner_handle* h, const char* name, bool shared, const char* user, const char* pwd, const char* check, char* rsc)
{
    std::vector<OLSCANNER> devs;
    std::vector<OLSCANNER>::iterator it;
    usb_io* io = NULL;
    scanner_err ret = SCANNER_ERR_DEVICE_NOT_FOUND;

    *h = NULL;
    get_online_devices(devs);
    it = std::find(devs.begin(), devs.end(), name);
    if (it != devs.end())
    {
        hg_scanner_mgr::last_open_msg_ = "";
        ret = (scanner_err)usb_manager::instance()->open(it->dev, &io, &hg_scanner_mgr::last_open_msg_);
        if (ret == SCANNER_ERR_OK)
        {
            hg_scanner* scanner  = g_supporting_devices[it->ind].create_scanner(it->display_name.c_str(), g_supporting_devices[it->ind].family.c_str(), io, h);

            if (scanner)
            {
                scanner->set_ui_callback(&hg_scanner_mgr::ui_default_callback, hg_scanner_mgr::async_io_enabled_);
                scanner->set_dev_family(g_supporting_devices[it->ind].family.c_str());
                scanner->set_read_over_with_no_data(hg_scanner_mgr::read_over_with_eof_);
            }
            {
                std::lock_guard<std::mutex>      lock(mutex_dev_);
                std::vector<OLSCANNER>::iterator ptr = std::find(online_devices_.begin(), online_devices_.end(), name);
                if (ptr != online_devices_.end())
                {
                    if (ptr->scanner)
                        ptr->scanner->release();
                    ptr->scanner = (hg_scanner*)*h;

                    auto userpriv = [this](int priv) -> bool
                    {
                        return user_->has_privilege(priv);
                    };
                    auto logger = [this](const char* msg) -> void
                    {
                        utils::to_log(LOG_LEVEL_DEBUG, "%s", msg);
                    };

                    if (ptr->dev_opts)
                        ptr->dev_opts->clear();
                    else
                        ptr->dev_opts = new device_option(userpriv, logger);
                    ptr->dev_opts->add(dynamic_cast<sane_opt_provider*>(offline_));
                    ptr->dev_opts->add(dynamic_cast<sane_opt_provider*>(g_language));
                    ptr->dev_opts->add(ptr->scanner);
                    ptr->dev_opts->restore(ptr->scanner);

                    ptr->imgproc = create_image_processor(ptr->dev_opts);
                    ptr->scanner->set_image_processor(ptr->imgproc);
                    ptr->dev_opts->add(ptr->imgproc);
                }
            }
        }
        else if(hg_scanner_mgr::last_open_msg_.length())
            hg_scanner_mgr::ui_default_callback(nullptr, SANE_EVENT_ERROR, (void*)hg_scanner_mgr::last_open_msg_.c_str(), (unsigned int*)&ret, nullptr);

        if(io)
            io->release();
    }

    return *h ? SCANNER_ERR_OK : ret;
}
scanner_err hg_scanner_mgr::hg_scanner_close(scanner_handle h, bool force)
{
    {
        std::lock_guard<std::mutex>      lock(mutex_dev_);
        for (auto& v : online_devices_)
        {
            if (v.scanner == h)
            {
                v.scanner = nullptr;
                if (v.dev_opts)
                {
                    v.dev_opts->clear();
                    v.dev_opts->release();
                    v.dev_opts = nullptr;
                }
                if (v.imgproc)
                    v.imgproc->release();
                v.imgproc = nullptr;

                break;
            }
        }
    }

    SCAN_PTR(h)->close(force);
    SCAN_PTR(h)->release();
    //delete SCAN_PTR(h);

	return SCANNER_ERR_OK;
}
scanner_err hg_scanner_mgr::hg_scanner_get_parameter(scanner_handle h, const char* name, char* data, long* len, int type)
{
    scanner_err err = SCANNER_ERR_INVALID_PARAMETER;

    if (len)
    {
        device_option* tmp = nullptr;
        if (!h)
        {
            tmp = new device_option();

            tmp->add(offline_);
            tmp->add(g_language);
        }
        else
        {
            err = SCANNER_ERR_DEVICE_NOT_FOUND;
            std::lock_guard<std::mutex>      lock(mutex_dev_);
            for (auto& v : online_devices_)
            {
                if (v.scanner == h)
                {
                    tmp = v.dev_opts;
                    if (tmp)
                        tmp->add_ref();
                    break;
                }
            }
        }

        if (tmp)
        {
            std::string raw(tmp->get_option_value(name == PARAM_ALL ? nullptr : name, type, nullptr, data));

            if (*len < raw.length())
            {
                *len = raw.length();

                err = SCANNER_ERR_INSUFFICIENT_MEMORY;
            }
            else
            {
                memcpy(data, raw.c_str(), raw.length());
                if (*len > raw.length())
                    data[raw.length()] = 0;
                *len = raw.length();
                err = SCANNER_ERR_OK;
#if defined(_WIN32) && defined(_DEBUG)
                if (name == PARAM_ALL)
                {
                    std::string file(utils::get_local_data_path() + PATH_SEPARATOR + "Log" + PATH_SEPARATOR + "allopt.txt");
                    FILE* dst = fopen(file.c_str(), "wb");
                    if (dst)
                    {
                        fwrite(raw.c_str(), 1, raw.length(), dst);
                        fclose(dst);
                    }
                }
#endif
            }

            tmp->release();
        }
    }

    return err;
}
scanner_err hg_scanner_mgr::hg_scanner_set_parameter(scanner_handle h, const char* name, void* data, bool to_default)
{
    scanner_err err = SCANNER_ERR_OK, se = SCANNER_ERR_OK;
    std::string init("");
    device_option* tmp = nullptr;

    if (!h)
    {
        tmp = new device_option();
        tmp->add(offline_);
        tmp->add(g_language);
    }
    else
    {
        for (auto& v : online_devices_)
        {
            if (v.scanner == h)
            {
                tmp = v.dev_opts;
                if (tmp)
                    tmp->add_ref();
                break;
            }
        }
    }

    if (tmp)
    {
        // do restore here ?
        if (name && strcmp(name, SANE_STD_OPT_NAME_RESTORE) == 0)
        {
            sane_opt_provider* sop = dynamic_cast<sane_opt_provider*>(SCAN_PTR(h));
            err = (scanner_err)tmp->restore(sop);
            utils::to_log(LOG_LEVEL_DEBUG, "Restore all options ...\n");
        }
        else
        {
            // 1 - paper option removes 'lateral' choices and add new option with name 'lateral'
            // 2 - page option replaces 'single side' with 'front side' and 'back side'
            //
            // here to transfer them ...
            std::string prev("");
            bool        lateral = false, restore_data = false;

            if (to_default)
            {
                int size = 0;
                init = tmp->get_option_value(name, SANE_ACTION_GET_DEFAULT_VALUE, &size);
                if (size > init.length())
                {
                    std::string t(std::move(init));
                    init.reserve(size);
                    memset(&init[0], 0, size);
                    memcpy(&init[0], &t[0], t.length());
                }
                data = &init[0];
            }
            else
            {
                if (strcmp(name, SANE_STD_OPT_NAME_PAPER) == 0)
                {
                    std::string hx(from_default_language("\346\250\252\345\220\221"));
                    char* lat = strstr((char*)data, hx.c_str());
                    if (lat)
                    {
                        prev = (char*)data;
                        lateral = true;
                        restore_data = true;
                        *lat = 0;
                    }
                }
                else if (strcmp(name, SANE_STD_OPT_NAME_PAGE) == 0)
                {
                    if (strcmp((char*)data, from_default_language("\345\215\225\351\235\242")) == 0)    // single side
                    {
                        prev = (char*)data;
                        restore_data = true;
                        strcpy((char*)data, from_default_language("\346\255\243\351\235\242"));         // front side
                        utils::to_log(LOG_LEVEL_DEBUG, "compatible for old page option '%s' to '%s'.\n", prev.c_str(), (char*)data);
                    }
                }

                err = tmp->refine_data(name, data) ? SCANNER_ERR_NOT_EXACT : SCANNER_ERR_OK;
            }
            se = (scanner_err)tmp->update_data(name, data);

            if (se != SCANNER_ERR_OK)
                err = se;
            else if (restore_data)
            {
                // here handle options paper and page are both string ...
                strcpy((char*)data, prev.c_str());

                if (lateral)
                {
                    utils::to_log(LOG_LEVEL_DEBUG, "compatible for old paper option '%s', set lateral to '%s' additional.\n", prev.c_str(), lateral ? "true" : "false");
                    tmp->refine_data(SANE_STD_OPT_NAME_LATERAL, &lateral);
                    tmp->update_data(SANE_STD_OPT_NAME_LATERAL, &lateral);
                }
            }
        }
        tmp->release();
    }

    return err;
}
scanner_err hg_scanner_mgr::hg_scanner_start(scanner_handle h, void* async_event, int num)
{
	return (scanner_err)SCAN_PTR(h)->start();
}
scanner_err hg_scanner_mgr::hg_scanner_stop(scanner_handle h)
{
    scanner_err err = (scanner_err)SCAN_PTR(h)->stop();

    // call from APP, block when all working-threads stopped - added on 2023-10-18 when handled double-feeding in SANE
    while (SCAN_PTR(h)->is_running() != hg_scanner::THREAD_RUNNING_IDLE)
        std::this_thread::sleep_for(std::chrono::milliseconds(3));

    return err;
}
scanner_err hg_scanner_mgr::hg_scanner_get_img_info(scanner_handle h, SANE_Parameters* bmi, long len)
{
	return (scanner_err)SCAN_PTR(h)->get_image_info(bmi);
}
scanner_err hg_scanner_mgr::hg_scanner_read_img_data(scanner_handle h, unsigned char* data, long* len)
{
    if (!len)
        return SCANNER_ERR_INVALID_PARAMETER;

    int l = *len,
        err = SCAN_PTR(h)->read_image_data(data, &l);

    *len = l;

    return (scanner_err)err;
}
scanner_err hg_scanner_mgr::hg_scanner_get_status(scanner_handle h, int setstutas)
{
    return (scanner_err)SCAN_PTR(h)->status();
}
scanner_err hg_scanner_mgr::hg_scanner_reset(scanner_handle h)
{
    return (scanner_err)SCAN_PTR(h)->reset();
}
scanner_err hg_scanner_mgr::hg_scanner_control(scanner_handle h, unsigned long code, void* data, unsigned* len)
{
    //if (!len && code != IO_CTRL_CODE_TEST_SINGLE)
    //    return SCANNER_ERR_INVALID_PARAMETER;

    if (code == IO_CTRL_CODE_ABOUT_INFO)
        return get_about_info(h, data, len);
    else if (code == IO_CTRL_CODE_GET_LOG_FILE && len && *len == LOG_FILE_DRIVER)
    {
        if (!data)
            return SCANNER_ERR_INVALID_PARAMETER;

        std::string f(utils::temporary_path() + PATH_SEPARATOR + "scanner-tmplog.txt");

        int ret = utils::copy_log_file_to(f.c_str());
        if (ret)
            *((char*)data) = 0;
        else
            strcpy((char*)data, f.c_str());

        return (scanner_err)ret;
    }
    else if (!h)
        return SCANNER_ERR_INVALID_PARAMETER;
    else 
        return (scanner_err)SCAN_PTR(h)->device_io_control(code, data, len);
}

void hg_scanner_mgr::on_language_changed(void)
{
    std::lock_guard<std::mutex>      lock(mutex_dev_);
    for (auto& v: online_devices_)
    {
        if (v.dev_opts)
            v.dev_opts->update_data(nullptr, nullptr, false);
    }
}
const char* hg_scanner_mgr::last_open_message(void)
{
    return hg_scanner_mgr::last_open_msg_.c_str();
}