#include "scanner_manager.h" #include "../../sdk/hginclude/utils.h" #include #include #include #include #include "../../../sdk/include/huagao/brand.h" #include "user-opt/user.h" #include "user-opt/offline_opt.h" #include #include #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" /// /// 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 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 /// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // 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 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 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 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(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(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(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(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(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(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(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 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锛屾墍浠ュ姞杞芥椂涓嶄細娓呮瑕佹墦寮€鍝竴鍙拌澶囷紝鍙湁閫氳繃澶栭儴杩涜鍔犺浇鏀瑰彉瀹炰�? 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鈥濇敼鍙樼殑鎯呮�? { 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::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& devs) { std::lock_guard 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 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(); 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()); 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 devs; std::vector::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 lock(mutex_dev_); std::vector::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(offline_)); ptr->dev_opts->add(dynamic_cast(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 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) { device_option* tmp = new device_option(); tmp->add(offline_); tmp->add(g_language); } else { err = SCANNER_ERR_DEVICE_NOT_FOUND; std::lock_guard 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(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 lock(mutex_dev_); for (auto& v: online_devices_) { if (v.scanner) v.scanner->on_language_changed(); } } const char* hg_scanner_mgr::last_open_message(void) { return hg_scanner_mgr::last_open_msg_.c_str(); }