lmh188
/
code_device
mirror of http://192.168.10.5:8099/sane/code_device.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

新增驱动锁定设备

This commit is contained in:
13038267101 2022-12-05 23:01:13 +08:00
parent ac1f6310b6
commit 4910ea4454
4 changed files with 306 additions and 5 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

239
hgdriver/hgdev/hg_scanner.cpp
View File

@ -9,7 +9,61 @@
#endif
#if defined(WIN32) || defined(_WIN64)
static int load_dll(const wchar_t* path_dll, HMODULE* dll)
{
HMODULE h = LoadLibraryW(path_dll);
int ret = GetLastError();
wchar_t info[128] = { 0 };
swprintf_s(info, _countof(info) - 1, L" = %d\r\n", ret);
OutputDebugStringW((L"[TWAIN]Load: " + std::wstring(path_dll) + info).c_str());
if (!h && ret == ERROR_MOD_NOT_FOUND)
{
std::wstring dir(path_dll);
size_t pos = dir.rfind(L'\\');
wchar_t path[MAX_PATH] = { 0 };
GetDllDirectoryW(_countof(path) - 1, path);
if (pos != std::wstring::npos)
dir.erase(pos);
OutputDebugStringW((L"[TWAIN]Load: try change directory to " + dir + L"\r\n").c_str());
SetDllDirectoryW(dir.c_str());
h = LoadLibraryW(path_dll);
ret = GetLastError();
swprintf_s(info, _countof(info) - 1, L" = %d\r\n", ret);
OutputDebugStringW((L"[TWAIN]Load: " + std::wstring(path_dll) + info).c_str());
OutputDebugStringW((L"[TWAIN]Load: restore directory to " + std::wstring(path) + L"\r\n").c_str());
SetDllDirectoryW(path);
}
if (dll)
*dll = h;
return ret;
}
static int strToWchar(string str, wchar_t* s)
{
if (str.empty() || !s)
{
return -1;
}
size_t size = str.length();
//获取缓冲区大小，并申请空间，缓冲区大小按字符计算
int len = MultiByteToWideChar(CP_ACP, 0, str.c_str(), size, NULL, 0);
wchar_t* buffer = new wchar_t[size + 1];
MultiByteToWideChar(CP_ACP, 0, str.c_str(), size, buffer, len);
buffer[len] = '\0';
wcscpy(s, buffer);
if (!buffer || !s)
return -1;
delete[]buffer;
buffer = NULL;
return 0;
}
#endif
static int ui_default_callback(scanner_handle, int, void*, unsigned int*, void*)
{
return 0;
@ -83,6 +137,7 @@ static std::string bmp_821(unsigned char* bits/*bits data*/, int w, int h, int*
return f;
}
static bool is_firstopen; //第二次打开设备就不在去获取和设置设备锁定状态
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// hg_scanner
hg_scanner::hg_scanner(ScannerSerial serial
@ -102,6 +157,7 @@ hg_scanner::hg_scanner(ScannerSerial serial
, is_kernelsnap_221027_(false), memory_size_(1024/*USB+JPEG压缩及图像处理图队列，总共1GB*/), isx86_Advan_(true), stop_fatal_(SCANNER_ERR_OK), is_auto_paper_scan(false)
,size_check(false), save_sleeptime_type_(false)
{
is_firstopen = true;
#if !defined(_WIN32) && !defined(_WIN64) &&defined(x86_64)
isx86_Advan_ = false;
#endif
@ -164,21 +220,27 @@ hg_scanner::hg_scanner(ScannerSerial serial
wait_usb_.set_debug_info("USB");
wait_img_.set_debug_info("Image");
wait_usb_result_.set_debug_info("start");
wait_usb_.set_debug_info("Devsislock");
thread_usb_read_.reset(new std::thread(&hg_scanner::thread_handle_usb, this));
thread_img_handle_.reset(new std::thread(&hg_scanner::thread_image_handle, this));
thread_devslock_handle_.reset(new std::thread(&hg_scanner::thread_devslock_handle, this));
ImagePrc_pHandle_ = hg_imgproc::init(pid_, isx86_Advan_);;
}
hg_scanner::~hg_scanner()
{
close(true);
hg_version_free_handle();
if (thread_usb_read_.get() && thread_usb_read_->joinable())
thread_usb_read_->join();
if (thread_img_handle_.get() && thread_img_handle_->joinable())
thread_img_handle_->join();
if (thread_devslock_handle_.get() && thread_devslock_handle_->joinable())
thread_devslock_handle_->join();
delete custom_gamma_val_;
hg_imgproc::release(ImagePrc_pHandle_);
name_.insert(0, "\350\256\276\345\244\207\342\200\234");
name_ += "\342\200\235\345\267\262\347\273\217\345\205\263\351\227\255\343\200\202";
notify_ui_working_status(name_.c_str(), SANE_EVENT_SCANNER_CLOSED);
@ -255,6 +317,17 @@ int hg_scanner::save_2_tempory_file(std::shared_ptr<std::vector<char>> data, std
return ret;
}
void hg_scanner::thread_devslock_handle(void)
{
int ret = SCANNER_ERR_OK;
while (is_firstopen)
{
wait_devsislock_.wait();
ret = get_server_blacklist();
hg_version_free_handle();
is_firstopen = false;
}
}
void hg_scanner::thread_handle_usb(void)
{
while (run_)
@ -294,6 +367,166 @@ void hg_scanner::thread_image_handle(void)
scan_life_ = NULL;
}
}
int hg_scanner::hg_version_init_handle()
{
int ret = SCANNER_ERR_OK;
#ifndef WIN32
#ifdef OEM_HANWANG
string libname = "libhwdriver.so";
#elif defined(OEM_LISICHENG)
string libname = "liblscdriver.so";
#elif defined(OEM_CANGTIAN)
string libname = "libctsdriver.so";
#else
string libname = "libhgdriver.so";
#endif
string scanner_path = hg_log::get_module_full_path(libname.c_str());
if (scanner_path.empty())
{
return SCANNER_ERR_OUT_OF_RANGE;
}
scanner_path = scanner_path.substr(0, scanner_path.size() - libname.size());
string HGVersionlib_path = scanner_path + HGVERSION_LIBNANE;
printf("get auto txt HGVersionlib_path is:%s\r\n", scanner_path.c_str());
if (access(HGVersionlib_path.c_str(), F_OK) != 0)
{
return SCANNER_ERR_OUT_OF_RANGE;
}
printf("HGVersionlib_path：%s \r\n", HGVersionlib_path.c_str());
Dynamicopen_HGVersion_pHandle_ = dlopen(HGVersionlib_path.c_str(), RTLD_LAZY);
if (!Dynamicopen_HGVersion_pHandle_ )
{
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "HGVersionlib_path open dll is error: %s\n", hg_scanner_err_name(SCANNER_ERR_INSUFFICIENT_MEMORY));
return SCANNER_ERR_INSUFFICIENT_MEMORY;
}
HGVersion_Init_ = (SDKHGVersion_Init_)dlsym(Dynamicopen_HGVersion_pHandle_, "HGVersion_CreateMgr");
HGVersion_Islock_ = (SDKHGVersion_Islock_)dlsym(Dynamicopen_HGVersion_pHandle_, "HGVersion_GetVersionList");
HGVersion_Postlog_ = (SDKHGVersion_Postlog_)dlsym(Dynamicopen_HGVersion_pHandle_, "HGVersion_BlackListCheck");
HGVersion_Free_ = (SDKHGVersion_Free_)dlsym(Dynamicopen_HGVersion_pHandle_, "HGVersion_DestroyMgr");
#else
string scanner_path = hg_log::get_module_full_path("scanner.dll");
scanner_path = scanner_path.substr(0, scanner_path.size() - strlen("scanner.dll"));
string HGVersionlib_path = scanner_path + HGVERSION_LIBNANE;
wchar_t* Prclibbuffer = new wchar_t[HGVersionlib_path.length() + 1];
ret = strToWchar(HGVersionlib_path, Prclibbuffer);
if (ret == -1)
return SCANNER_ERR_INSUFFICIENT_MEMORY;
load_dll(Prclibbuffer, &Dynamicopen_HGVersion_pHandle_); //windows下可能会找不到他所在的依赖库导致直接打开动态库的时候找不到模块
SAFE_DELETE(Prclibbuffer);
//int l = GetLastError();
if (!Dynamicopen_HGVersion_pHandle_ )
{
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "Dynamicopen_HGVersion_pHandle_ open dll is error: %s\n", hg_scanner_err_name(SCANNER_ERR_INSUFFICIENT_MEMORY));
return SCANNER_ERR_INSUFFICIENT_MEMORY;
}
HGVersion_Init_ = (SDKHGVersion_Init_) GetProcAddress(Dynamicopen_HGVersion_pHandle_, "HGVersion_CreateMgr");
HGVersion_Islock_ = (SDKHGVersion_Islock_) GetProcAddress(Dynamicopen_HGVersion_pHandle_, "HGVersion_BlackListCheck");
HGVersion_Postlog_ = (SDKHGVersion_Postlog_) GetProcAddress(Dynamicopen_HGVersion_pHandle_, "HGVersion_PostDeviceLockInfo");
HGVersion_Free_ = (SDKHGVersion_Free_) GetProcAddress(Dynamicopen_HGVersion_pHandle_, "HGVersion_DestroyMgr");
#endif
if (!HGVersion_Init_ ||!HGVersion_Islock_ || !HGVersion_Postlog_ || !HGVersion_Free_)
{
return SCANNER_ERR_INVALID_PARAMETER;
}
HGVersion_Init_(&HGVersion_mgr_);
return ret;
}
int hg_scanner::get_server_blacklist()
{
if (!HGVersion_mgr_)
{
return SCANNER_ERR_INVALID_PARAMETER;
}
char snbuffer[20];
char fvbuffer[15];
char pidbuffer[5];
SANE_Bool scan_islock = false;
memset(snbuffer, 0, sizeof(snbuffer));
memset(fvbuffer, 0, sizeof(fvbuffer));
memset(pidbuffer, 0, sizeof(pidbuffer));
HGBool islock;
string sn = get_serial_num();
string fv = get_firmware_version();
strcpy(snbuffer, sn.c_str());
strcpy(fvbuffer, fv.c_str());
sprintf(pidbuffer, "%0x", pid_);
HGResult ret = HGVersion_Islock_(HGVersion_mgr_, snbuffer, &islock);
if (ret != 0)
{
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "net is 404:%d\n", ret);
return -1; //服务器没有连接到网络
}
if (!islock)
{
ret = get_scan_islock(scan_islock);
if (ret == SCANNER_ERR_DEVICE_ISLOCK)
{
ret = set_scan_islock(0); //锁定设备
if (ret != SCANNER_ERR_OK)
{
return ret;
}
ret = HGVersion_Postlog_(HGVersion_mgr_, pidbuffer, snbuffer, fv.substr(0, 4).c_str(), fvbuffer, islock); //发送日志到服务器
if (ret != 0)
{
return -1; //服务器没有连接到网络
}
}
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "scanner go:%d\n", islock);
return 0;
}
ret = set_scan_islock(1); //锁定设备
if (ret != SCANNER_ERR_OK)
{
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "Dev is locked err:%d\n", ret);
return ret;
}
ret = HGVersion_Postlog_(HGVersion_mgr_, pidbuffer, snbuffer, fv.substr(0,4).c_str(), fvbuffer, islock); //发送日志到服务器
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "Dev is locked succeed:%d\n", ret);
if (ret != 0)
{
return -1; //服务器没有连接到网络
}
return ret = islock ? SCANNER_ERR_DEVICE_ISLOCK : SCANNER_ERR_OK;
}
void hg_scanner::hg_version_free_handle()
{
int ret = 0;
if (HGVersion_mgr_)
{
int ret = HGVersion_Free_(HGVersion_mgr_);
HGVersion_mgr_ = NULL;
}
if (Dynamicopen_HGVersion_pHandle_)
{
#if (!defined WIN32)
ret = dlclose(Dynamicopen_HGVersion_pHandle_);
#else
ret = FreeLibrary(Dynamicopen_HGVersion_pHandle_);
#endif
Dynamicopen_HGVersion_pHandle_ = NULL;
}
}
void hg_scanner::dump_image_empty(hg_imgproc::HIMGPRC himg, const char* desc)
{}
void hg_scanner::dump_image_real(hg_imgproc::HIMGPRC himg, const char* desc)
@ -2028,6 +2261,9 @@ int hg_scanner::on_scanner_closing(bool force)
void hg_scanner::thread_handle_usb_read(void)
{
}
void hg_scanner::thread_handle_islock_read(void)
{
}
void hg_scanner::adjust_color(hg_imgproc::HIMGPRC handle)
{
int tableLength = 0; // ZERO length perform color-adjust only
@ -2550,6 +2786,7 @@ int hg_scanner::close(bool force)
run_ = false;
wait_usb_.notify();
wait_img_.notify();
wait_devsislock_.notify();
if(!scan_life_)
{
std::lock_guard<std::mutex> lock(io_lock_);

61
hgdriver/hgdev/hg_scanner.h
View File

@ -20,7 +20,7 @@
#include "image_process.h"
#include "StopWatch.h"
#include "PaperSize.h"
#include "version/HGVersion.h"
#if defined(WIN32) || defined(_WIN64)
#include <cryptoPP/md5.h> //暂时linux 屏蔽
#include <cryptoPP/files.h>
@ -30,6 +30,35 @@
#else
#include <unistd.h>
#endif
#ifdef OEM_HANWANG
#ifdef WIN32
#define HGVERSION_LIBNANE "HWVersion.dll"
#else
#define HGVERSION_LIBNANE "libHwVersion.so"
#endif
#elif defined(OEM_LISICHENG)
#ifdef WIN32
#define HGVERSION_LIBNANE "LSCVersion.dll"
#else
#define HGVERSION_LIBNANE "libLscVersion.so"
#endif
#elif defined(OEM_CANGTIAN)
#ifdef WIN32
#define HGVERSION_LIBNANE "CtsVersion.dll"
#else
#define HGVERSION_LIBNANE "libCtsVersion.so"
#endif
#else
#ifdef WIN32
#define HGVERSION_LIBNANE "HGVersion.dll"
#else
#define HGVERSION_LIBNANE "libHGVersion.so""
#endif
#endif
#ifndef WIN32
#define __stdcall
#endif
#define MAPPING_FUNCTION_IN_BASE // 定义该标志，各子类不必再初始化setting_map_数组
// 删除指针
@ -57,8 +86,26 @@ if (NULL != (p)) {delete((p)); \
#define USB_REQ_SET_DEV_CONFIGURATION 0x62
#define USB_REQ_GET_DEV_REGS 0x63
#define USB_REQ_SET_DEV_REGS 0x64
typedef HGResult(__stdcall* SDKHGVersion_Init_)(HGVersionMgr* mgr);
typedef HGResult(__stdcall* SDKHGVersion_Islock_)(HGVersionMgr mgr, const HGChar* devSN, HGBool* inList);
typedef HGResult(__stdcall* SDKHGVersion_Postlog_)(HGVersionMgr mgr, const HGChar* devName, const HGChar* devSN,
const HGChar* devType, const HGChar* devFW, HGBool isLock);
typedef HGResult(__stdcall* SDKHGVersion_Free_)(HGVersionMgr mgr);
class hg_scanner
{
HGVersionMgr HGVersion_mgr_;
SDKHGVersion_Init_ HGVersion_Init_;
SDKHGVersion_Islock_ HGVersion_Islock_;
SDKHGVersion_Postlog_ HGVersion_Postlog_;
SDKHGVersion_Free_ HGVersion_Free_;
#ifndef WIN32
void* Dynamicopen_HGVersion_pHandle_;;
#else
HINSTANCE Dynamicopen_HGVersion_pHandle_;
#endif
bool notify_setting_result_;
std::string name_;
std::string save_multiout; //保存多留输出类型
@ -74,6 +121,9 @@ class hg_scanner
std::unique_ptr<std::thread> thread_img_handle_;
void thread_image_handle(void);
std::unique_ptr<std::thread> thread_devslock_handle_;
void thread_devslock_handle(void);
void(hg_scanner::* dump_img_)(hg_imgproc::HIMGPRC himg, const char* desc);
void dump_image_empty(hg_imgproc::HIMGPRC himg, const char* desc);
void dump_image_real(hg_imgproc::HIMGPRC himg, const char* desc);
@ -99,7 +149,8 @@ class hg_scanner
void reset_custom_area_range(int paper);
float reset_custom_area_jsn_value(const char* name, double& var, float range_l, float range_u, float value_l, float value_u); // return cur value
int set_color_change(void);
public:
// 设置接口
protected:
@ -210,7 +261,10 @@ protected:
virtual int set_setting_value(const char* name, void* data, int len);
virtual int on_scanner_closing(bool force);
virtual void thread_handle_usb_read(void) = 0;
virtual void thread_handle_islock_read();
int hg_version_init_handle();
int get_server_blacklist();
void hg_version_free_handle();
// adjust color or apply custom gamma
void adjust_color(hg_imgproc::HIMGPRC handle);
hg_imgproc::IMGPRCPARAM get_image_process_object(int model);
@ -223,6 +277,7 @@ protected:
platform_event wait_usb_;
platform_event wait_img_;
platform_event wait_usb_result_;
platform_event wait_devsislock_;
usb_io* io_;
std::mutex io_lock_;
std::string firmware_ver_;

9
hgdriver/hgdev/hg_scanner_239.cpp
View File

@ -164,6 +164,8 @@ hg_scanner_239::hg_scanner_239(const char* dev_name, int pid,usb_io* io) : hg_sc
//init_settings((jsontext1 + jsontext2).c_str());
//writedown_device_configuration(); // initialize the hardware settings
init_version();
hg_version_init_handle();
wait_devsislock_.notify();
}
hg_scanner_239::~hg_scanner_239()
{
@ -1023,6 +1025,10 @@ void hg_scanner_239::thread_handle_usb_read(void)
}
VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "USB thread exit with code: %s, status = %s\n", hg_scanner_err_name(ret), hg_scanner_err_name(status_));
}
void hg_scanner_239::thread_handle_islock_read(void)
{
int get_server_blacklist();
}
int hg_scanner_239::start(void)
{
bool handled = false;
@ -1370,6 +1376,7 @@ int hg_scanner_239::get_scan_islock(SANE_Bool& islock)
//if (!is_kernelsnap_220830_)
// return SCANNER_ERR_DEVICE_NOT_SUPPORT;
int val = 0,
ret = read_register(setting3399::SR_GET_LOCK_STATES, &val);
@ -1449,6 +1456,7 @@ int hg_scanner_239::set_scan_lock_check_val(string check_str)
}
int hg_scanner_239::firmware_upgrade(std::string filename)
{
std::lock_guard<std::mutex> lock(io_lock_);
std::ifstream fwname;
int ret = SCANNER_ERR_OK;
@ -1526,6 +1534,7 @@ int hg_scanner_239::firmware_upgrade(std::string filename)
}
int hg_scanner_239::clean_paper_road()
{
std::lock_guard<std::mutex> lock(io_lock_);
int ret = 0, len = 0;
ret = write_register(setting3399::SR_CLEAN_PAPER_ROAD, len);
return ret;

2
hgdriver/hgdev/hg_scanner_239.h
View File

@ -64,7 +64,7 @@ protected:
virtual void on_device_reconnected(void) override;
virtual int on_scanner_closing(bool force) override;
virtual void thread_handle_usb_read(void) override;
virtual void thread_handle_islock_read();
public:
hg_scanner_239(const char* dev_name, int pid,usb_io* io);
~hg_scanner_239();