2023-03-22 09:37:40 +00:00
|
|
|
|
#include "scanner_manager.h"
|
2023-07-11 09:13:28 +00:00
|
|
|
|
|
|
|
|
|
#include "../../sdk/hginclude/utils.h"
|
|
|
|
|
#include <lang/app_language.h>
|
2022-05-03 03:56:07 +00:00
|
|
|
|
#include <iostream>
|
2023-09-23 01:15:57 +00:00
|
|
|
|
#include <fstream>
|
2022-05-03 03:56:07 +00:00
|
|
|
|
#include <string.h>
|
2023-07-20 09:10:31 +00:00
|
|
|
|
#include "../../../sdk/include/huagao/brand.h"
|
2022-05-03 03:56:07 +00:00
|
|
|
|
|
2023-09-22 07:43:53 +00:00
|
|
|
|
#include "user-opt/user.h"
|
|
|
|
|
#include "user-opt/offline_opt.h"
|
2023-10-31 06:51:14 +00:00
|
|
|
|
#include "user-opt/device_opt.h"
|
|
|
|
|
|
2023-09-22 07:43:53 +00:00
|
|
|
|
|
2022-09-23 02:26:04 +00:00
|
|
|
|
#if !defined(WIN32) && !defined(_WIN64)
|
|
|
|
|
#endif
|
|
|
|
|
|
2022-05-03 03:56:07 +00:00
|
|
|
|
// 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"
|
2022-08-18 06:50:43 +00:00
|
|
|
|
#include "hg_scanner_302.h"
|
2023-03-06 03:37:37 +00:00
|
|
|
|
|
2022-05-03 03:56:07 +00:00
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
|
/// supporting devices :
|
2022-10-08 09:18:17 +00:00
|
|
|
|
///
|
2023-01-31 08:01:27 +00:00
|
|
|
|
#define GET_LANG(str,b) from_default_language(str,b)
|
2022-05-03 03:56:07 +00:00
|
|
|
|
static struct
|
|
|
|
|
{
|
|
|
|
|
uint16_t vid; // vendor ID
|
|
|
|
|
uint16_t pid; // product ID
|
2023-09-21 03:23:38 +00:00
|
|
|
|
std::string name; // product name - type
|
|
|
|
|
std::string family; // product model - family
|
2022-05-03 03:56:07 +00:00
|
|
|
|
std::string rsc; // USB resource, version-addr. e.g. "USB2.0-1"
|
2023-11-01 07:12:11 +00:00
|
|
|
|
hg_scanner* (* create_scanner)(const char*/*name*/, const char*/*model*/, usb_io*, scanner_handle*);
|
2022-05-03 03:56:07 +00:00
|
|
|
|
}
|
2022-05-17 07:04:55 +00:00
|
|
|
|
g_supporting_devices[] = {
|
2023-01-18 02:35:40 +00:00
|
|
|
|
#ifdef OEM_LISICHENG
|
2023-07-20 09:10:31 +00:00
|
|
|
|
{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}
|
2022-07-11 08:30:30 +00:00
|
|
|
|
|
2023-01-18 02:35:40 +00:00
|
|
|
|
#elif defined(OEM_HANWANG)
|
2023-07-20 09:10:31 +00:00
|
|
|
|
{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"
|
2023-01-18 02:35:40 +00:00
|
|
|
|
#elif defined(OEM_CANGTIAN)
|
2023-07-20 09:10:31 +00:00
|
|
|
|
{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}
|
2023-06-07 08:41:16 +00:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2023-01-30 01:35:35 +00:00
|
|
|
|
#elif defined(OEM_ZHONGJING)
|
2023-07-20 09:10:31 +00:00
|
|
|
|
{0X05DA, 0x9220, PRODUCT_NAME_ZJ_9200, PRODUCT_FAMILY_ZJ_9200, "",& hg_scanner_mgr::create_scanner_g439}
|
2023-03-10 09:36:20 +00:00
|
|
|
|
#elif defined(OEM_ZIGUANG)
|
2023-07-20 09:10:31 +00:00
|
|
|
|
{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}
|
2023-04-20 09:34:14 +00:00
|
|
|
|
#elif defined(OEM_NEUTRAL)
|
2023-07-20 09:10:31 +00:00
|
|
|
|
{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}
|
2023-02-02 06:15:44 +00:00
|
|
|
|
#else
|
2023-07-20 09:10:31 +00:00
|
|
|
|
{0x3072, 0x100, PRODUCT_NAME_HG_G100, PRODUCT_FAMILY_HG_G100, "",& hg_scanner_mgr::create_scanner_g100}
|
2023-07-21 02:06:45 +00:00
|
|
|
|
, {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}
|
2023-07-20 09:10:31 +00:00
|
|
|
|
|
|
|
|
|
, {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}
|
2023-01-18 02:35:40 +00:00
|
|
|
|
#endif
|
2022-05-03 03:56:07 +00:00
|
|
|
|
};
|
2023-01-31 08:01:27 +00:00
|
|
|
|
bool islang = false;
|
2023-02-02 03:43:59 +00:00
|
|
|
|
//static std::string g_vendor = GET_LANG(COMPANY_NAME, &islang);
|
2022-05-03 03:56:07 +00:00
|
|
|
|
|
|
|
|
|
#define BRAND_LOGO_SIZE 8 * 1024
|
|
|
|
|
|
|
|
|
|
#define MOVE_TO_NEXT_STR(str) str += strlen(str) + 1
|
|
|
|
|
/// </summary>
|
|
|
|
|
|
|
|
|
|
|
2023-10-31 06:51:14 +00:00
|
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
// 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;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
//
|
2022-05-03 03:56:07 +00:00
|
|
|
|
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;
|
2022-09-23 02:26:04 +00:00
|
|
|
|
std::string hg_scanner_mgr::pe_path_("");
|
|
|
|
|
std::string hg_scanner_mgr::pe_name_("");
|
2023-07-02 06:13:55 +00:00
|
|
|
|
std::string hg_scanner_mgr::last_open_msg_("");
|
2022-10-18 01:22:47 +00:00
|
|
|
|
bool hg_scanner_mgr::read_over_with_eof_ = true;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
|
2023-01-28 07:19:10 +00:00
|
|
|
|
uint32_t hg_scanner_mgr::unique_img_id_ = 0;;
|
|
|
|
|
std::mutex hg_scanner_mgr::mutex_img_id;
|
|
|
|
|
|
2023-10-31 06:51:14 +00:00
|
|
|
|
hg_scanner_mgr::hg_scanner_mgr() : same_ind_(1), cf_name(""), dev_opts_(new device_option())
|
2022-05-03 03:56:07 +00:00
|
|
|
|
{
|
2023-07-11 09:13:28 +00:00
|
|
|
|
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());
|
|
|
|
|
|
|
|
|
|
buf[l] = 0;
|
|
|
|
|
cf_name = buf;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
usb_manager::instance()->register_hotplug(&hg_scanner_mgr::usb_event_handle, this);
|
2023-06-15 03:56:19 +00:00
|
|
|
|
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;
|
|
|
|
|
}
|
2023-09-22 07:43:53 +00:00
|
|
|
|
|
|
|
|
|
user_ = new hguser();
|
|
|
|
|
offline_ = new offline_opts(user_);
|
2023-10-31 06:51:14 +00:00
|
|
|
|
g_language = new lang_opt();
|
|
|
|
|
|
|
|
|
|
reset_device_opts();
|
2022-05-03 03:56:07 +00:00
|
|
|
|
}
|
|
|
|
|
hg_scanner_mgr::~hg_scanner_mgr()
|
|
|
|
|
{
|
2023-09-22 01:42:37 +00:00
|
|
|
|
usb_manager::instance()->register_hotplug(nullptr, nullptr);
|
2023-09-09 10:09:20 +00:00
|
|
|
|
{
|
|
|
|
|
std::lock_guard<std::mutex> lock(mutex_dev_);
|
|
|
|
|
for (auto& v : online_devices_)
|
|
|
|
|
libusb_unref_device(v.dev);
|
|
|
|
|
online_devices_.clear();
|
|
|
|
|
}
|
2023-10-31 06:51:14 +00:00
|
|
|
|
dev_opts_->clear();
|
|
|
|
|
delete dev_opts_;
|
|
|
|
|
|
2022-05-03 03:56:07 +00:00
|
|
|
|
usb_manager::clear();
|
2023-09-22 07:43:53 +00:00
|
|
|
|
offline_->release();
|
|
|
|
|
delete user_;
|
2023-10-31 06:51:14 +00:00
|
|
|
|
|
|
|
|
|
g_language->release();
|
2022-05-03 03:56:07 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
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)
|
2022-05-17 07:04:55 +00:00
|
|
|
|
// return si.freeram * si.mem_unit > *len + 200 * 1024 * 1024 ? SCANNER_ERR_OK : SCANNER_ERR_INSUFFICIENT_MEMORY;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
|
2022-05-17 07:04:55 +00:00
|
|
|
|
// return SCANNER_ERR_OK;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
// }
|
|
|
|
|
|
|
|
|
|
if (hg_scanner_mgr::event_callback_)
|
|
|
|
|
return hg_scanner_mgr::event_callback_(h, ev, data, len, param);
|
|
|
|
|
|
2022-05-17 07:04:55 +00:00
|
|
|
|
return SCANNER_ERR_OK;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
}
|
|
|
|
|
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;
|
2023-01-28 07:19:10 +00:00
|
|
|
|
hg_scanner_mgr::unique_img_id_ = (uint32_t)INT_MAX + 1;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
hg_scanner_mgr::inst_ = new hg_scanner_mgr();
|
2023-07-11 09:13:28 +00:00
|
|
|
|
utils::to_log(LOG_LEVEL_DEBUG, "async image transferring is %s\n", hg_scanner_mgr::async_io_enabled_ ? "enabled" : "disabled");
|
2022-05-03 03:56:07 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return hg_scanner_mgr::inst_;
|
|
|
|
|
}
|
|
|
|
|
void hg_scanner_mgr::clear(void)
|
|
|
|
|
{
|
2023-03-10 09:36:20 +00:00
|
|
|
|
if (hg_scanner_mgr::inst_)
|
2022-05-03 03:56:07 +00:00
|
|
|
|
{
|
2022-05-09 06:48:42 +00:00
|
|
|
|
{
|
|
|
|
|
std::lock_guard<std::mutex> lock(hg_scanner_mgr::inst_->mutex_dev_);
|
|
|
|
|
hg_scanner_mgr::event_callback_ = nullptr;
|
|
|
|
|
}
|
2022-05-03 03:56:07 +00:00
|
|
|
|
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;
|
|
|
|
|
}
|
2023-09-22 07:43:53 +00:00
|
|
|
|
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_;
|
|
|
|
|
}
|
2022-09-23 02:26:04 +00:00
|
|
|
|
void hg_scanner_mgr::set_exe_name(const char* path, const char* name)
|
|
|
|
|
{
|
2023-07-11 09:13:28 +00:00
|
|
|
|
std::string cfgf(utils::get_local_data_path() + PATH_SEPARATOR + "config" + PATH_SEPARATOR + "debug.cfg");
|
|
|
|
|
char buf[260] = {0};
|
|
|
|
|
int l = 0;
|
|
|
|
|
|
2022-09-23 02:26:04 +00:00
|
|
|
|
hg_scanner_mgr::pe_path_ = path ? path : "";
|
|
|
|
|
hg_scanner_mgr::pe_name_ = name ? name : "";
|
2023-07-11 09:13:28 +00:00
|
|
|
|
std::string str(utils::get_command_result("scanimage -V"));
|
2022-12-14 06:18:17 +00:00
|
|
|
|
bool is_scanimg =false;
|
2023-01-18 02:35:40 +00:00
|
|
|
|
is_scanimg = str >= "1.0.29" ? true : false;
|
2023-07-11 09:13:28 +00:00
|
|
|
|
utils::to_log(LOG_LEVEL_ALL, "imgascan ver is: %s is_scanimg is:%d\n", str.c_str(),is_scanimg);
|
2022-10-18 01:22:47 +00:00
|
|
|
|
if (name && *name)
|
|
|
|
|
{
|
2022-12-14 06:18:17 +00:00
|
|
|
|
// int ret = system("scanimage -V");
|
2023-07-11 09:13:28 +00:00
|
|
|
|
l = GetPrivateProfileStringA("read_eof", name, "", buf, _countof(buf) - 1, cfgf.c_str());
|
|
|
|
|
if (l == 0)
|
2022-12-14 06:18:17 +00:00
|
|
|
|
{
|
|
|
|
|
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);
|
|
|
|
|
}
|
2022-10-18 01:22:47 +00:00
|
|
|
|
else
|
2023-07-11 09:13:28 +00:00
|
|
|
|
hg_scanner_mgr::read_over_with_eof_ = strcmp(buf, "0") != 0;
|
2022-10-18 01:22:47 +00:00
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
2023-07-11 09:13:28 +00:00
|
|
|
|
l = GetPrivateProfileStringA("read_eof", "first", "", buf, _countof(buf) - 1, cfgf.c_str());
|
|
|
|
|
if (l == 0)
|
2022-10-18 01:22:47 +00:00
|
|
|
|
hg_scanner_mgr::read_over_with_eof_ = true;
|
|
|
|
|
else
|
2023-07-11 09:13:28 +00:00
|
|
|
|
hg_scanner_mgr::read_over_with_eof_ = strcmp(buf, "0") != 0;
|
2022-10-18 01:22:47 +00:00
|
|
|
|
}
|
|
|
|
|
|
2023-07-11 09:13:28 +00:00
|
|
|
|
utils::to_log(LOG_LEVEL_ALL, "read image data end with EOF: %s\n", hg_scanner_mgr::read_over_with_eof_ ? "true" : "false");
|
2022-09-23 02:26:04 +00:00
|
|
|
|
}
|
|
|
|
|
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_;
|
|
|
|
|
}
|
2023-01-28 07:19:10 +00:00
|
|
|
|
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;
|
|
|
|
|
}
|
2022-05-03 03:56:07 +00:00
|
|
|
|
|
2023-11-01 07:12:11 +00:00
|
|
|
|
hg_scanner* hg_scanner_mgr::create_scanner_empty(const char* name, const char* family, usb_io* io, scanner_handle* h)
|
2022-07-13 10:22:31 +00:00
|
|
|
|
{
|
|
|
|
|
if (h)
|
|
|
|
|
*h = nullptr;
|
|
|
|
|
|
|
|
|
|
return nullptr;
|
|
|
|
|
}
|
2023-11-01 07:12:11 +00:00
|
|
|
|
hg_scanner* hg_scanner_mgr::create_scanner_g100(const char* name, const char* family, usb_io* io, scanner_handle* h)
|
2022-07-13 10:22:31 +00:00
|
|
|
|
{
|
2023-11-01 07:12:11 +00:00
|
|
|
|
hg_scanner_200* s = new hg_scanner_200(name, family, 0x100, io);
|
2022-07-13 10:22:31 +00:00
|
|
|
|
|
|
|
|
|
if (h)
|
|
|
|
|
*h = s;
|
|
|
|
|
|
|
|
|
|
return dynamic_cast<hg_scanner*>(s);
|
|
|
|
|
}
|
2023-11-01 07:12:11 +00:00
|
|
|
|
hg_scanner* hg_scanner_mgr::create_scanner_g239(const char* name, const char* family, usb_io* io, scanner_handle* h)
|
2022-07-13 10:22:31 +00:00
|
|
|
|
{
|
2023-11-01 07:12:11 +00:00
|
|
|
|
hg_scanner_239* s = new hg_scanner_239(name, family, 0x239, io);
|
2022-07-13 10:22:31 +00:00
|
|
|
|
|
|
|
|
|
if (h)
|
|
|
|
|
*h = s;
|
|
|
|
|
|
|
|
|
|
return dynamic_cast<hg_scanner*>(s);
|
|
|
|
|
}
|
2023-11-01 07:12:11 +00:00
|
|
|
|
hg_scanner* hg_scanner_mgr::create_scanner_g300(const char* name, const char* family, usb_io* io, scanner_handle* h)
|
2022-07-13 10:22:31 +00:00
|
|
|
|
{
|
2023-11-01 07:12:11 +00:00
|
|
|
|
hg_scanner_300* s = new hg_scanner_300(name, family, 0x300, io);
|
2022-07-13 10:22:31 +00:00
|
|
|
|
|
|
|
|
|
if (h)
|
|
|
|
|
*h = s;
|
|
|
|
|
|
|
|
|
|
return dynamic_cast<hg_scanner*>(s);
|
|
|
|
|
}
|
2023-11-01 07:12:11 +00:00
|
|
|
|
hg_scanner* hg_scanner_mgr::create_scanner_g400(const char* name, const char* family, usb_io* io, scanner_handle* h)
|
2022-08-18 06:50:43 +00:00
|
|
|
|
{
|
2023-11-01 07:12:11 +00:00
|
|
|
|
hg_scanner_300* s = new hg_scanner_300(name, family, 0x400, io);
|
2022-08-18 06:50:43 +00:00
|
|
|
|
|
|
|
|
|
if (h)
|
|
|
|
|
*h = s;
|
|
|
|
|
|
|
|
|
|
return dynamic_cast<hg_scanner*>(s);
|
|
|
|
|
}
|
2023-11-01 07:12:11 +00:00
|
|
|
|
hg_scanner* hg_scanner_mgr::create_scanner_g302(const char* name, const char* family, usb_io* io, scanner_handle* h)
|
2022-07-13 10:22:31 +00:00
|
|
|
|
{
|
2023-11-01 07:12:11 +00:00
|
|
|
|
hg_scanner_302* s = new hg_scanner_302(name, family, 0x302, io); // image_process needs PID 402, we should add 302 ...
|
2022-07-13 10:22:31 +00:00
|
|
|
|
|
|
|
|
|
if (h)
|
|
|
|
|
*h = s;
|
|
|
|
|
|
|
|
|
|
return dynamic_cast<hg_scanner*>(s);
|
|
|
|
|
}
|
2023-11-01 07:12:11 +00:00
|
|
|
|
hg_scanner* hg_scanner_mgr::create_scanner_g402(const char* name, const char* family, usb_io* io, scanner_handle* h)
|
2022-07-13 10:22:31 +00:00
|
|
|
|
{
|
2023-11-01 07:12:11 +00:00
|
|
|
|
hg_scanner_302* s = new hg_scanner_302(name, family, 0x402, io);
|
2022-07-13 10:22:31 +00:00
|
|
|
|
|
|
|
|
|
if (h)
|
|
|
|
|
*h = s;
|
|
|
|
|
|
|
|
|
|
return dynamic_cast<hg_scanner*>(s);
|
|
|
|
|
}
|
2023-11-01 07:12:11 +00:00
|
|
|
|
hg_scanner* hg_scanner_mgr::create_scanner_g439(const char* name, const char* family, usb_io* io, scanner_handle* h)
|
2022-11-26 03:22:39 +00:00
|
|
|
|
{
|
2023-11-01 07:12:11 +00:00
|
|
|
|
hg_scanner_239* s = new hg_scanner_239(name, family, 0x439, io);
|
2022-11-26 03:22:39 +00:00
|
|
|
|
|
|
|
|
|
if (h)
|
|
|
|
|
*h = s;
|
2022-07-13 10:22:31 +00:00
|
|
|
|
|
2022-11-26 03:22:39 +00:00
|
|
|
|
return dynamic_cast<hg_scanner*>(s);
|
|
|
|
|
}
|
2022-05-03 03:56:07 +00:00
|
|
|
|
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("");
|
2022-05-09 06:48:42 +00:00
|
|
|
|
std::lock_guard<std::mutex> lock(mutex_dev_);
|
2022-05-03 03:56:07 +00:00
|
|
|
|
|
|
|
|
|
sprintf(model, "%x", pid);
|
|
|
|
|
sprintf(vendor, "%x", vid);
|
|
|
|
|
de.model = model;
|
|
|
|
|
de.name = NULL;
|
2023-09-21 03:23:38 +00:00
|
|
|
|
de.family = NULL;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
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)
|
|
|
|
|
{
|
2023-09-23 01:15:57 +00:00
|
|
|
|
// 064B 澶氬彴璁惧浣跨敤杩欎釜vid锛屾墍浠ュ姞杞芥椂涓嶄細娓呮瑕佹墦寮€鍝竴鍙拌澶囷紝鍙湁閫氳繃澶栭儴杩涜鍔犺浇鏀瑰彉瀹炰<E780B9>?
|
2022-05-03 03:56:07 +00:00
|
|
|
|
if (g_supporting_devices[i].vid == vid && g_supporting_devices[i].pid == pid)
|
|
|
|
|
{
|
|
|
|
|
index = i;
|
|
|
|
|
ev_ui = SANE_EVENT_DEVICE_ARRIVED;
|
2022-08-06 12:43:07 +00:00
|
|
|
|
name = g_supporting_devices[i].name.c_str();
|
2023-09-21 03:23:38 +00:00
|
|
|
|
type = g_supporting_devices[i].family.c_str();
|
2023-06-12 12:06:28 +00:00
|
|
|
|
|
|
|
|
|
if (vid == 0x064B && !cf_name.empty())
|
|
|
|
|
{
|
2023-09-21 03:23:38 +00:00
|
|
|
|
if (cf_name == g_supporting_devices[i].family)
|
2023-06-12 12:06:28 +00:00
|
|
|
|
{
|
|
|
|
|
name = g_supporting_devices[i].name.c_str();
|
2023-09-21 03:23:38 +00:00
|
|
|
|
type = g_supporting_devices[i].family.c_str();
|
2023-06-12 12:06:28 +00:00
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
break;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (index != -1)
|
|
|
|
|
{
|
|
|
|
|
bool add = true;
|
2022-07-04 08:30:01 +00:00
|
|
|
|
size_t i = 0;
|
|
|
|
|
for (; i < online_devices_.size(); ++i)
|
2022-05-03 03:56:07 +00:00
|
|
|
|
{
|
2023-06-15 10:27:31 +00:00
|
|
|
|
if (online_devices_[i].dev == device) // 姝ゅ鍋囧畾鍚屼竴鍙拌澶囬噸鏂拌繛鎺ュ悗锛岃澶囧璞♀€渄evice鈥濅繚鎸佷笉鍙橈紱濡傛灉鍋囪涓嶆垚绔嬶紝浼氬鑷磋澶囬噸杩炴秷鎭笉鑳芥甯告帴鏀讹紝缁戝畾鍒拌璁惧鐨剆canner瀵硅薄寰椾笉鍒伴噴鏀?
|
2022-05-03 03:56:07 +00:00
|
|
|
|
{
|
|
|
|
|
online_devices_[i].ind = index;
|
|
|
|
|
add = false;
|
|
|
|
|
break;
|
|
|
|
|
}
|
2022-07-04 08:30:01 +00:00
|
|
|
|
}
|
2023-09-23 01:15:57 +00:00
|
|
|
|
if (add) // 澶勭悊瀵硅薄鈥渄evice鈥濇敼鍙樼殑鎯呮<E98EAF>?
|
2022-07-04 08:30:01 +00:00
|
|
|
|
{
|
|
|
|
|
i = 0;
|
|
|
|
|
for (auto& v : online_devices_)
|
2022-05-03 03:56:07 +00:00
|
|
|
|
{
|
2022-07-04 08:30:01 +00:00
|
|
|
|
if (v.ind == index &&
|
2022-10-20 10:18:24 +00:00
|
|
|
|
(v.scanner && !v.scanner->is_online()))
|
2022-05-03 03:56:07 +00:00
|
|
|
|
{
|
2022-07-04 08:30:01 +00:00
|
|
|
|
add = false;
|
|
|
|
|
break;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
}
|
2022-07-04 08:30:01 +00:00
|
|
|
|
i++;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (add)
|
|
|
|
|
{
|
|
|
|
|
OLSCANNER ols;
|
|
|
|
|
|
|
|
|
|
ols.dev = device;
|
|
|
|
|
ols.ind = index;
|
|
|
|
|
ols.scanner = NULL;
|
|
|
|
|
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;
|
|
|
|
|
}
|
2022-07-04 08:30:01 +00:00
|
|
|
|
libusb_ref_device(ols.dev); // ref to the device of queue online_devices_
|
2022-05-03 03:56:07 +00:00
|
|
|
|
online_devices_.push_back(ols);
|
|
|
|
|
name = ols.display_name;
|
2023-07-11 09:13:28 +00:00
|
|
|
|
utils::to_log(LOG_LEVEL_DEBUG, "%s connected.\n", name.c_str());
|
2023-09-21 03:23:38 +00:00
|
|
|
|
type = g_supporting_devices[ols.ind].family;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
}
|
2022-07-04 08:30:01 +00:00
|
|
|
|
else if (online_devices_[i].scanner && !online_devices_[i].scanner->is_online())
|
|
|
|
|
{
|
|
|
|
|
usb_io* io = NULL;
|
|
|
|
|
|
|
|
|
|
name = online_devices_[i].display_name;
|
2023-09-21 03:23:38 +00:00
|
|
|
|
type = g_supporting_devices[index].family;
|
2022-07-04 08:30:01 +00:00
|
|
|
|
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);
|
2023-07-11 09:13:28 +00:00
|
|
|
|
utils::to_log(LOG_LEVEL_WARNING, "[%04x:%04x]%s re-connected.\n", pid, vid, online_devices_[i].display_name.c_str());
|
2022-07-04 08:30:01 +00:00
|
|
|
|
if (len == SCANNER_ERR_OK)
|
|
|
|
|
{
|
|
|
|
|
online_devices_[i].scanner->reset_io(io);
|
|
|
|
|
de.openned = SANE_TRUE;
|
|
|
|
|
}
|
|
|
|
|
if (io)
|
|
|
|
|
io->release();
|
|
|
|
|
add = false;
|
|
|
|
|
}
|
2022-05-03 03:56:07 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
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;
|
2023-09-21 03:23:38 +00:00
|
|
|
|
type = g_supporting_devices[it->ind].family;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
h = it->scanner;
|
2023-07-11 09:13:28 +00:00
|
|
|
|
utils::to_log(LOG_LEVEL_DEBUG, "%s Dis-connected.\n", name.c_str());
|
2022-05-03 03:56:07 +00:00
|
|
|
|
if (it->scanner)
|
|
|
|
|
it->scanner->io_disconnected();
|
|
|
|
|
else
|
2022-07-04 08:30:01 +00:00
|
|
|
|
{
|
|
|
|
|
libusb_unref_device(it->dev); // unref the device of queue online_devices_
|
2022-05-03 03:56:07 +00:00
|
|
|
|
online_devices_.erase(it);
|
2022-07-04 08:30:01 +00:00
|
|
|
|
}
|
2022-05-03 03:56:07 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (ev_ui)
|
|
|
|
|
{
|
|
|
|
|
de.name = name.c_str();
|
2023-09-21 03:23:38 +00:00
|
|
|
|
de.family = type.c_str();
|
2022-05-03 03:56:07 +00:00
|
|
|
|
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_;
|
|
|
|
|
}
|
2023-10-31 06:51:14 +00:00
|
|
|
|
void hg_scanner_mgr::reset_device_opts(sane_opt_provider* scanner)
|
|
|
|
|
{
|
|
|
|
|
dev_opts_->clear();
|
|
|
|
|
|
|
|
|
|
// Four sources: offline, language, algorithm, scanner
|
|
|
|
|
dev_opts_->add(dynamic_cast<sane_opt_provider*>(offline_));
|
|
|
|
|
dev_opts_->add(dynamic_cast<sane_opt_provider*>(g_language));
|
|
|
|
|
|
|
|
|
|
if (scanner)
|
2023-10-31 10:04:26 +00:00
|
|
|
|
{
|
2023-10-31 06:51:14 +00:00
|
|
|
|
dev_opts_->add(scanner);
|
2023-10-31 10:04:26 +00:00
|
|
|
|
dev_opts_->restore(scanner);
|
|
|
|
|
}
|
2023-10-31 06:51:14 +00:00
|
|
|
|
}
|
2022-05-03 03:56:07 +00:00
|
|
|
|
|
|
|
|
|
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)
|
|
|
|
|
{
|
2022-05-11 01:36:23 +00:00
|
|
|
|
#ifdef BRAND_DISPLAY_ALL_EXPAND
|
|
|
|
|
if (!info || *info == 0)
|
2023-01-31 08:01:27 +00:00
|
|
|
|
info = GET_LANG(BRAND_COMMUNICATION_FAIL,&islang);
|
2022-05-11 01:36:23 +00:00
|
|
|
|
#endif
|
|
|
|
|
|
2022-05-03 03:56:07 +00:00
|
|
|
|
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
|
2023-02-21 06:07:43 +00:00
|
|
|
|
{
|
|
|
|
|
about->appendix[count].url = NULL;
|
|
|
|
|
count++;
|
|
|
|
|
}
|
2022-05-03 03:56:07 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
2022-05-17 07:04:55 +00:00
|
|
|
|
scanner_err hg_scanner_mgr::get_about_info(scanner_handle h, void* data, unsigned* len)
|
2022-05-03 03:56:07 +00:00
|
|
|
|
{
|
|
|
|
|
hg_scanner* scanner = (hg_scanner*)h;
|
|
|
|
|
unsigned bytes = sizeof(SANE_About) + 40;
|
|
|
|
|
SANE_About tmp;
|
2023-02-21 06:07:43 +00:00
|
|
|
|
size_t append_cnt = 1;
|
2023-06-15 03:56:19 +00:00
|
|
|
|
|
2022-05-03 03:56:07 +00:00
|
|
|
|
|
2023-09-25 05:30:53 +00:00
|
|
|
|
//bytes += sizeof(g_logo);
|
2023-02-21 06:07:43 +00:00
|
|
|
|
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++;
|
2023-06-15 03:13:34 +00:00
|
|
|
|
bytes += strlen(GET_LANG(url_en.c_str(), &islang)) + 8; append_cnt++;
|
2023-06-14 10:04:29 +00:00
|
|
|
|
|
|
|
|
|
|
2023-06-15 03:56:19 +00:00
|
|
|
|
bytes += strlen(GET_LANG(url_link_en.c_str(), &islang)) + 8; append_cnt++;
|
2023-02-21 06:07:43 +00:00
|
|
|
|
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++;
|
2022-05-11 01:36:23 +00:00
|
|
|
|
// bytes += 5 * sizeof(tmp.appendix[0]);
|
2022-05-03 03:56:07 +00:00
|
|
|
|
|
2022-05-11 01:36:23 +00:00
|
|
|
|
#ifndef BRAND_DISPLAY_ALL_EXPAND
|
2022-05-03 03:56:07 +00:00
|
|
|
|
if (scanner)
|
2022-05-11 01:36:23 +00:00
|
|
|
|
#endif
|
2022-05-03 03:56:07 +00:00
|
|
|
|
{
|
2023-04-26 06:59:34 +00:00
|
|
|
|
bytes += sizeof(tmp.appendix[0]) + BRAND_INFO_MAX_LENGTH + 8 + strlen(GET_LANG(BRAND_SOFTWARE_VERSION, &islang)) + 8;
|
2023-02-21 06:07:43 +00:00
|
|
|
|
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++;
|
2023-08-21 08:09:57 +00:00
|
|
|
|
bytes += sizeof(tmp.appendix[0]) + 28 + strlen(GET_LANG(BRAND_TITLE_DEVICE_INITIAL_POWER_ON_TIME, &islang)) + 8; append_cnt++;
|
2023-02-21 06:07:43 +00:00
|
|
|
|
bytes += sizeof(tmp.appendix[0]); append_cnt++;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!data || *len < bytes)
|
|
|
|
|
{
|
|
|
|
|
*len = bytes;
|
|
|
|
|
|
2022-05-17 07:04:55 +00:00
|
|
|
|
return SCANNER_ERR_INSUFFICIENT_MEMORY;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// filling info to flat buffer ...
|
|
|
|
|
SANE_About* about = (SANE_About*)data;
|
|
|
|
|
std::string info("");
|
2023-02-21 06:07:43 +00:00
|
|
|
|
char* ptr = (char*)data + sizeof(SANE_About) + append_cnt * sizeof(about->appendix[0]);
|
2022-05-03 03:56:07 +00:00
|
|
|
|
|
|
|
|
|
about->title = ptr;
|
2023-01-31 08:01:27 +00:00
|
|
|
|
strcpy(ptr, GET_LANG(BRAND_APP_NAME,&islang));
|
2022-05-03 03:56:07 +00:00
|
|
|
|
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;
|
2023-02-02 03:43:59 +00:00
|
|
|
|
std::string s = GET_LANG(BRAND_COPYRIGHT, &islang);
|
|
|
|
|
strcpy(ptr, s.c_str());
|
2022-05-03 03:56:07 +00:00
|
|
|
|
MOVE_TO_NEXT_STR(ptr);
|
|
|
|
|
|
2023-09-25 05:30:53 +00:00
|
|
|
|
//about->logo_bytes = sizeof(g_logo);;
|
|
|
|
|
//about->logo = ptr;
|
|
|
|
|
//memcpy(ptr, g_logo, about->logo_bytes);
|
2022-05-03 03:56:07 +00:00
|
|
|
|
ptr += about->logo_bytes + 1;
|
|
|
|
|
|
2022-11-11 09:59:08 +00:00
|
|
|
|
int count = 0, rolls = 0, ret = SCANNER_ERR_OK;
|
2023-04-26 06:59:34 +00:00
|
|
|
|
#ifdef TEST
|
|
|
|
|
set_appendix_info_for_about(about, ptr, count, GET_LANG(BRAND_SOFTWARE_VERSION, &islang), BRAND_SOFTWARE_VERSION_TEST, NULL);
|
|
|
|
|
#endif
|
2023-02-02 03:43:59 +00:00
|
|
|
|
std::string g_vendor = GET_LANG(COMPANY_NAME, &islang);
|
2023-01-31 08:01:27 +00:00
|
|
|
|
set_appendix_info_for_about(about, ptr, count, GET_LANG(BRAND_TITE_MANUFACTOR,&islang), g_vendor.c_str(), NULL);
|
2023-06-15 03:56:19 +00:00
|
|
|
|
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));
|
2023-01-31 08:01:27 +00:00
|
|
|
|
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);
|
2023-06-14 10:04:29 +00:00
|
|
|
|
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));
|
|
|
|
|
|
|
|
|
|
}
|
2022-05-03 03:56:07 +00:00
|
|
|
|
|
|
|
|
|
if (scanner)
|
2023-04-26 06:59:34 +00:00
|
|
|
|
{
|
2023-01-31 08:01:27 +00:00
|
|
|
|
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);
|
2022-07-25 02:38:20 +00:00
|
|
|
|
info = scanner->get_ip();
|
2023-02-21 01:54:26 +00:00
|
|
|
|
if (info.length() > 10 && !info.empty())
|
2023-01-31 08:01:27 +00:00
|
|
|
|
set_appendix_info_for_about(about, ptr, count, GET_LANG(BRAND_TITLE_IP,&islang), info.c_str(), NULL);
|
2023-02-03 02:30:57 +00:00
|
|
|
|
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);
|
2023-08-21 08:09:57 +00:00
|
|
|
|
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);
|
|
|
|
|
}
|
2022-11-11 09:59:08 +00:00
|
|
|
|
ret = scanner->get_roller_num(rolls);
|
|
|
|
|
if (ret == SCANNER_ERR_OK)
|
2022-05-03 03:56:07 +00:00
|
|
|
|
{
|
|
|
|
|
char buf[40];
|
|
|
|
|
sprintf(buf, "%u", rolls);
|
2023-01-31 08:01:27 +00:00
|
|
|
|
set_appendix_info_for_about(about, ptr, count, GET_LANG(BRAND_TITLE_ROLLER_COUNT,&islang), buf, NULL);
|
2022-05-13 08:39:21 +00:00
|
|
|
|
}
|
|
|
|
|
#ifdef BRAND_DISPLAY_ALL_EXPAND
|
|
|
|
|
else
|
2023-01-31 08:01:27 +00:00
|
|
|
|
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);
|
2022-05-13 08:39:21 +00:00
|
|
|
|
#endif
|
|
|
|
|
|
2022-12-29 10:05:59 +00:00
|
|
|
|
ret = scanner->get_history_scan_count(rolls);
|
2022-11-11 09:59:08 +00:00
|
|
|
|
if (ret == SCANNER_ERR_OK)
|
2022-05-13 08:39:21 +00:00
|
|
|
|
{
|
|
|
|
|
char buf[40];
|
|
|
|
|
sprintf(buf, "%u", rolls);
|
2023-01-31 08:01:27 +00:00
|
|
|
|
set_appendix_info_for_about(about, ptr, count, GET_LANG(BRAND_TITLE_HISTORY_COUNT,&islang), buf, NULL);
|
2022-05-13 08:39:21 +00:00
|
|
|
|
}
|
2022-05-11 01:36:23 +00:00
|
|
|
|
#ifdef BRAND_DISPLAY_ALL_EXPAND
|
|
|
|
|
else
|
2023-01-31 08:01:27 +00:00
|
|
|
|
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);
|
2022-05-11 01:36:23 +00:00
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
#ifdef BRAND_DISPLAY_ALL_EXPAND
|
|
|
|
|
else
|
|
|
|
|
{
|
2023-01-31 08:01:27 +00:00
|
|
|
|
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);
|
2022-05-03 03:56:07 +00:00
|
|
|
|
}
|
2022-05-11 01:36:23 +00:00
|
|
|
|
#endif
|
|
|
|
|
|
2022-05-03 03:56:07 +00:00
|
|
|
|
about->appendix[count].key = NULL;
|
|
|
|
|
about->appendix[count].content = NULL;
|
|
|
|
|
about->appendix[count].url = NULL;
|
|
|
|
|
|
2022-05-17 07:04:55 +00:00
|
|
|
|
return SCANNER_ERR_OK;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
}
|
|
|
|
|
|
2022-05-17 07:04:55 +00:00
|
|
|
|
scanner_err hg_scanner_mgr::hg_scanner_enum(ScannerInfo* scanner_list, long* count, bool local_only)
|
2022-05-03 03:56:07 +00:00
|
|
|
|
{
|
|
|
|
|
std::vector<OLSCANNER> devusbuf;
|
|
|
|
|
long size = *count;
|
2022-05-17 07:04:55 +00:00
|
|
|
|
scanner_err ret = SCANNER_ERR_OK;
|
2023-07-26 01:07:44 +00:00
|
|
|
|
std::string g_vendor(from_default_language(COMPANY_NAME, nullptr));
|
2022-05-03 03:56:07 +00:00
|
|
|
|
get_online_devices(devusbuf);
|
|
|
|
|
*count = devusbuf.size();
|
2023-07-26 01:07:44 +00:00
|
|
|
|
utils::to_log(LOG_LEVEL_ALL, "current language(%d) of '%s' is '%s'\n", lang_get_cur_code_page(), COMPANY_NAME, g_vendor.c_str());
|
2022-05-03 03:56:07 +00:00
|
|
|
|
if (*count > size)
|
|
|
|
|
{
|
2022-05-17 07:04:55 +00:00
|
|
|
|
ret = SCANNER_ERR_INSUFFICIENT_MEMORY;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
for (size_t i = 0; i < devusbuf.size(); i++)
|
|
|
|
|
{
|
2022-06-15 03:05:36 +00:00
|
|
|
|
scanner_list->vid = g_supporting_devices[devusbuf[i].ind].vid;
|
|
|
|
|
scanner_list->pid = g_supporting_devices[devusbuf[i].ind].pid;
|
2022-10-20 10:18:24 +00:00
|
|
|
|
strcpy(scanner_list->name, devusbuf[i].display_name.c_str());
|
2023-09-21 03:23:38 +00:00
|
|
|
|
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());
|
2022-05-03 03:56:07 +00:00
|
|
|
|
strcpy(scanner_list->vendor, g_vendor.c_str());
|
|
|
|
|
scanner_list++;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
2022-05-17 07:04:55 +00:00
|
|
|
|
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)
|
2022-05-03 03:56:07 +00:00
|
|
|
|
{
|
|
|
|
|
std::vector<OLSCANNER> devs;
|
|
|
|
|
std::vector<OLSCANNER>::iterator it;
|
|
|
|
|
usb_io* io = NULL;
|
2022-05-17 07:04:55 +00:00
|
|
|
|
scanner_err ret = SCANNER_ERR_DEVICE_NOT_FOUND;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
|
|
|
|
|
*h = NULL;
|
|
|
|
|
get_online_devices(devs);
|
|
|
|
|
it = std::find(devs.begin(), devs.end(), name);
|
|
|
|
|
if (it != devs.end())
|
|
|
|
|
{
|
2023-07-02 06:13:55 +00:00
|
|
|
|
hg_scanner_mgr::last_open_msg_ = "";
|
|
|
|
|
ret = (scanner_err)usb_manager::instance()->open(it->dev, &io, &hg_scanner_mgr::last_open_msg_);
|
2022-05-17 07:04:55 +00:00
|
|
|
|
if (ret == SCANNER_ERR_OK)
|
2022-05-03 03:56:07 +00:00
|
|
|
|
{
|
2023-11-01 07:12:11 +00:00
|
|
|
|
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);
|
2022-05-03 03:56:07 +00:00
|
|
|
|
|
|
|
|
|
if (scanner)
|
2022-09-23 02:26:04 +00:00
|
|
|
|
{
|
2022-05-03 03:56:07 +00:00
|
|
|
|
scanner->set_ui_callback(&hg_scanner_mgr::ui_default_callback, hg_scanner_mgr::async_io_enabled_);
|
2023-09-21 03:23:38 +00:00
|
|
|
|
scanner->set_dev_family(g_supporting_devices[it->ind].family.c_str());
|
2022-10-18 01:22:47 +00:00
|
|
|
|
scanner->set_read_over_with_no_data(hg_scanner_mgr::read_over_with_eof_);
|
2023-10-31 06:51:14 +00:00
|
|
|
|
|
|
|
|
|
reset_device_opts(dynamic_cast<sane_opt_provider*>(scanner));
|
2022-09-23 02:26:04 +00:00
|
|
|
|
}
|
2022-05-03 03:56:07 +00:00
|
|
|
|
|
|
|
|
|
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())
|
|
|
|
|
ptr->scanner = (hg_scanner*)*h;
|
|
|
|
|
}
|
2023-07-02 06:13:55 +00:00
|
|
|
|
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);
|
2022-05-03 03:56:07 +00:00
|
|
|
|
|
|
|
|
|
if(io)
|
|
|
|
|
io->release();
|
|
|
|
|
}
|
|
|
|
|
|
2022-05-26 09:17:37 +00:00
|
|
|
|
return *h ? SCANNER_ERR_OK : ret;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
}
|
2022-05-17 07:04:55 +00:00
|
|
|
|
scanner_err hg_scanner_mgr::hg_scanner_close(scanner_handle h, bool force)
|
2022-05-03 03:56:07 +00:00
|
|
|
|
{
|
|
|
|
|
{
|
|
|
|
|
std::lock_guard<std::mutex> lock(mutex_dev_);
|
|
|
|
|
for (size_t i = 0; i < online_devices_.size(); ++i)
|
|
|
|
|
{
|
|
|
|
|
if (online_devices_[i].scanner == h)
|
|
|
|
|
{
|
|
|
|
|
online_devices_[i].scanner = NULL;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2023-10-31 06:51:14 +00:00
|
|
|
|
reset_device_opts();
|
2022-05-03 03:56:07 +00:00
|
|
|
|
SCAN_PTR(h)->close(force);
|
2023-10-31 06:51:14 +00:00
|
|
|
|
SCAN_PTR(h)->release();
|
|
|
|
|
//delete SCAN_PTR(h);
|
2022-05-03 03:56:07 +00:00
|
|
|
|
|
2022-05-17 07:04:55 +00:00
|
|
|
|
return SCANNER_ERR_OK;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
}
|
2023-09-09 10:09:20 +00:00
|
|
|
|
scanner_err hg_scanner_mgr::hg_scanner_get_parameter(scanner_handle h, const char* name, char* data, long* len, int type)
|
2022-05-03 03:56:07 +00:00
|
|
|
|
{
|
2023-10-31 06:51:14 +00:00
|
|
|
|
scanner_err err = SCANNER_ERR_INVALID_PARAMETER;
|
2023-05-13 08:26:43 +00:00
|
|
|
|
|
2023-10-31 06:51:14 +00:00
|
|
|
|
if (len)
|
2023-09-22 07:43:53 +00:00
|
|
|
|
{
|
2023-10-31 06:51:14 +00:00
|
|
|
|
std::string raw(dev_opts_->get_option_value(name == PARAM_ALL ? nullptr : name, type, nullptr, data));
|
2023-05-13 08:26:43 +00:00
|
|
|
|
|
2023-10-31 06:51:14 +00:00
|
|
|
|
if (*len < raw.length())
|
2023-05-13 08:26:43 +00:00
|
|
|
|
{
|
2023-10-31 06:51:14 +00:00
|
|
|
|
*len = raw.length();
|
2023-05-13 08:26:43 +00:00
|
|
|
|
|
2023-10-31 06:51:14 +00:00
|
|
|
|
err = SCANNER_ERR_INSUFFICIENT_MEMORY;
|
2023-05-13 08:26:43 +00:00
|
|
|
|
}
|
2023-10-31 06:51:14 +00:00
|
|
|
|
else
|
2023-11-01 07:12:11 +00:00
|
|
|
|
{
|
2023-10-31 06:51:14 +00:00
|
|
|
|
memcpy(data, raw.c_str(), raw.length());
|
2023-11-01 07:12:11 +00:00
|
|
|
|
if (*len > raw.length())
|
|
|
|
|
data[raw.length()] = 0;
|
2023-10-31 06:51:14 +00:00
|
|
|
|
*len = raw.length();
|
|
|
|
|
err = SCANNER_ERR_OK;
|
2023-10-31 10:04:26 +00:00
|
|
|
|
#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
|
2023-06-13 04:28:20 +00:00
|
|
|
|
}
|
2023-05-13 08:26:43 +00:00
|
|
|
|
}
|
|
|
|
|
|
2023-09-22 07:43:53 +00:00
|
|
|
|
return err;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
}
|
2023-09-09 10:09:20 +00:00
|
|
|
|
scanner_err hg_scanner_mgr::hg_scanner_set_parameter(scanner_handle h, const char* name, void* data, bool to_default)
|
2022-05-03 03:56:07 +00:00
|
|
|
|
{
|
2023-10-31 06:51:14 +00:00
|
|
|
|
scanner_err err = SCANNER_ERR_OK, se = SCANNER_ERR_OK;
|
|
|
|
|
std::string init("");
|
2023-05-13 08:26:43 +00:00
|
|
|
|
|
2023-10-31 06:51:14 +00:00
|
|
|
|
// do restore here ?
|
|
|
|
|
if (name && strcmp(name, SANE_STD_OPT_NAME_RESTORE) == 0)
|
2023-09-22 07:43:53 +00:00
|
|
|
|
{
|
2023-11-01 07:12:11 +00:00
|
|
|
|
sane_opt_provider* sop = dynamic_cast<sane_opt_provider*>(SCAN_PTR(h));
|
|
|
|
|
err = (scanner_err)dev_opts_->restore(sop);
|
2023-11-03 10:03:22 +00:00
|
|
|
|
utils::to_log(LOG_LEVEL_DEBUG, "Restore all options ...\n");
|
2023-09-22 07:43:53 +00:00
|
|
|
|
}
|
2023-10-31 06:51:14 +00:00
|
|
|
|
else
|
2023-09-22 07:43:53 +00:00
|
|
|
|
{
|
2023-11-04 09:41:26 +00:00
|
|
|
|
// 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;
|
|
|
|
|
|
2023-10-31 06:51:14 +00:00
|
|
|
|
if (to_default)
|
2023-05-13 08:26:43 +00:00
|
|
|
|
{
|
2023-10-31 06:51:14 +00:00
|
|
|
|
int size = 0;
|
|
|
|
|
init = dev_opts_->get_option_value(name, SANE_ACTION_GET_DEFAULT_VALUE, &size);
|
|
|
|
|
if (size > init.length())
|
2023-05-13 08:26:43 +00:00
|
|
|
|
{
|
2023-10-31 06:51:14 +00:00
|
|
|
|
std::string t(std::move(init));
|
|
|
|
|
init.reserve(size);
|
|
|
|
|
memset(&init[0], 0, size);
|
|
|
|
|
memcpy(&init[0], &t[0], t.length());
|
2023-05-13 08:26:43 +00:00
|
|
|
|
}
|
2023-10-31 06:51:14 +00:00
|
|
|
|
data = &init[0];
|
2023-09-09 10:09:20 +00:00
|
|
|
|
}
|
2023-10-31 06:51:14 +00:00
|
|
|
|
else
|
2023-06-17 08:52:39 +00:00
|
|
|
|
{
|
2023-11-04 09:41:26 +00:00
|
|
|
|
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);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2023-10-31 06:51:14 +00:00
|
|
|
|
err = dev_opts_->refine_data(name, data) ? SCANNER_ERR_NOT_EXACT : SCANNER_ERR_OK;
|
2023-06-17 08:52:39 +00:00
|
|
|
|
}
|
2023-10-31 06:51:14 +00:00
|
|
|
|
se = (scanner_err)dev_opts_->update_data(name, data);
|
2023-11-04 09:41:26 +00:00
|
|
|
|
|
2023-10-31 06:51:14 +00:00
|
|
|
|
if (se != SCANNER_ERR_OK)
|
|
|
|
|
err = se;
|
2023-11-04 09:41:26 +00:00
|
|
|
|
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");
|
|
|
|
|
dev_opts_->refine_data(SANE_STD_OPT_NAME_LATERAL, &lateral);
|
|
|
|
|
dev_opts_->update_data(SANE_STD_OPT_NAME_LATERAL, &lateral);
|
|
|
|
|
}
|
|
|
|
|
}
|
2023-05-13 08:26:43 +00:00
|
|
|
|
}
|
|
|
|
|
|
2023-10-31 06:51:14 +00:00
|
|
|
|
return err;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
}
|
2022-05-17 07:04:55 +00:00
|
|
|
|
scanner_err hg_scanner_mgr::hg_scanner_start(scanner_handle h, void* async_event, int num)
|
2022-05-03 03:56:07 +00:00
|
|
|
|
{
|
2022-05-17 07:04:55 +00:00
|
|
|
|
return (scanner_err)SCAN_PTR(h)->start();
|
2022-05-03 03:56:07 +00:00
|
|
|
|
}
|
2022-05-17 07:04:55 +00:00
|
|
|
|
scanner_err hg_scanner_mgr::hg_scanner_stop(scanner_handle h)
|
2022-05-03 03:56:07 +00:00
|
|
|
|
{
|
2023-10-20 07:21:17 +00:00
|
|
|
|
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;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
}
|
2022-05-17 07:04:55 +00:00
|
|
|
|
scanner_err hg_scanner_mgr::hg_scanner_get_img_info(scanner_handle h, SANE_Parameters* bmi, long len)
|
2022-05-03 03:56:07 +00:00
|
|
|
|
{
|
2022-05-17 07:04:55 +00:00
|
|
|
|
return (scanner_err)SCAN_PTR(h)->get_image_info(bmi);
|
2022-05-03 03:56:07 +00:00
|
|
|
|
}
|
2022-05-17 07:04:55 +00:00
|
|
|
|
scanner_err hg_scanner_mgr::hg_scanner_read_img_data(scanner_handle h, unsigned char* data, long* len)
|
2022-05-03 03:56:07 +00:00
|
|
|
|
{
|
|
|
|
|
if (!len)
|
2022-05-17 07:04:55 +00:00
|
|
|
|
return SCANNER_ERR_INVALID_PARAMETER;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
|
|
|
|
|
int l = *len,
|
|
|
|
|
err = SCAN_PTR(h)->read_image_data(data, &l);
|
|
|
|
|
|
|
|
|
|
*len = l;
|
|
|
|
|
|
2022-05-17 07:04:55 +00:00
|
|
|
|
return (scanner_err)err;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
}
|
2022-05-17 07:04:55 +00:00
|
|
|
|
scanner_err hg_scanner_mgr::hg_scanner_get_status(scanner_handle h, int setstutas)
|
2022-05-03 03:56:07 +00:00
|
|
|
|
{
|
2022-05-17 07:04:55 +00:00
|
|
|
|
return (scanner_err)SCAN_PTR(h)->status();
|
2022-05-03 03:56:07 +00:00
|
|
|
|
}
|
2022-05-17 07:04:55 +00:00
|
|
|
|
scanner_err hg_scanner_mgr::hg_scanner_reset(scanner_handle h)
|
2022-05-03 03:56:07 +00:00
|
|
|
|
{
|
2022-05-17 07:04:55 +00:00
|
|
|
|
return (scanner_err)SCAN_PTR(h)->reset();
|
2022-05-03 03:56:07 +00:00
|
|
|
|
}
|
2022-05-17 07:04:55 +00:00
|
|
|
|
scanner_err hg_scanner_mgr::hg_scanner_control(scanner_handle h, unsigned long code, void* data, unsigned* len)
|
2022-05-03 03:56:07 +00:00
|
|
|
|
{
|
|
|
|
|
//if (!len && code != IO_CTRL_CODE_TEST_SINGLE)
|
2022-05-17 07:04:55 +00:00
|
|
|
|
// return SCANNER_ERR_INVALID_PARAMETER;
|
2022-05-03 03:56:07 +00:00
|
|
|
|
|
|
|
|
|
if (code == IO_CTRL_CODE_ABOUT_INFO)
|
|
|
|
|
return get_about_info(h, data, len);
|
2022-07-20 06:57:26 +00:00
|
|
|
|
else if (code == IO_CTRL_CODE_GET_LOG_FILE && len && *len == LOG_FILE_DRIVER)
|
|
|
|
|
{
|
|
|
|
|
if (!data)
|
|
|
|
|
return SCANNER_ERR_INVALID_PARAMETER;
|
|
|
|
|
|
2023-07-11 09:13:28 +00:00
|
|
|
|
std::string f(utils::temporary_path() + PATH_SEPARATOR + "scanner-tmplog.txt");
|
2022-07-20 06:57:26 +00:00
|
|
|
|
|
2023-07-11 09:13:28 +00:00
|
|
|
|
int ret = utils::copy_log_file_to(f.c_str());
|
|
|
|
|
if (ret)
|
2022-07-20 06:57:26 +00:00
|
|
|
|
*((char*)data) = 0;
|
|
|
|
|
else
|
|
|
|
|
strcpy((char*)data, f.c_str());
|
|
|
|
|
|
2023-07-11 09:13:28 +00:00
|
|
|
|
return (scanner_err)ret;
|
2022-07-20 06:57:26 +00:00
|
|
|
|
}
|
2022-05-03 03:56:07 +00:00
|
|
|
|
else if (!h)
|
2022-05-17 07:04:55 +00:00
|
|
|
|
return SCANNER_ERR_INVALID_PARAMETER;
|
2022-07-23 10:20:44 +00:00
|
|
|
|
else
|
2022-05-17 07:04:55 +00:00
|
|
|
|
return (scanner_err)SCAN_PTR(h)->device_io_control(code, data, len);
|
2022-05-03 03:56:07 +00:00
|
|
|
|
}
|
2023-01-29 07:01:38 +00:00
|
|
|
|
|
|
|
|
|
void hg_scanner_mgr::on_language_changed(void)
|
|
|
|
|
{
|
|
|
|
|
std::lock_guard<std::mutex> lock(mutex_dev_);
|
|
|
|
|
for (auto& v: online_devices_)
|
|
|
|
|
{
|
|
|
|
|
if (v.scanner)
|
|
|
|
|
v.scanner->on_language_changed();
|
|
|
|
|
}
|
2023-07-02 06:13:55 +00:00
|
|
|
|
}
|
|
|
|
|
const char* hg_scanner_mgr::last_open_message(void)
|
|
|
|
|
{
|
|
|
|
|
return hg_scanner_mgr::last_open_msg_.c_str();
|
|
|
|
|
}
|