code_device/hgdriver/hgdev/hg_scanner_300.cpp

#include "hg_scanner_300.h"
#include "../wrapper/hg_log.h"

#if defined(WIN32) || defined(_WIN64)
#include "scanner_manager.h"
#endif
//G300
static std::string jsontext1("{\"global\":{\"device_type\":\"G300\",\"option_count\":69},\"restore\":{\"cat\":\"base\",\"readonly\":false,\"affect\":0,\"group\":\"none\",\"visible\":true,\"field\":\"Common\",\"pos\":0,\"unit\":\"None\",\"title\":\"\\u6062\\u590d\\u9ed8\\u8ba4\\u8bbe\\u7f6e\",\"desc\":\"\\u6062\\u590d\\u9ed8\\u8ba4\\u8bbe\\u7f6e\",\"type\":\"button\",\"cur\":\"button\",\"default\":\"button\",\"size\":0},\"help\":{\"cat\":\"base\",\"readonly\":false,\"affect\":0,\"group\":\"none\",\"visible\":true,\"field\":\"Common\",\"pos\":0,\"unit\":\"None\",\"title\":\"\\u5e2e\\u52a9\",\"desc\":\"\\u663e\\u793a\\u8f6f\\u4ef6\\u5e2e\\u52a9\\u6587\\u6863\",\"type\":\"button\",\"cur\":\"true\",\"default\":\"true\",\"size\":4},\"grp-1\":{\"cat\":\"base\",\"title\":\"\\u57fa\\u672c\\u8bbe\\u7f6e\",\"type\":\"group\",\"readonly\":false,\"affect\":0,\"group\":\"base\",\"field\":\"Common\",\"pos\":0,\"visible\":true,\"unit\":\"None\"},\"is-multiout\":{\"cat\":\"base\",\"readonly\":false,\"affect\":0,\"group\":\"base\",\"visible\":true,\"field\":\"Common\",\"pos\":0,\"unit\":\"None\",\"title\":\"\\u591a\\u6d41\\u8f93\\u51fa\",\"desc\":\"\\u540c\\u65f6\\u8f93\\u51fa\\u591a\\u79cd\\u989c\\u8272\\u6a21\\u5f0f\\u7684\\u56fe\\u50cf\",\"type\":\"bool\",\"cur\":false,\"default\":false,\"size\":4},\"multiout-type\":{\"cat\":\"base\",\"readonly\":false,\"affect\":0,\"group\":\"base\",\"visible\":true,\"field\":\"Common\",\"pos\":0,\"unit\":\"None\",\"title\":\"\\u591a\\u6d41\\u8f93\\u51fa\\u7c7b\\u578b\",\"desc\":\"\\u9009\\u62e9\\u591a\\u6d41\\u8f93\\u51fa\\u7684\\u7c7b\\u578b\",\"type\":\"string\",\"cur\":\"\\u5f69\\u8272+\\u7070\\u5ea6+\\u9ed1\\u767d\",\"default\":\"\\u5f69\\u8272+\\u7070\\u5ea6+\\u9ed1\\u767d\",\"size\":32,\"range\":[\"\\u5f69\\u8272+\\u7070\\u5ea6+\\u9ed1\\u767d\",\"\\u5f69\\u8272+\\u7070\\u5ea6\",\"\\u5f69\\u8272+\\u9ed1\\u767d\",\"\\u7070\\u5ea6+\\u9ed1\\u767d\"],\"depend_or\":[\"is-multiout==true\"]},\"mode\":{\"cat\":\"base\",\"readonly\":false,\"affect\":0,\"group\":\"base\",\"visible\":true,\"field\":\"Common\",\"pos\":0,\"unit\":\"None\",\"title\":\"\\u989c\\u8272\\u6a21\\u5f0f\",\"desc\":\"\\u9009\\u62e9\\u8272\\u5f69\\u6a21\\u5f0f\",\"type\":\"string\",\"cur\":\"24\\u4f4d\\u5f69\\u8272\",\"default\":\"24\\u4f4d\\u5f69\\u8272\",\"size\":32,\"range\":[\"24\\u4f4d\\u5f69\\u8272\",\"256\\u7ea7\\u7070\\u5ea6\",\"\\u9ed1\\u767d\",\"\\u989c\\u8272\\u81ea\\u52a8\\u8bc6\\u522b\"],\"depend_or\":[\"is-multiout==false\"]},\"binary-threshold\":{\"cat\":\"base\",\"readonly\":false,\"affect\":0,\"group\":\"base\",\"visible\":true,\"field\":\"Common\",\"pos\":0,\"unit\":\"None\",\"title\":\"\\u9ed1\\u767d\\u56fe\\u50cf\\u9608\\u503c\",\"desc\":\"\\u9ad8\\u4e8e\\u8be5\\u9608\\u503c\\u4e3a1\\uff08\\u767d\\uff09\\uff0c\\u4f4e\\u4e8e\\u8be5\\u9608\\u503c\\u4e3a0\\uff08\\u9ed1\\uff09\",\"type\":\"int\",\"cur\":127,\"default\":127,\"size\":4,\"range\":{\"min\":0,\"max\":255,\"step\":1},\"depend_or\":[\"multiout-type!=\\u5f69\\u8272+\\u7070\\u5ea6\",\"mode==\\u9ed1\\u767d\"]},\"reverse-bw\":{\"cat\":\"base\",\"readonly\":false,\"affect\":0,\"group\":\"base\",\"visible\":true,\"field\":\"Common\",\"pos\":0,\"unit\":\"None\",\"title\":\"\\u9ed1\\u767d\\u56fe\\u50cf\\u53cd\\u8272\\u8f93\\u51fa\",\"desc\":\"\\u8f93\\u51fa\\u7684\\u9ed1\\u767d\\u56fe\\u50cf\\u4ee5\\u201c1\\u201d\\u4ee3\\u8868\\u9ed1\\u8272\\uff0c\\u201c0\\u201d\\u4ee3\\u8868\\u767d\\u8272\",\"type\":\"bool\",\"cur\":false,\"default\":false,\"size\":4,\"depend_or\":[\"multiout-type!=\\u5f69\\u8272+\\u7070\\u5ea6\",\"mode==\\u9ed1\\u767d\"]},\"filter\":{\"cat\":\"base\",\"readonly\":false,\"affect\":0,\"group\":\"base\",\"visible\":true,\"field\":\"Common\",\"pos\":0,\"unit\":\"None\",\"title\":\"\\u7070\\u5ea6\\u6216\\u9ed1\\u767d\\u56fe\\u50cf - \\u9664\\u8272\\u4e0e\\u589e\\u5f3a\",\"desc\":\"\\u6d88\\u9664\\u6216\\u589e\\u5f3a\\u6307\\u5b9a\\u8272\\u5f69\",\"type\":\"string\",\"cur\":\"\\u4e0d\\u9664\\u8272\",\"default\":\"\\u4e0d\\u9664\\u8272\",\"size\":24,\"range\":[\"\\u4e0d\\u9664\\u8272\",\"\\u9664\\u7ea2\\u8272\",\"\\u9664\\u7eff\\u8272\",\"\\u9664\\u84dd\
static std::string jsontext2("f\\u533a\\u57df\\u4e0b\\u4fa7\\uff08mm\\uff09\",\"desc\":\"\\u81ea\\u5b9a\\u4e49\\u626b\\u63cf\\u533a\\u57df\\u53f3\\u4e0b\\u89d2y\\u5750\\u6807\",\"type\":\"float\",\"cur\":297.000000,\"default\":297.000000,\"size\":4,\"range\":{\"min\":0.000000,\"max\":297.000000,\"step\":29.700000},\"depend_and\":[\"is-custom-area==true\"]},\"is-size-check\":{\"cat\":\"base\",\"readonly\":false,\"affect\":0,\"group\":\"base\",\"visible\":true,\"field\":\"Common\",\"pos\":0,\"unit\":\"None\",\"title\":\"\\u5c3a\\u5bf8\\u68c0\\u6d4b\",\"desc\":\"\\u68c0\\u6d4b\\u7eb8\\u5f20\\u5b9e\\u9645\\u5c3a\\u5bf8\\u4e0e\\u8bbe\\u7f6e\\u662f\\u5426\\u5339\\u914d\",\"type\":\"bool\",\"cur\":false,\"default\":false,\"size\":4,\"depend_and\":[\"paper!=\\u5339\\u914d\\u539f\\u59cb\\u5c3a\\u5bf8\",\"!=\\u6700\\u5927\\u626b\\u63cf\\u5c3a\\u5bf8\",\"!=\\u6700\\u5927\\u626b\\u63cf\\u5c3a\\u5bf8\\u81ea\\u52a8\\u88c1\\u5207\"]},\"page\":{\"cat\":\"base\",\"readonly\":false,\"affect\":0,\"group\":\"base\",\"visible\":true,\"field\":\"Common\",\"pos\":0,\"unit\":\"None\",\"title\":\"\\u626b\\u63cf\\u9875\\u9762\",\"desc\":\"\\u8bbe\\u7f6e\\u9875\\u9762\\u626b\\u63cf\\u65b9\\u5f0f\",\"type\":\"string\",\"cur\":\"\\u53cc\\u9762\",\"default\":\"\\u53cc\\u9762\",\"size\":40,\"range\":[\"\\u5355\\u9762\",\"\\u53cc\\u9762\",\"\\u8df3\\u8fc7\\u7a7a\\u767d\\u9875\\uff08\\u901a\\u7528\\uff09\",\"\\u8df3\\u8fc7\\u7a7a\\u767d\\u9875\\uff08\\u53d1\\u7968\\u7eb8\\uff09\",\"\\u5bf9\\u6298\"]},\"discardblank\":{\"cat\":\"base\",\"readonly\":false,\"affect\":0,\"group\":\"base\",\"visible\":true,\"field\":\"Common\",\"pos\":0,\"unit\":\"None\",\"title\":\"\\u8df3\\u8fc7\\u7a7a\\u767d\\u9875\",\"desc\":\"\",\"type\":\"bool\",\"cur\":false,\"default\":false,\"size\":4,\"depend_or\":[\"page!=\\u5bf9\\u6298\"]},\"blank-sensitivity\":{\"cat\":\"base\",\"readonly\":false,\"affect\":0,\"group\":\"base\",\"visible\":true,\"field\":\"Common\",\"pos\":0,\"unit\":\"None\",\"title\":\" \\u8df3\\u8fc7\\u7a7a\\u767d\\u9875\\u7075\\u654f\\u5ea6\",\"desc\":\"\\u6570\\u503c\\u8d8a\\u5927\\uff0c\\u5219\\u8d8a\\u5bb9\\u6613\\u8df3\\u8fc7\",\"type\":\"int\",\"cur\":30,\"default\":30,\"size\":4,\"range\":{\"min\":1,\"max\":100,\"step\":1},\"depend_or\":[\"page==\\u8df3\\u8fc7\\u7a7a\\u767d\\u9875\\uff08\\u53d1\\u7968\\u7eb8\\uff09\",\"==\\u8df3\\u8fc7\\u7a7a\\u767d\\u9875\\uff08\\u901a\\u7528\\uff09\",\"discardblank==true\"]},\"fold-type\":{\"cat\":\"base\",\"readonly\":false,\"affect\":0,\"group\":\"base\",\"visible\":true,\"field\":\"Common\",\"pos\":0,\"unit\":\"None\",\"title\":\"\\u5bf9\\u6298\\u6a21\\u5f0f\",\"desc\":\"\",\"type\":\"string\",\"cur\":\"\\u5de6\\u53f3\\u5bf9\\u6298\",\"default\":\"\\u5de6\\u53f3\\u5bf9\\u6298\",\"size\":50,\"range\":[\"\\u5de6\\u53f3\\u5bf9\\u6298\",\"\\u4e0a\\u4e0b\\u5bf9\\u6298\",\"\\u81ea\\u52a8\\u5bf9\\u6298\"],\"depend_or\":[\"page==\\u5bf9\\u6298\"]},\"resolution\":{\"cat\":\"base\",\"readonly\":false,\"affect\":0,\"group\":\"base\",\"visible\":true,\"field\":\"Common\",\"pos\":0,\"unit\":\"None\",\"title\":\"\\u5206\\u8fa8\\u7387\",\"desc\":\"\\u8bbe\\u7f6e\\u626b\\u63cf\\u56fe\\u50cf\\u7684\\u5206\\u8fa8\\u7387\",\"type\":\"int\",\"cur\":200,\"default\":200,\"size\":4,\"range\":{\"min\":100,\"max\":600,\"step\":1}},\"image-quality\":{\"cat\":\"base\",\"readonly\":false,\"affect\":0,\"group\":\"base\",\"visible\":true,\"field\":\"Common\",\"pos\":0,\"unit\":\"None\",\"title\":\"\\u753b\\u8d28\",\"desc\":\"\\u9009\\u62e9\\u626b\\u63cf\\u4eea\\u7684\\u753b\\u8d28\\u6a21\\u5f0f\",\"type\":\"string\",\"cur\":\"\\u753b\\u8d28\\u4f18\\u5148\",\"default\":\"\\u753b\\u8d28\\u4f18\\u5148\",\"size\":200,\"range\":[\"\\u901f\\u5ea6\\u4f18\\u5148\",\"\\u753b\\u8d28\\u4f18\\u5148\"],\"depend_or\":[\"resolution>=300\"]},\"is-exchange\":{\"cat\":\"base\",\"readonly\":false,\"affect\":0,\"group\":\"base\",\"visible\":true,\"field\":\"Common\",\"pos\":0,\"unit\":\"None\",\"title\":\"\\u4ea4\\u6362\\u6b63\\u53cd\\u9762\",\"desc\":\"\\u4ea4\\u6362\\u6bcf\\u5f20\\u6587\\u7a3f\\u7684\\u6b63\\u53cd\\u9762\\u51fa\\u56fe\\u987a\\u5e8f\",\"type\":
static std::string jsontext3("\"unit\":\"None\",\"title\":\"\\u7a7f\\u5b54\\u79fb\\u9664\\u2014\\u5de6\\u4fa7\",\"desc\":\"\\u7a7f\\u5b54\\u5728\\u7eb8\\u5f20\\u4e0a\\u7684\\u5de6\\u4fa7\",\"type\":\"bool\",\"cur\":false,\"default\":false,\"size\":4},\"search-hole-range-l\":{\"cat\":\"base\",\"readonly\":false,\"affect\":0,\"group\":\"imgproc\",\"visible\":true,\"field\":\"Common\",\"pos\":0,\"unit\":\"None\",\"title\":\"        \\u5de6\\u4fa7\\u7a7f\\u5b54\\u641c\\u7d22\\u8303\\u56f4\\u5360\\u5e45\\u9762\\u6bd4\\u4f8b\",\"desc\":\"\\u7a7f\\u5b54\\u641c\\u7d22\\u8303\\u56f4\\u5360\\u5e45\\u9762\\u6bd4\\u4f8b\",\"type\":\"float\",\"cur\":0.100000,\"default\":0.100000,\"size\":4,\"range\":{\"min\":0.000000,\"max\":0.500000,\"step\":0.050000},\"depend_or\":[\"is-rid-hole-l==true\"]},\"is-rid-hole-r\":{\"cat\":\"base\",\"readonly\":false,\"affect\":0,\"group\":\"imgproc\",\"visible\":true,\"field\":\"Common\",\"pos\":0,\"unit\":\"None\",\"title\":\"\\u7a7f\\u5b54\\u79fb\\u9664\\u2014\\u53f3\\u4fa7\",\"desc\":\"\\u7a7f\\u5b54\\u5728\\u7eb8\\u5f20\\u4e0a\\u7684\\u53f3\\u4fa7\",\"type\":\"bool\",\"cur\":false,\"default\":false,\"size\":4},\"search-hole-range-r\":{\"cat\":\"base\",\"readonly\":false,\"affect\":0,\"group\":\"imgproc\",\"visible\":true,\"field\":\"Common\",\"pos\":0,\"unit\":\"None\",\"title\":\"        \\u53f3\\u4fa7\\u7a7f\\u5b54\\u641c\\u7d22\\u8303\\u56f4\\u5360\\u5e45\\u9762\\u6bd4\\u4f8b\",\"desc\":\"\\u7a7f\\u5b54\\u641c\\u7d22\\u8303\\u56f4\\u5360\\u5e45\\u9762\\u6bd4\\u4f8b\",\"type\":\"float\",\"cur\":0.100000,\"default\":0.100000,\"size\":4,\"range\":{\"min\":0.000000,\"max\":0.500000,\"step\":0.050000},\"depend_or\":[\"is-rid-hole-r==true\"]},\"is-rid-hole-t\":{\"cat\":\"base\",\"readonly\":false,\"affect\":0,\"group\":\"imgproc\",\"visible\":true,\"field\":\"Common\",\"pos\":0,\"unit\":\"None\",\"title\":\"\\u7a7f\\u5b54\\u79fb\\u9664\\u2014\\u4e0a\\u4fa7\",\"desc\":\"\\u7a7f\\u5b54\\u5728\\u7eb8\\u5f20\\u7684\\u4e0a\\u90e8\",\"type\":\"bool\",\"cur\":false,\"default\":false,\"size\":4},\"search-hole-range-t\":{\"cat\":\"base\",\"readonly\":false,\"affect\":0,\"group\":\"imgproc\",\"visible\":true,\"field\":\"Common\",\"pos\":0,\"unit\":\"None\",\"title\":\"        \\u4e0a\\u4fa7\\u7a7f\\u5b54\\u641c\\u7d22\\u8303\\u56f4\\u5360\\u5e45\\u9762\\u6bd4\\u4f8b\",\"desc\":\"\\u7a7f\\u5b54\\u641c\\u7d22\\u8303\\u56f4\\u5360\\u5e45\\u9762\\u6bd4\\u4f8b\",\"type\":\"float\",\"cur\":0.100000,\"default\":0.100000,\"size\":4,\"range\":{\"min\":0.000000,\"max\":0.500000,\"step\":0.050000},\"depend_or\":[\"is-rid-hole-t==true\"]},\"is-rid-hole-b\":{\"cat\":\"base\",\"readonly\":false,\"affect\":0,\"group\":\"imgproc\",\"visible\":true,\"field\":\"Common\",\"pos\":0,\"unit\":\"None\",\"title\":\"\\u7a7f\\u5b54\\u79fb\\u9664\\u2014\\u4e0b\\u4fa7\",\"desc\":\"\\u7a7f\\u5b54\\u5728\\u7eb8\\u5f20\\u7684\\u4e0b\\u90e8\",\"type\":\"bool\",\"cur\":false,\"default\":false,\"size\":4},\"search-hole-range-b\":{\"cat\":\"base\",\"readonly\":false,\"affect\":0,\"group\":\"imgproc\",\"visible\":true,\"field\":\"Common\",\"pos\":0,\"unit\":\"None\",\"title\":\"        \\u4e0b\\u4fa7\\u7a7f\\u5b54\\u641c\\u7d22\\u8303\\u56f4\\u5360\\u5e45\\u9762\\u6bd4\\u4f8b\",\"desc\":\"\\u7a7f\\u5b54\\u641c\\u7d22\\u8303\\u56f4\\u5360\\u5e45\\u9762\\u6bd4\\u4f8b\",\"type\":\"float\",\"cur\":0.100000,\"default\":0.100000,\"size\":4,\"range\":{\"min\":0.000000,\"max\":0.500000,\"step\":0.050000},\"depend_or\":[\"is-rid-hole-b==true\"]},\"grp-4\":{\"cat\":\"base\",\"title\":\"\\u9001\\u7eb8\\u65b9\\u5f0f\\u8bbe\\u7f6e\",\"type\":\"group\",\"readonly\":false,\"affect\":0,\"group\":\"feeder\",\"field\":\"Common\",\"pos\":0,\"visible\":true,\"unit\":\"None\"},\"scan-mode\":{\"cat\":\"base\",\"readonly\":false,\"affect\":0,\"group\":\"feeder\",\"visible\":true,\"field\":\"Common\",\"pos\":0,\"unit\":\"None\",\"title\":\"\\u626b\\u63cf\\u5f20\\u6570\",\"desc\":\"\\u9009\\u62e9\\u6307\\u5b9a\\u6570\\u91cf\\u626b\\u63cf\\u6216\\u8fde\\u7eed\\u626b\\u63cf\",\"type\":\"string\",\"cur\":\"\\u8fde\\u7eed\\u626b\\u63cf\",\"default\":\"\\u8fde\\u7eed\\u626b\\

//G400
static std::string jsontext4("{\"global\":{\"device_type\":\"G400\",\"option_count\":67},\"restore\":{\"cat\":\"base\",\"readonly\":false,\"affect\":0,\"group\":\"none\",\"visible\":true,\"field\":\"Common\",\"pos\":0,\"unit\":\"None\",\"title\":\"\\u6062\\u590d\\u9ed8\\u8ba4\\u8bbe\\u7f6e\",\"desc\":\"\\u6062\\u590d\\u9ed8\\u8ba4\\u8bbe\\u7f6e\",\"type\":\"button\",\"cur\":\"button\",\"default\":\"button\",\"size\":0},\"help\":{\"cat\":\"base\",\"readonly\":false,\"affect\":0,\"group\":\"none\",\"visible\":true,\"field\":\"Common\",\"pos\":0,\"unit\":\"None\",\"title\":\"\\u5e2e\\u52a9\",\"desc\":\"\\u663e\\u793a\\u8f6f\\u4ef6\\u5e2e\\u52a9\\u6587\\u6863\",\"type\":\"button\",\"cur\":\"true\",\"default\":\"true\",\"size\":4},\"grp-1\":{\"cat\":\"base\",\"title\":\"\\u57fa\\u672c\\u8bbe\\u7f6e\",\"type\":\"group\",\"readonly\":false,\"affect\":0,\"group\":\"base\",\"field\":\"Common\",\"pos\":0,\"visible\":true,\"unit\":\"None\"},\"is-multiout\":{\"cat\":\"base\",\"readonly\":false,\"affect\":0,\"group\":\"base\",\"visible\":true,\"field\":\"Common\",\"pos\":0,\"unit\":\"None\",\"title\":\"\\u591a\\u6d41\\u8f93\\u51fa\",\"desc\":\"\\u540c\\u65f6\\u8f93\\u51fa\\u591a\\u79cd\\u989c\\u8272\\u6a21\\u5f0f\\u7684\\u56fe\\u50cf\",\"type\":\"bool\",\"cur\":false,\"default\":false,\"size\":4},\"multiout-type\":{\"cat\":\"base\",\"readonly\":false,\"affect\":0,\"group\":\"base\",\"visible\":true,\"field\":\"Common\",\"pos\":0,\"unit\":\"None\",\"title\":\"\\u591a\\u6d41\\u8f93\\u51fa\\u7c7b\\u578b\",\"desc\":\"\\u9009\\u62e9\\u591a\\u6d41\\u8f93\\u51fa\\u7684\\u7c7b\\u578b\",\"type\":\"string\",\"cur\":\"\\u5f69\\u8272+\\u7070\\u5ea6+\\u9ed1\\u767d\",\"default\":\"\\u5f69\\u8272+\\u7070\\u5ea6+\\u9ed1\\u767d\",\"size\":32,\"range\":[\"\\u5f69\\u8272+\\u7070\\u5ea6+\\u9ed1\\u767d\",\"\\u5f69\\u8272+\\u7070\\u5ea6\",\"\\u5f69\\u8272+\\u9ed1\\u767d\",\"\\u7070\\u5ea6+\\u9ed1\\u767d\"],\"depend_or\":[\"is-multiout==true\"]},\"mode\":{\"cat\":\"base\",\"readonly\":false,\"affect\":0,\"group\":\"base\",\"visible\":true,\"field\":\"Common\",\"pos\":0,\"unit\":\"None\",\"title\":\"\\u989c\\u8272\\u6a21\\u5f0f\",\"desc\":\"\\u9009\\u62e9\\u8272\\u5f69\\u6a21\\u5f0f\",\"type\":\"string\",\"cur\":\"24\\u4f4d\\u5f69\\u8272\",\"default\":\"24\\u4f4d\\u5f69\\u8272\",\"size\":32,\"range\":[\"24\\u4f4d\\u5f69\\u8272\",\"256\\u7ea7\\u7070\\u5ea6\",\"\\u9ed1\\u767d\",\"\\u989c\\u8272\\u81ea\\u52a8\\u8bc6\\u522b\"],\"depend_or\":[\"is-multiout==false\"]},\"binary-threshold\":{\"cat\":\"base\",\"readonly\":false,\"affect\":0,\"group\":\"base\",\"visible\":true,\"field\":\"Common\",\"pos\":0,\"unit\":\"None\",\"title\":\"\\u9ed1\\u767d\\u56fe\\u50cf\\u9608\\u503c\",\"desc\":\"\\u9ad8\\u4e8e\\u8be5\\u9608\\u503c\\u4e3a1\\uff08\\u767d\\uff09\\uff0c\\u4f4e\\u4e8e\\u8be5\\u9608\\u503c\\u4e3a0\\uff08\\u9ed1\\uff09\",\"type\":\"int\",\"cur\":127,\"default\":127,\"size\":4,\"range\":{\"min\":0,\"max\":255,\"step\":1},\"depend_or\":[\"multiout-type!=\\u5f69\\u8272+\\u7070\\u5ea6\",\"mode==\\u9ed1\\u767d\"]},\"reverse-bw\":{\"cat\":\"base\",\"readonly\":false,\"affect\":0,\"group\":\"base\",\"visible\":true,\"field\":\"Common\",\"pos\":0,\"unit\":\"None\",\"title\":\"\\u9ed1\\u767d\\u56fe\\u50cf\\u53cd\\u8272\\u8f93\\u51fa\",\"desc\":\"\\u8f93\\u51fa\\u7684\\u9ed1\\u767d\\u56fe\\u50cf\\u4ee5\\u201c1\\u201d\\u4ee3\\u8868\\u9ed1\\u8272\\uff0c\\u201c0\\u201d\\u4ee3\\u8868\\u767d\\u8272\",\"type\":\"bool\",\"cur\":false,\"default\":false,\"size\":4,\"depend_or\":[\"multiout-type!=\\u5f69\\u8272+\\u7070\\u5ea6\",\"mode==\\u9ed1\\u767d\"]},\"filter\":{\"cat\":\"base\",\"readonly\":false,\"affect\":0,\"group\":\"base\",\"visible\":true,\"field\":\"Common\",\"pos\":0,\"unit\":\"None\",\"title\":\"\\u7070\\u5ea6\\u6216\\u9ed1\\u767d\\u56fe\\u50cf - \\u9664\\u8272\\u4e0e\\u589e\\u5f3a\",\"desc\":\"\\u6d88\\u9664\\u6216\\u589e\\u5f3a\\u6307\\u5b9a\\u8272\\u5f69\",\"type\":\"string\",\"cur\":\"\\u4e0d\\u9664\\u8272\",\"default\":\"\\u4e0d\\u9664\\u8272\",\"size\":24,\"range\":[\"\\u4e0d\\u9664\\u8272\",\"\\u9664\\u7ea2\\u8272\",\"\\u9664\\u7eff\\u8272\",\"\\u9664\\u84dd\
static std::string jsontext5("at\",\"cur\":0.000000,\"default\":0.000000,\"size\":4,\"range\":{\"min\":0.000000,\"max\":297.000000,\"step\":29.700000},\"depend_and\":[\"is-custom-area==true\"]},\"br-y\":{\"cat\":\"base\",\"readonly\":false,\"affect\":0,\"group\":\"base\",\"visible\":true,\"field\":\"Common\",\"pos\":0,\"unit\":\"None\",\"title\":\"\\u626b\\u63cf\\u533a\\u57df\\u4e0b\\u4fa7\\uff08mm\\uff09\",\"desc\":\"\\u81ea\\u5b9a\\u4e49\\u626b\\u63cf\\u533a\\u57df\\u53f3\\u4e0b\\u89d2y\\u5750\\u6807\",\"type\":\"float\",\"cur\":297.000000,\"default\":297.000000,\"size\":4,\"range\":{\"min\":0.000000,\"max\":297.000000,\"step\":29.700000},\"depend_and\":[\"is-custom-area==true\"]},\"page\":{\"cat\":\"base\",\"readonly\":false,\"affect\":0,\"group\":\"base\",\"visible\":true,\"field\":\"Common\",\"pos\":0,\"unit\":\"None\",\"title\":\"\\u626b\\u63cf\\u9875\\u9762\",\"desc\":\"\\u8bbe\\u7f6e\\u9875\\u9762\\u626b\\u63cf\\u65b9\\u5f0f\",\"type\":\"string\",\"cur\":\"\\u53cc\\u9762\",\"default\":\"\\u53cc\\u9762\",\"size\":40,\"range\":[\"\\u5355\\u9762\",\"\\u53cc\\u9762\",\"\\u8df3\\u8fc7\\u7a7a\\u767d\\u9875\\uff08\\u901a\\u7528\\uff09\",\"\\u8df3\\u8fc7\\u7a7a\\u767d\\u9875\\uff08\\u53d1\\u7968\\u7eb8\\uff09\",\"\\u5bf9\\u6298\"]},\"discardblank\":{\"cat\":\"base\",\"readonly\":false,\"affect\":0,\"group\":\"base\",\"visible\":true,\"field\":\"Common\",\"pos\":0,\"unit\":\"None\",\"title\":\"\\u8df3\\u8fc7\\u7a7a\\u767d\\u9875\",\"desc\":\"\",\"type\":\"bool\",\"cur\":false,\"default\":false,\"size\":4,\"depend_or\":[\"page!=\\u5bf9\\u6298\"]},\"blank-sensitivity\":{\"cat\":\"base\",\"readonly\":false,\"affect\":0,\"group\":\"base\",\"visible\":true,\"field\":\"Common\",\"pos\":0,\"unit\":\"None\",\"title\":\" \\u8df3\\u8fc7\\u7a7a\\u767d\\u9875\\u7075\\u654f\\u5ea6\",\"desc\":\"\\u6570\\u503c\\u8d8a\\u5927\\uff0c\\u5219\\u8d8a\\u5bb9\\u6613\\u8df3\\u8fc7\",\"type\":\"int\",\"cur\":30,\"default\":30,\"size\":4,\"range\":{\"min\":1,\"max\":100,\"step\":1},\"depend_or\":[\"page==\\u8df3\\u8fc7\\u7a7a\\u767d\\u9875\\uff08\\u53d1\\u7968\\u7eb8\\uff09\",\"==\\u8df3\\u8fc7\\u7a7a\\u767d\\u9875\\uff08\\u901a\\u7528\\uff09\",\"discardblank==true\"]},\"fold-type\":{\"cat\":\"base\",\"readonly\":false,\"affect\":0,\"group\":\"base\",\"visible\":true,\"field\":\"Common\",\"pos\":0,\"unit\":\"None\",\"title\":\"\\u5bf9\\u6298\\u6a21\\u5f0f\",\"desc\":\"\",\"type\":\"string\",\"cur\":\"\\u5de6\\u53f3\\u5bf9\\u6298\",\"default\":\"\\u5de6\\u53f3\\u5bf9\\u6298\",\"size\":200,\"range\":[\"\\u5de6\\u53f3\\u5bf9\\u6298\",\"\\u4e0a\\u4e0b\\u5bf9\\u6298\",\"\\u81ea\\u52a8\\u5bf9\\u6298\"],\"depend_or\":[\"page==\\u5bf9\\u6298\"]},\"resolution\":{\"cat\":\"base\",\"readonly\":false,\"affect\":0,\"group\":\"base\",\"visible\":true,\"field\":\"Common\",\"pos\":0,\"unit\":\"None\",\"title\":\"\\u5206\\u8fa8\\u7387\",\"desc\":\"\\u8bbe\\u7f6e\\u626b\\u63cf\\u56fe\\u50cf\\u7684\\u5206\\u8fa8\\u7387\",\"type\":\"int\",\"cur\":200,\"default\":200,\"size\":4,\"range\":{\"min\":100,\"max\":600,\"step\":1}},\"image-quality\":{\"cat\":\"base\",\"readonly\":false,\"affect\":0,\"group\":\"base\",\"visible\":true,\"field\":\"Common\",\"pos\":0,\"unit\":\"None\",\"title\":\"\\u753b\\u8d28\",\"desc\":\"\",\"type\":\"string\",\"cur\":\"\\u753b\\u8d28\\u4f18\\u5148\",\"default\":\"\\u753b\\u8d28\\u4f18\\u5148\",\"size\":200,\"range\":[\"\\u901f\\u5ea6\\u4f18\\u5148\",\"\\u753b\\u8d28\\u4f18\\u5148\"],\"depend_or\":[\"resolution>=300\"]},\"is-exchange\":{\"cat\":\"base\",\"readonly\":false,\"affect\":0,\"group\":\"base\",\"visible\":true,\"field\":\"Common\",\"pos\":0,\"unit\":\"None\",\"title\":\"\\u4ea4\\u6362\\u6b63\\u53cd\\u9762\",\"desc\":\"\\u4ea4\\u6362\\u6bcf\\u5f20\\u6587\\u7a3f\\u7684\\u6b63\\u53cd\\u9762\\u51fa\\u56fe\\u987a\\u5e8f\",\"type\":\"bool\",\"cur\":false,\"default\":false,\"size\":4,\"depend_and\":[\"page!=\\u5355\\u9762\"]},\"grp-2\":{\"cat\":\"base\",\"title\":\"\\u4eae\\u5ea6\",\"type\":\"group\",\"readonly\":false,\"affect\":0,\"group\":\"light\",\"field\":\"Common\",\"pos\":0,\"visible\":true,\"unit\":\"None\"},\"is-custom-gamma\":
static std::string jsontext6("\",\"readonly\":false,\"affect\":0,\"group\":\"imgproc\",\"visible\":true,\"field\":\"Common\",\"pos\":0,\"unit\":\"None\",\"title\":\"        \\u5de6\\u4fa7\\u7a7f\\u5b54\\u641c\\u7d22\\u8303\\u56f4\\u5360\\u5e45\\u9762\\u6bd4\\u4f8b\",\"desc\":\"\\u7a7f\\u5b54\\u641c\\u7d22\\u8303\\u56f4\\u5360\\u5e45\\u9762\\u6bd4\\u4f8b\",\"type\":\"float\",\"cur\":0.100000,\"default\":0.100000,\"size\":4,\"range\":{\"min\":0.000000,\"max\":0.500000,\"step\":0.050000},\"depend_or\":[\"is-rid-hole-l==true\"]},\"is-rid-hole-r\":{\"cat\":\"base\",\"readonly\":false,\"affect\":0,\"group\":\"imgproc\",\"visible\":true,\"field\":\"Common\",\"pos\":0,\"unit\":\"None\",\"title\":\"\\u7a7f\\u5b54\\u79fb\\u9664\\u2014\\u53f3\\u4fa7\",\"desc\":\"\\u7a7f\\u5b54\\u5728\\u7eb8\\u5f20\\u4e0a\\u7684\\u53f3\\u4fa7\",\"type\":\"bool\",\"cur\":false,\"default\":false,\"size\":4},\"search-hole-range-r\":{\"cat\":\"base\",\"readonly\":false,\"affect\":0,\"group\":\"imgproc\",\"visible\":true,\"field\":\"Common\",\"pos\":0,\"unit\":\"None\",\"title\":\"        \\u53f3\\u4fa7\\u7a7f\\u5b54\\u641c\\u7d22\\u8303\\u56f4\\u5360\\u5e45\\u9762\\u6bd4\\u4f8b\",\"desc\":\"\\u7a7f\\u5b54\\u641c\\u7d22\\u8303\\u56f4\\u5360\\u5e45\\u9762\\u6bd4\\u4f8b\",\"type\":\"float\",\"cur\":0.100000,\"default\":0.100000,\"size\":4,\"range\":{\"min\":0.000000,\"max\":0.500000,\"step\":0.050000},\"depend_or\":[\"is-rid-hole-r==true\"]},\"is-rid-hole-t\":{\"cat\":\"base\",\"readonly\":false,\"affect\":0,\"group\":\"imgproc\",\"visible\":true,\"field\":\"Common\",\"pos\":0,\"unit\":\"None\",\"title\":\"\\u7a7f\\u5b54\\u79fb\\u9664\\u2014\\u4e0a\\u4fa7\",\"desc\":\"\\u7a7f\\u5b54\\u5728\\u7eb8\\u5f20\\u7684\\u4e0a\\u90e8\",\"type\":\"bool\",\"cur\":false,\"default\":false,\"size\":4},\"search-hole-range-t\":{\"cat\":\"base\",\"readonly\":false,\"affect\":0,\"group\":\"imgproc\",\"visible\":true,\"field\":\"Common\",\"pos\":0,\"unit\":\"None\",\"title\":\"        \\u4e0a\\u4fa7\\u7a7f\\u5b54\\u641c\\u7d22\\u8303\\u56f4\\u5360\\u5e45\\u9762\\u6bd4\\u4f8b\",\"desc\":\"\\u7a7f\\u5b54\\u641c\\u7d22\\u8303\\u56f4\\u5360\\u5e45\\u9762\\u6bd4\\u4f8b\",\"type\":\"float\",\"cur\":0.100000,\"default\":0.100000,\"size\":4,\"range\":{\"min\":0.000000,\"max\":0.500000,\"step\":0.050000},\"depend_or\":[\"is-rid-hole-t==true\"]},\"is-rid-hole-b\":{\"cat\":\"base\",\"readonly\":false,\"affect\":0,\"group\":\"imgproc\",\"visible\":true,\"field\":\"Common\",\"pos\":0,\"unit\":\"None\",\"title\":\"\\u7a7f\\u5b54\\u79fb\\u9664\\u2014\\u4e0b\\u4fa7\",\"desc\":\"\\u7a7f\\u5b54\\u5728\\u7eb8\\u5f20\\u7684\\u4e0b\\u90e8\",\"type\":\"bool\",\"cur\":false,\"default\":false,\"size\":4},\"search-hole-range-b\":{\"cat\":\"base\",\"readonly\":false,\"affect\":0,\"group\":\"imgproc\",\"visible\":true,\"field\":\"Common\",\"pos\":0,\"unit\":\"None\",\"title\":\"        \\u4e0b\\u4fa7\\u7a7f\\u5b54\\u641c\\u7d22\\u8303\\u56f4\\u5360\\u5e45\\u9762\\u6bd4\\u4f8b\",\"desc\":\"\\u7a7f\\u5b54\\u641c\\u7d22\\u8303\\u56f4\\u5360\\u5e45\\u9762\\u6bd4\\u4f8b\",\"type\":\"float\",\"cur\":0.100000,\"default\":0.100000,\"size\":4,\"range\":{\"min\":0.000000,\"max\":0.500000,\"step\":0.050000},\"depend_or\":[\"is-rid-hole-b==true\"]},\"grp-4\":{\"cat\":\"base\",\"title\":\"\\u9001\\u7eb8\\u65b9\\u5f0f\\u8bbe\\u7f6e\",\"type\":\"group\",\"readonly\":false,\"affect\":0,\"group\":\"feeder\",\"field\":\"Common\",\"pos\":0,\"visible\":true,\"unit\":\"None\"},\"scan-mode\":{\"cat\":\"base\",\"readonly\":false,\"affect\":0,\"group\":\"feeder\",\"visible\":true,\"field\":\"Common\",\"pos\":0,\"unit\":\"None\",\"title\":\"\\u626b\\u63cf\\u5f20\\u6570\",\"desc\":\"\\u9009\\u62e9\\u6307\\u5b9a\\u6570\\u91cf\\u626b\\u63cf\\u6216\\u8fde\\u7eed\\u626b\\u63cf\",\"type\":\"string\",\"cur\":\"\\u8fde\\u7eed\\u626b\\u63cf\",\"default\":\"\\u8fde\\u7eed\\u626b\\u63cf\",\"size\":32,\"range\":[\"\\u8fde\\u7eed\\u626b\\u63cf\",\"\\u626b\\u63cf\\u6307\\u5b9a\\u5f20\\u6570\"]},\"scan-count\":{\"cat\":\"base\",\"readonly\":false,\"affect\":0,\"group\":\"feeder\",\"visible\":true,\"field\":\"Common\",\"pos\":0,\"unit\":\"No

namespace settingsdsp_300
{
	scanner_err device_status_to_hg_err(int  usbdata)
	{
		scanner_err code = SCANNER_ERR_NO_DATA;
		switch (usbdata)
		{
		case setting3288dsp::DOUBLE_FEED_IMAGE:
		case setting3288dsp::HAVE_IMAGE:
			code = SCANNER_ERR_OK;
			break;
		case setting3288dsp::STOP_SCAN:
			code = SCANNER_ERR_DEVICE_STOPPED;
			break;
		case setting3288dsp::COUNT_MODE:
			code = SCANNER_ERR_DEVICE_COUNT_MODE;
			break;
		case setting3288dsp::NO_FEED:
			code = SCANNER_ERR_DEVICE_NO_PAPER;
			break;
		case setting3288dsp::OPEN_COVER:
			code = SCANNER_ERR_DEVICE_COVER_OPENNED;
			break;
		case setting3288dsp::FEED_IN_ERROR:
			code = SCANNER_ERR_DEVICE_FEEDING_PAPER;
			break;
		case setting3288dsp::PAPER_JAM:
			code = SCANNER_ERR_DEVICE_PAPER_JAMMED;
			break;
		case setting3288dsp::DETECT_DOUBLE_FEED:
			code = SCANNER_ERR_DEVICE_DOUBLE_FEEDING;
			break;
		case setting3288dsp::DETECT_STAPLE:
			code = SCANNER_ERR_DEVICE_STAPLE_ON;
			break;
		case setting3288dsp::PAPER_SKEW:
			code = SCANNER_ERR_DEVICE_PAPER_SKEW;
			break;
		case setting3288dsp::HARDWARE_ERROR:
			code = SCANNER_ERR_DEVICE_NOT_SUPPORT;
			break;
		case setting3288dsp::PC_SCAN_BUSY_or_ERROR:
			code = SCANNER_ERR_DEVICE_PC_BUSY;
			break;
		case setting3288dsp::SIZE_ERROR:
			code = SCANNER_ERR_DEVICE_SIZE_CHECK;
			break;
		case setting3288dsp::AUTO_FLAT_FINISHED:
			code = SCANNER_ERR_DEVICE_AUTO_FAIL_OVER;
			break;
		case setting3288dsp::AUTO_FLATTING:
			code = SCANNER_ERR_DEVICE_AUTO_FAIL_INFO;
			break;
		case setting3288dsp::HAVE_HOLE:
			code = SCANNER_ERR_DEVICE_MAYBE_IS_HOLE;
			break;
		case setting3288dsp::IMAGE_DIRTY_BAND:
		case setting3288dsp::IMAGE_DIRTY_CIS:
			code = SCANNER_ERR_DEVICE_LENS_DIRTY;
			break;
		default:
			code = SCANNER_ERR_NO_DATA;
			break;
		}

		return code;
	}
}
hg_scanner_300::hg_scanner_300(const char* dev_name,int pid, usb_io* io) : 
	hg_scanner(G100Serial, dev_name, io,pid)
	,papersize(pid)
	,is_devs_sleep_(false)
{
	if (init_settings(pid_))
	{
		if (pid_ == 0x300)
			init_settings((jsontext1 + jsontext2 + jsontext3).c_str());
		else
			init_settings((jsontext4 + jsontext5 + jsontext6).c_str());
	}

	dsp_config.value = 0;
	dsp_config.params_3288.enableLed = 1; //默认值
	dsp_config.params_3288.isCorrect = 1;
	
	int ret = initdevice();
	if (ret != SCANNER_ERR_OK)
	{
		return;
	}
	std::string fv(get_firmware_version()),
		sn(get_serial_num());
	if (fv.empty() || sn.empty())
		return;

	string dev = fv.substr(0, 2);
	string ver = fv.substr(2, 3);
	string date = fv.substr(5, 5);
	string year = fv.substr(4, 2);
	string devType;
	string year_date = fv.substr(4, 6);

	firmware_sup_morr_ = year_date.compare("230724") >= 0 ? true : false;	
	firmware_sup_double_check = year_date.compare("231027") >= 0 ? true : false;
	firmware_sup_dirty_check = year_date.compare("231027") >= 0 ? true : false;
	firmware_sup_backup_restore = year_date.compare("231021") >= 0 ? true : false;
	firmware_sup_boardTime = year_date.compare("231021") >= 0 ? true : false;
	firmware_sup_double_img = year_date.compare("231027") >= 0 ? true : false;
	firmware_sup_log_export_G300_ = year_date.compare("230430") >= 0 ? true : false;

#ifndef MAPPING_FUNCTION_IN_BASE
	init_setting_map(setting_map_, ARRAY_SIZE(setting_map_));//优先初始化
#endif
	
	if (firmware_sup_boardTime)
		update_boarddatetime();//暂未考虑版本兼容情况
	//wait_read_int.notify();
	status_ = SCANNER_ERR_OK;
}
hg_scanner_300::~hg_scanner_300()
{}
int hg_scanner_300::on_scanner_closing(bool force)
{
	return SCANNER_ERR_OK;
}
void hg_scanner_300::thread_handle_usb_read(void)
{
	int			 ret 	= SCANNER_ERR_OK,
				status	= SCANNER_ERR_OK;
	StopWatch	sw;
	sw.reset();
	SANE_Image_Statu	statu = IMG_STATUS_OK;
	int img_num = 0;
	savestatus_.clear();
	while (run_)
	{
		USBCB usb={0};
		ret = get_scanner_status(usb);
		if (ret && ret != SCANNER_ERR_NO_DATA)
		{
			VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "status from bulk point is '%s'\n", hg_scanner_err_description(ret));
		}

		//printf("usb.u32_Data = %d  ret = %d\r\n",usb.u32_Data,ret);
		//如果设备出现卡纸 或者双张等设备信息问题，需要等到设备进行发送stop才能停止。 所以始终以 "停止" 消息为结束信号
		//如果有图的情况下，并且卡纸或双张等，设备会先发送卡纸双张信息。所以接受到错误信息之后，仍需要把图像取出来。
		if (ret == SCANNER_ERR_DEVICE_STOPPED)
		{
			status_ = !savestatus_.empty() ? savestatus_[0] : SCANNER_ERR_OK;//以第一个消息为准
			savestatus_.clear();
			if (user_cancel_)
			{
				if (status_ && status_ != SCANNER_ERR_DEVICE_STOPPED)		// thread_handle_image_process maybe call stop() when insufficient memory occurs .
					ret = status_;
				else
					status_ = ret = SCANNER_ERR_USER_CANCELED;
				VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "%s\n", hg_scanner_err_description(status_));
			}
			VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,  "'STOPSCAN' message in usb thread:%s\n" , hg_scanner_err_description(status_));

			break;
		}
		if (ret != SCANNER_ERR_OK && 
			ret != SCANNER_ERR_DEVICE_STOPPED && 
			ret != SCANNER_ERR_NO_DATA && 
			ret != SCANNER_ERR_DEVICE_AUTO_FAIL_INFO && 
			ret != SCANNER_ERR_DEVICE_AUTO_FAIL_OVER)
		{
			//statu = last_usb_image_statu(ret); 
			savestatus_.push_back(ret);
		}
		else if (ret != SCANNER_ERR_NO_DATA && 
				 ret != SCANNER_ERR_DEVICE_AUTO_FAIL_OVER && 
				 ret != SCANNER_ERR_DEVICE_AUTO_FAIL_INFO)
		{
			statu = IMG_STATUS_OK;
		}
		else if (ret == SCANNER_ERR_DEVICE_AUTO_FAIL_OVER)
		{
			is_auto_falt = false;
			status_ = ret;
			std::string msg;
			int count = usb.u32_Count;
			msg.resize(count);

			{
				std::lock_guard<std::mutex>      lock(io_lock_);
				ret = io_->read_bulk(&msg[0], &count);
			}
			if (ret == SCANNER_ERR_OK)
				notify_ui_working_status(msg.c_str(), SANE_EVENT_STATUS, status_);
			else
				status_ = ret;

			break;
		}
		else if (ret == SCANNER_ERR_DEVICE_AUTO_FAIL_INFO)
		{
			sw.reset();
			status_ = ret;

			std::string msg;
			int count = usb.u32_Count;
			msg.resize(count);
			ret = io_->read_bulk(&msg[0], &count);
			if (ret == SCANNER_ERR_OK)
			{
				status_= ret = SCANNER_ERR_DEVICE_AUTO_FAIL_INFO;
				char buf[1024];
				strcpy(buf, msg.c_str());
				notify_ui_working_status(buf, SANE_EVENT_STATUS, status_);	
				msg.clear();
			}
			else
			{
				status_ = ret;
				break;
			}
		}
		else if (ret == SCANNER_ERR_IO)
		{
			status_ = ret;
			VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "%s\n", hg_scanner_err_description(status_));
			break;
		}
		if (sw.elapsed_ms() > 30000 && img_conf_.resolution_dst != 600)//防止状态信息一直取不上来导致卡死
		{
			if ((img_conf_.papertype == TwSS::MaxSize || img_conf_.papertype == TwSS::USStatement) && pid_ == 0x0300 && firmware_sup_dpi_600)
			{
				hg_log::log(LOG_LEVEL_WARNING, "while 30S\n");
			}
			else
			{
				if (!savestatus_.empty())//以第一个消息为准
				{
					status_ = savestatus_[0];
				}
				savestatus_.clear();
				hg_log::log(LOG_LEVEL_WARNING, "Get Status TimeOut,get image out 30S\n");
				notify_ui_working_status(hg_log::lang_load(ID_STATU_DESC_SCANNER_ERR_DEVICE_GET_IMAGE_OUTTIME), SANE_EVENT_ERROR, status_);	// 鍙栧浘閫氫俊瓒呮椂
				break;
			}
		}
		if (sw.elapsed_s() > 130)
		{
			if (!savestatus_.empty())//以第一个消息为准
			{
				status_ = savestatus_[0];
			}
			savestatus_.clear();
			hg_log::log(LOG_LEVEL_WARNING, "MaxSize TimeOut,Get Image 130s\n");
			notify_ui_working_status(hg_log::lang_load(ID_STATU_DESC_SCANNER_ERR_DEVICE_GET_IMAGE_OUTTIME), SANE_EVENT_ERROR, status_);	// 鍙栧浘閫氫俊瓒呮椂
			break;
		}
		if (ret == SCANNER_ERR_OK && usb.u32_Count > 0)
		{
			int totalNum = usb.u32_Count & 0x3fffffff;	// 2022-08-04: 兼容Android，默认图片大小均在1GB以内
			VLOG_MINI_2(LOG_LEVEL_WARNING, "Get Scaner Image Size:%d bytes,Image Num[%d]\n", totalNum,img_num);
			img_num++;
			if (totalNum)
			{
				std::shared_ptr<tiny_buffer> imagedata(aquire_memory(totalNum));

				if (!imagedata.get())
				{
					status_ = SCANNER_ERR_INSUFFICIENT_MEMORY;
					break;
				}

				imagedata->set_image_statu(usb.u32_Data == setting3288dsp::DOUBLE_FEED_IMAGE ? IMG_STATUS_DOUBLE : IMG_STATUS_OK);
				ret = get_img_data(imagedata);
				//io_->set_timeout(200);

				if (ret == SCANNER_ERR_OK)
				{
					ret = pop_image();
					sw.reset();
					if (ret != SCANNER_ERR_OK)
					{
						status_ = ret;
						break;
					}
				}
				else
				{
					status_ = ret;
					break;
				}
			}
		}	
		this_thread::sleep_for(chrono::milliseconds(10));
	}
	VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "USB thread exit with code: %s, status = %s\n", hg_scanner_err_name(ret), hg_scanner_err_description(status_));
}
int hg_scanner_300::discard_all_images(void)
{
	int block = 1024 * 512, len = block;
	uint8_t* buf = new uint8_t[block];

	if(buf)
	{
		std::lock_guard<std::mutex>      lock(io_lock_);
		int cnt = 0, ret = SCANNER_ERR_OK;

		io_->set_timeout(1000);
		while ((ret = io_->read_bulk(buf, &len)) == SCANNER_ERR_OK)
		{
			len = block;
			this_thread::sleep_for(chrono::milliseconds(10));
			if (cnt++ > 10)
			{
				break;
			}
		}
		delete[] buf;
	}


	//if (is_read_int)
	//{
	//	initdevice();
	//}
	return SCANNER_ERR_OK;
}
int hg_scanner_300::get_roller_life(void)
{
	return pid_ == 300 ? 150000 : 200000;
}
int hg_scanner_300::do_start(void)
{
	bool	handled = false;
	int		ret = try_third_app_handle_start(handled), //sane调用是每次都会调用一次start和stop
			count = -1, 
			val = 1;

	user_cancel_ = false;
	
	// for third-sane-app invoking, added on 2022-05-19
	if (handled)
		return ret;

	final_imgs_.clear();        
        imgs_.Clear();	// move from scanning done

	ret = get_scan_is_sleep(val);
	if (!val && ret == SCANNER_ERR_OK)
	{
		status_ = SCANNER_ERR_DEVICE_SLEEPING;

		return status_;
	}
	ret = get_scanner_paperon(val);
	if (!val && ret == SCANNER_ERR_OK)
	{
		status_ = SCANNER_ERR_DEVICE_NO_PAPER;

		return status_;
	}
	if (ret != SCANNER_ERR_OK)
	{
		return ret;
	}
	if (is_devs_sleep_)//设备在睡眠的状态当中获取固件是失败的，所以在这个地方进行标志位设置。（总感觉不保险）
	{
		is_devs_sleep_ = false;
		set_kernelsnap_ver();
		int paper = image_prc_param_.bits.paper;
		on_paper_changed(paper);
		int dpi = resolution_;
		on_resolution_changed(dpi);
	}
	ret = writedown_device_configuration(true);
	if (ret == SCANNER_ERR_OK)
		writedown_image_configuration();
	else
	{
		status_ = ret;
		return ret;
	}
	printf_devconfig();
	USBCB usb = { setting3288dsp::START_COMMAND, img_conf_.scannum, 0};
	{
		std::lock_guard<std::mutex>      lock(io_lock_);
		ret = writeusb(usb);
	}
	
	if(ret == SCANNER_ERR_OK)
	{
		wait_usb_.notify();
		std::this_thread::sleep_for(std::chrono::milliseconds(300));
		ret = try_third_app_after_start(ret);
	}
	else
		status_ = ret;
	VLOG_MINI_1(LOG_LEVEL_WARNING, "----------Main start scan status : %s----------\n", hg_scanner_err_description(ret));
	return ret;
}
int hg_scanner_300::do_stop(void)
{
	int ret = SCANNER_ERR_OK;

	USBCB usbcb = { setting3288dsp::STOP, 0, 0};
	{
		std::lock_guard<std::mutex>      lock(io_lock_);
		ret = writeusb(usbcb);
	}
        VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "Write stop command = %d\n", ret);

	if (status_ == SCANNER_ERR_DEVICE_BUSY)
	{
		LOG_INFO(LOG_LEVEL_DEBUG_INFO,"stop status is busy\r\n");
		std::this_thread::sleep_for(std::chrono::milliseconds(2000));
	}
	user_cancel_ = true;
	if (ret == SCANNER_ERR_OK)
	{
		status_ = SCANNER_ERR_DEVICE_STOPPED;
	}
	//final_imgs_.clear();

	return ret;
}
int hg_scanner_300::writeusb(USBCB &usb)
{
	int ret = SCANNER_ERR_OK;
	int len = sizeof(usb);
	
	ret = io_->write_bulk(&usb,&len);
	if (ret)
	{
		status_	= ret;
	}
	
	return ret;
}
int hg_scanner_300::readusb(USBCB &usb)
{
	int ret = SCANNER_ERR_OK;
	int len = sizeof(USBCB);

	ret = io_->read_bulk(&usb,&len);
	if (ret)
	{
		status_	= ret;
	}
	
	return ret;
}
int hg_scanner_300::pop_image()
{
	int ret = SCANNER_ERR_OK;

	USBCB usbcb = { setting3288dsp::POP_IMAGE, 0, 0};
	{
		std::lock_guard<std::mutex>      lock(io_lock_);
		ret = writeusb(usbcb);
	}

	return ret;
}
int hg_scanner_300::get_scanner_status(USBCB &usb)
{
	std::lock_guard<std::mutex>      lock(io_lock_);
	int 		ret = SCANNER_ERR_OK;

	usb = { setting3288dsp::GET_DSP_STATUS, 0, 0};
	io_->set_timeout(2000);
	ret = writeusb(usb);
	if (ret != SCANNER_ERR_OK)
	{
		VLOG_MINI_1(LOG_LEVEL_WARNING, "get_scanner_status write usb: %s\n", hg_scanner_err_name(ret));
		return ret;
	}
	ret = readusb(usb);
	
	if (ret != SCANNER_ERR_OK)
	{
		VLOG_MINI_1(LOG_LEVEL_WARNING, "get_scanner_status read usb: %s\n", hg_scanner_err_name(ret));
		status_ = ret;
		return ret;
	}
	scanner_err code = settingsdsp_300::device_status_to_hg_err(usb.u32_Data);
	return code ;
}
int hg_scanner_300::get_img_data(std::shared_ptr<tiny_buffer>& imagedata)
{
	int total = imagedata->size(),
		ret = SCANNER_ERR_OK,
		index = 0,
		block = total;

	USBCB usb{ setting3288dsp::GET_IMAGE, 0, total };
	{
		std::lock_guard<std::mutex>      lock(io_lock_);
		ret = writeusb(usb);
		if (ret != SCANNER_ERR_OK)
		{
			VLOG_MINI_1(LOG_LEVEL_WARNING, "get_img_data setting3288dsp::GET_IMAGE write usb: %s\n", hg_scanner_err_name(ret));
		}
		else
		{
			VLOG_MINI_1(LOG_LEVEL_FATAL, "get_img_data get data total len is:%d\n", total);
			while (total > 0)
			{
				block = 512 * 1024;

				if (total < block)
					block = total;

				unsigned int size = block;
				void* buf = imagedata->data(index, &size);
				if (!buf)
				{
					VLOG_MINI_3(LOG_LEVEL_FATAL, "memory(0x%08x + %u) fatal when read USB image %d !!!\n", index, block, usb_img_index_);
					ret = SCANNER_ERR_INSUFFICIENT_MEMORY;
					break;
				}
				block = size;
				ret = io_->read_bulk(buf, &block);

				if (ret != SCANNER_ERR_OK && ret != SCANNER_ERR_TIMEOUT)
				{
					VLOG_MINI_1(LOG_LEVEL_FATAL, "get_img_data read_data:%s!!! \n", hg_scanner_err_name(ret));
					break;
				}
				else if (ret == SCANNER_ERR_TIMEOUT && io_->get_timeout() > 3000)
				{
					VLOG_MINI_2(LOG_LEVEL_FATAL, "get_img_data read_data:%s!!!  ,get_timeout is %d\n", hg_scanner_err_name(ret), io_->get_timeout());
					break;
				}

				index += block;
				total -= block;
			}
		}
	}
	if (ret == SCANNER_ERR_OK)
	{
		ret = save_usb_data(imagedata);
	}
	else
	{
		VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "Read image data from USB err: %s\n", hg_scanner_err_name(ret));
		do_stop();
		string str = STATU_DESC_SCANNER_ERR_DEVICE_GET_IMAGE_ERR;
		str = str + '-' + STATU_DESC_SCANNER_ERR_DEVICE_STOPPED;
		notify_ui_working_status(str.c_str(), SANE_EVENT_ERROR, ret);
	}

	return status_ = ret;
}

int hg_scanner_300::writedown_device_configuration(bool type,setting_hardware::HGSCANCONF_3288 *d)
{
	if (!type)
		return SCANNER_ERR_OK;
	
	int ret 	= SCANNER_ERR_OK,
		len 	= 0;
	SIZE size;
	setting_hardware::HGSCANCONF_3288 p = dsp_config;
	if (!d)
	{
		p.params_3288.lutmode = keep_watermark_;
		d = &p;
	}
	if (is_multiout)
	{
		d->params_3288.isColor = image_prc_param_.bits.multi_out == MULTI_GRAY_AND_BW ? 0 : 1;
	}
	else if ((image_prc_param_.bits.color_mode == COLOR_MODE_256_GRAY
		|| image_prc_param_.bits.color_mode == COLOR_MODE_BLACK_WHITE)
		&& image_prc_param_.bits.rid_color != RID_COLOR_NONE)
	{
		d->params_3288.isColor = 1;
	}
	if (paper_size_ == TwSS::USStatement || paper_size_ == TwSS::MaxSize)
	{
		//d->params_3288.pageSize = setting3288dsp::G400_MAXSIZE;
	}
	if (paper_size_ == TwSS::None || paper_size_ == TwSS::USStatement || paper_size_ == TwSS::MaxSize || paper_size_ == TwSS::Trigeminy)
	{
		d->params_3288.enableSizeDetect = false;
	}

	if ((is_quality_ == IMG_SPEED) && (resolution_ >= 300))
	{
		VLOG_MINI_1(LOG_LEVEL_WARNING, "writedown_device_configuration is_quality_ is .(%d)\n", is_quality_)
		d->params_3288.dpi = 1;
	}
	if (image_prc_param_.bits.remove_morr && firmware_sup_morr_ && resolution_ < 500)
	{
		d->params_3288.moire = true;
	}
	else
		d->params_3288.moire = false;

	if (image_prc_param_.bits.paper == PAPER_AUTO_MATCH
		|| image_prc_param_.bits.paper == PAPER_MAX_SIZE
		|| image_prc_param_.bits.paper == PAPER_MAX_SIZE_CLIP
		|| image_prc_param_.bits.paper == PAPER_TRIGEMINY
		|| image_prc_param_.bits.paper == PAPER_16K
		|| image_prc_param_.bits.paper == PAPER_8K
		|| image_prc_param_.bits.paper == PAPER_16K_LATERAL
		)
	{
		d->params_3288.enableSizeDetect = false;
	}
	size = papersize.GetPaperSize(TwSS::A4, 200, img_conf_.paperAlign);
	dsp_config.params_3288.dstHeight = (int)((size.cy + 200) / 100);

	USBCB usbcb = { setting3288dsp::CONFIGURED_DATA, d->value, 0};
	len = sizeof(USBCB);
	{
		std::lock_guard<std::mutex>      lock(io_lock_);
		ret = io_->write_bulk(&usbcb, &len);
	}
	if (type)
	{
		printf_devconfig(d);
	}
	VLOG_MINI_1(LOG_LEVEL_WARNING, "writedown_device_configuration is .(%s)\n", hg_scanner_err_name(ret));

	return ret;
}
int hg_scanner_300::on_color_mode_changed(int& color_mode)
{
	dsp_config.params_3288.isColor = (color_mode == COLOR_MODE_BLACK_WHITE || color_mode == COLOR_MODE_256_GRAY) ? 0 : 1;
	return SCANNER_ERR_OK;
}
int hg_scanner_300::on_paper_changed(int& paper)
{
	bool exact = true;
	Paper_Map* papermap = pid_ == 0x0300 && firmware_sup_dpi_600 ? paper_map_3288_600dpi : paper_map_3288;
	int paperlen = pid_ == 0x0300 && firmware_sup_dpi_600 ? ARRAY_SIZE(paper_map_3288_600dpi) : ARRAY_SIZE(paper_map_3288);

	int ind = hgpaper_to_devspaper(papermap, paperlen, paper, &exact, &paper_size_),
		ret = exact ? SCANNER_ERR_OK : SCANNER_ERR_NOT_EXACT;

	if (dsp_config.params_3288.pageSize != papermap[ind].dev_value)
	{
		int old = dsp_config.params_3288.pageSize;

		dsp_config.params_3288.pageSize = papermap[ind].dev_value;
		ret = writedown_device_configuration();
		if (ret)
		{
			dsp_config.params_3288.pageSize = old;
			for (int i = 0; i < paperlen; ++i)
			{
				if (papermap[i].dev_value == old)
				{
					paper = papermap[i].paper;
					break;
				}
			}
		}
		else if (!exact)
			ret = SCANNER_ERR_NOT_EXACT;
	}
	return ret;
}
int hg_scanner_300::on_paper_check_changed(bool& check)
{
	if (!firmware_sup_dpi_600 && check)
	{
		check = false;
		return SCANNER_ERR_DEVICE_NOT_SUPPORT;
	}
	int ret = SCANNER_ERR_OK;
	if(dsp_config.params_3288.enableSizeDetect ^ check)
	{
		dsp_config.params_3288.enableSizeDetect = check;
		ret = writedown_device_configuration();
		if (ret)
		{
			dsp_config.params_3288.enableSizeDetect = !check;
			check = dsp_config.params_3288.enableSizeDetect;
		}
	}
	return ret;
}
int hg_scanner_300::on_resolution_changed(int& dpi)
{
	int ret = SCANNER_ERR_OK;
	if (firmware_sup_dpi_600)
		dsp_config.params_3288.dpi = dpi == 600 ? 3 : (dpi < 599 && dpi>=300) ? 2 : 1;
	else if (firmware_sup_dpi_300)
		dsp_config.params_3288.dpi = (dpi >= 300) ? 2 : 1;
	else
		dsp_config.params_3288.dpi = 1;

	VLOG_MINI_3(LOG_LEVEL_WARNING, "on_resolution_changed is dpi:%d  .set device dpi(%d),firmware_sup_dpi_300 is :%d\n", dpi, dsp_config.params_3288.dpi, firmware_sup_dpi_300);

	ret = writedown_device_configuration();
	return ret;
}
int hg_scanner_300::on_ultrasonic_check_changed(bool& check)
{
	int ret = SCANNER_ERR_OK;

	if (dsp_config.params_3288.doubleFeeded ^ check)
	{
		dsp_config.params_3288.doubleFeeded = check;
		ret = writedown_device_configuration();
		if (ret)
		{
			dsp_config.params_3288.doubleFeeded = !check;
			check = dsp_config.params_3288.doubleFeeded;
		}
	}
	return ret;
}
int hg_scanner_300::set_kernelsnap_ver()
{
	int ret = SCANNER_ERR_OK;

	string fw = get_firmware_version();
	if (!fw.empty())
	{
		if (atoi(fw.substr(4, 6).c_str()) >= 221106 && atoi(fw.substr(4, 6).c_str()) < 230210)
			firmware_sup_dpi_300 = true;
		else if (atoi(fw.substr(4, 6).c_str()) >= 230210)
			firmware_sup_dpi_600 = true;
		else
		{
			firmware_sup_dpi_300 = false;
			firmware_sup_dpi_600 = false;
		}
		firmware_sup_history_cnt = atoi(fw.substr(4, 6).c_str()) >= 220303 ? true : false;
	}
	else
	{
		ret = SCANNER_ERR_NO_DATA;
	}

	VLOG_MINI_2(LOG_LEVEL_WARNING, "hg_scanner_300 firmware_sup_dpi_300 :%d ,firmware_sup_dpi_600:%d\n", firmware_sup_dpi_300, firmware_sup_dpi_600);
	return SCANNER_ERR_OK;
}
int hg_scanner_300::agreement(TwSS tw,int align)
{
	int ret = SCANNER_ERR_OK;
	SIZE size;
	setting_hardware::HGSCANCONF_3288 d = dsp_config;
	size = papersize.GetPaperSize(TwSS::A4,200,align);
	dsp_config.params_3288.dstHeight = (int)((size.cy + 200)/100);
	ret = writedown_device_configuration(true,&d);
	return ret;
}
int hg_scanner_300::initdevice()
{
	io_->set_timeout(2000);

	int val = 0,
		ret = SCANNER_ERR_OK;
		status_ = ret;
	int cnt = 0;

	ret = get_scan_is_sleep(val);
	if (!val && ret == SCANNER_ERR_OK)
	{
		is_devs_sleep_ = status_ = SCANNER_ERR_DEVICE_SLEEPING;
	}
	if (status_ != SCANNER_ERR_DEVICE_SLEEPING)
	{
		string fw = get_firmware_version();
		if (!fw.empty())
		{
			if (fw.substr(4, 6) == "230303")
			{
				string scanner_path = hg_log::get_module_full_path(MODULE_NAME_SCANNER);
				scanner_path = scanner_path.substr(0, scanner_path.size() - strlen(MODULE_NAME_SCANNER));
				scanner_path += "update.zip";
				set_firmware_upgrade(scanner_path);
				return SCANNER_ERR_OK;
			}
		}
	}
	if (status_ != SCANNER_ERR_DEVICE_SLEEPING)
	{
		set_kernelsnap_ver();
		is_devs_sleep_ = false; // 睡眠唤醒 客户提前点击设置这边固件版本号 还没有做判断的
	}
	return status_;
}
void hg_scanner_300::writedown_image_configuration(void)
{
	SCANCONF	ic;
	int			len = sizeof(ic);

	bzero(&ic, len);

	ic.contrast = contrast_;
	ic.brightness = bright_;
	if (image_prc_param_.bits.text_direction != TEXT_DIRECTION_AUTO)
		ic.imageRotateDegree = image_prc_param_.bits.text_direction;
	else
		ic.imageRotateDegree = 0;
	if (test_1_paper_)
	{
		LOG_INFO(LOG_LEVEL_DEBUG_INFO, "scanning mode: testing ONE paper ...\n");
		ic.scannum = 1;
	}
	else
		ic.scannum = scan_count_;
	ic.en_sizecheck = dsp_config.params_3288.enableSizeDetect;
	ic.hardwarecaps.en_skrewdetect = 0;
	ic.hardwarecaps.en_doublefeed = dsp_config.params_3288.doubleFeeded;
	ic.hardwarecaps.en_stapledetect = 0;
	ic.hardwarecaps.skrewdetectlevel = 0;

	// ic.hardwarecaps.is_autopaper = dsp_config_.params_dsp.is_autopaper;
	ic.hardwarecaps.capturepixtype = 0;						//暂无参数  获取图像类型
	ic.hardwarecaps.lowpowermode = LowPowerMode::Min_None;	//暂无参数 	设置休眠时间   两个参数3399未使用
	image_configuration(ic);
}
void hg_scanner_300::printf_devconfig(setting_hardware::HGSCANCONF_3288 *d)
{
	if (!d)
		d = &dsp_config;

	VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"dsp_config.params_3288.doubleFeeded:%d\r\n",d->params_3288.doubleFeeded);
	VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"dsp_config.params_3288.dpi:%d\r\n",d->params_3288.dpi);
	VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"dsp_config.params_3288.dstHeight:%d\r\n",d->params_3288.dstHeight);
	VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"dsp_config.params_3288.enableLed:%d\r\n",d->params_3288.enableLed);
	VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"dsp_config.params_3288.isColor:%d\r\n",d->params_3288.isColor);
	VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"dsp_config.params_3288.isCorrect:%d\r\n",d->params_3288.isCorrect);
	VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"dsp_config.params_3288.pageSize:%d\r\n",d->params_3288.pageSize);
	VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"dsp_config.params_3288.reversed1:%d\r\n",d->params_3288.reversed1);
	VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"dsp_config.params_3288.reversed2:%d\r\n",d->params_3288.reversed2);
	VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"dsp_config.params_3288.enableSizeDetect:%d\r\n",d->params_3288.enableSizeDetect);
	VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "dsp_config.params_3288.dirty_detect:%d\r\n", d->params_3288.dirty_detect);
	VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO,"dsp_config.params_3288.value:%d\r\n",d->value);
}


int hg_scanner_300::get_devs_distortion_check_val(float& data, int dpi, int dir)
{
	int ret = SCANNER_ERR_OK;
	USBCB usbcb = { dir ? setting3288dsp::GET_JUST_COF_V : setting3288dsp::GET_JUST_COF_H ,0,dpi };
	int len = sizeof(usbcb);
	{
		ret = io_->write_bulk(&usbcb, &len);
		if (ret != SCANNER_ERR_OK)
		{
			return ret;
		}

		io_->set_timeout(3000);
		ret = io_->read_bulk(&usbcb, &len);
	}
	if (ret != SCANNER_ERR_OK)
	{
		return ret;
	}

	int val = usbcb.u32_Data;
	data = *(float*)&val;
}

int hg_scanner_300::update_boarddatetime()
{
	if (!firmware_sup_boardTime)
		return SCANNER_ERR_DEVICE_NOT_SUPPORT;

	USBCB usbcb = { setting3288dsp::GET_DATETIME,0,0 };
	int len = sizeof(usbcb);
	int size = 0;
	int ret = io_->write_bulk(&usbcb, &len);
	if (ret == SCANNER_ERR_OK)
	{
		len = sizeof(usbcb);
		ret = io_->read_bulk(&usbcb, &len);
		if (usbcb.u32_Count == 512 || usbcb.u32_Count == 0)
		{
			VLOG_MINI_1(LOG_LEVEL_FATAL, "GET_DATETIME  error data lenght\n", 0);
			return SCANNER_ERR_ACCESS_DENIED;
		}
		std::string datenow;
		datenow.resize(usbcb.u32_Count);
		size = datenow.size();
		io_->read_bulk(&datenow[0], &size);
		VLOG_MINI_1(LOG_LEVEL_FATAL, "Boardtime : %s \n", datenow.c_str());
	}
	else
	{
		VLOG_MINI_1(LOG_LEVEL_FATAL, "GET_DATETIME  usb communication failed\n", 0);
		return SCANNER_ERR_ACCESS_DENIED;
	}

	//获取当前系统时间
	time_t now_time;
	struct tm* info;
	char buffer[32];
	time(&now_time);
	info = localtime(&now_time);
	strftime(buffer, 32, "%Y-%m-%d %H:%M:%S", info);
	std::string str = buffer;

	usbcb.u32_CMD = setting3288dsp::SET_DATETIME;
	usbcb.u32_Count = str.length();

	ret = io_->write_bulk(&usbcb, &len);
	size = str.size();
	ret = io_->write_bulk(&str[0], &size);
	if (ret != SCANNER_ERR_OK)
	{
		VLOG_MINI_1(LOG_LEVEL_FATAL, "GET_DATETIME failed \n", 0);
		return SCANNER_ERR_ACCESS_DENIED;
	}

	USBCB usbcb2 = { setting3288dsp::GET_DATETIME,0,0 };
	len = sizeof(usbcb);
	ret = io_->write_bulk(&usbcb2, &len);
	if (ret == SCANNER_ERR_OK)
	{
		ret = io_->read_bulk(&usbcb2, &len);
		if (usbcb2.u32_Count == 512 || usbcb2.u32_Count == 0)
		{
			VLOG_MINI_1(LOG_LEVEL_FATAL, "GET_DATETIME  error data lenght\n", 0);
			return SCANNER_ERR_ACCESS_DENIED;
		}
		std::string datenow;
		datenow.resize(usbcb2.u32_Count);
		int size = datenow.size();
		io_->read_bulk(&datenow[0], &size);
		VLOG_MINI_1(LOG_LEVEL_FATAL, "After update board time : %s \n", datenow.c_str());
	}
	else
	{
		VLOG_MINI_1(LOG_LEVEL_FATAL, "GET_DATETIME  usb communication failed\n", 0);
		return SCANNER_ERR_ACCESS_DENIED;
	}

	return SCANNER_ERR_OK;
}

int hg_scanner_300::get_correction_image(int inx , int dpi, int mode)
{
	for (auto it : correction_image_map_)
	{
		if (it.second.info.params.colormode == mode && it.second.info.params.dpi == dpi)
		{
			return -1;//预防重复添加
		}
	}
	int ret = SCANNER_ERR_OK;
	setting3288dsp::FLAT_INFO_IMAGE image_info;
	
	image_info.info.params.dpi = dpi;
	image_info.info.params.colormode = mode;

	cv::Mat white_mat;
	cv::Mat black_mat;;
	for (size_t i = 0; i < 2; i++)  //黑白一起保存下来
	{
		vector<unsigned char> imagedata;

		image_info.info.params.is_whiteimage = i;
		int val = image_info.info.value;
		USBCB	cmd = { setting3288dsp::GET_FLAT_DATA,val,0, };
		{
			std::lock_guard<std::mutex>      lock(io_lock_);
			ret = writeusb(cmd);
			if (ret == SCANNER_ERR_OK)
				ret = readusb(cmd);

			if (ret)
				return ret;

			image_info.info.value = cmd.u32_Data;

			if (image_info.info.params.status != 100)
			{
				VLOG_MINI_1(LOG_LEVEL_WARNING, "get_correction_image status:%d\n", image_info.info.params.status);
				return SCANNER_ERR_NO_DATA;
			}
			int len = image_info.info.params.datalen;
			imagedata.resize(len);

		
			if (ret == SCANNER_ERR_OK)
				ret = io_->read_bulk(&imagedata[0], &len);
			if (imagedata.empty())
			{
				return SCANNER_ERR_NO_DATA;
			}
			cv::ImreadModes rmc =  cv::IMREAD_GRAYSCALE;;// image_info.info.params.colormode ? cv::IMREAD_COLOR : cv::IMREAD_GRAYSCALE;
			cv::Mat mat = cv::imdecode(imagedata, rmc);//color BGR 

			//if (mat.channels() == 3)
				//cv::cvtColor(mat, mat, CV_BGR2RGB);

			if (mat.empty())
			{
				VLOG_MINI_1(LOG_LEVEL_WARNING, "get_correction_image image is NULL:%d\n", image_info.info.params.status);
				return SCANNER_ERR_NO_DATA;  //只要有一张图没有 直接退了
			}
			float f = 0.0;

			get_devs_distortion_check_val(f, dpi, i);

			if (i)
			{
				image_info.vratio = f;
				white_mat = mat;
			}
				
			else
			{
				image_info.hratio = f;
				black_mat = mat;
			}
				
		}
	}
	//cv::imwrite("C://image//correction_image_white_mat" + to_string(inx) + ".bmp", white_mat);
	//cv::imwrite("C://image//correction_image_black_mat" + to_string(inx) + ".bmp", black_mat);

	ret = hg_imgproc::correction_image(ImagePrc_pHandle_, image_info.flat_lut, black_mat, white_mat);

	correction_image_map_[inx] = image_info;

	return ret;
}
std::string hg_scanner_300::get_firmware_version()
{
	char	buf[20] = { 0 };
	int 	ret	= SCANNER_ERR_OK,
			len = 10; //协议定义长度为10 100 200 =8
    USBCB	cmd = { setting3288dsp::GET_FW_VERSION,len,0,};
		
	{
		std::lock_guard<std::mutex>      lock(io_lock_);
		ret = writeusb(cmd);
		if(ret == SCANNER_ERR_OK)
			ret = io_->read_bulk(buf, &len);
	}
	string fw = buf;
	VLOG_MINI_1(LOG_LEVEL_WARNING, "get_firmware_version:%s\n", !fw.empty() ? fw.c_str() : "not find devs firmware_version");

	return buf;
}
 std::string hg_scanner_300::get_serial_num() 
 {
	string  SerialNum = "";
	int 	ret	= SCANNER_ERR_OK,
			len = 14; 
			SerialNum.resize(len);

	USBCB cmd = { setting3288dsp::GET_SERIAL,len,0,};
	{
		std::lock_guard<std::mutex>      lock(io_lock_);
		ret = writeusb(cmd);
		if(ret == SCANNER_ERR_OK)
			ret = io_->read_bulk(&SerialNum[0], &len);
	}

	VLOG_MINI_1(LOG_LEVEL_WARNING, "get_serial_num:%s\n", !SerialNum.empty() ? SerialNum.c_str() : "not find devs get_serial_num");
	return SerialNum;
 }
 std::string hg_scanner_300::get_ip(void)
 {
	 return "";
 }
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int hg_scanner_300::set_leaflet_scan(void)
{
	int ret 		= SCANNER_ERR_OK;
	test_1_paper_ = true;
	
	ret = start();
	return ret;
}

int hg_scanner_300::set_clear_roller_num(void)
{
	std::lock_guard<std::mutex>      lock(io_lock_);
	USBCB usbcb = { setting3288dsp::CLR_ROLLER_NUM,0,4 };
	return writeusb(usbcb);
}
int hg_scanner_300::set_clear_history_num(void)
{
	if (!firmware_sup_history_cnt)
	{
		return SCANNER_ERR_DEVICE_NOT_SUPPORT;
	}
	std::lock_guard<std::mutex>      lock(io_lock_);
	USBCB usbcb = { setting3288dsp::CLR_SCAN_NUM,0,4 };
	return writeusb(usbcb);
}
int hg_scanner_300::get_device_code(void)
{
	return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_300::get_sleep_time(int &data)
{
	int ret = SCANNER_ERR_OK,
		len = 0;

	USBCB usbcb = { setting3288dsp::GET_SLEEP_TIME, 0, 0 };
	{
		std::lock_guard<std::mutex>      lock(io_lock_);
		ret = writeusb(usbcb);
		if (ret != SCANNER_ERR_OK)
		{
			return ret;
		}
		len = sizeof(usbcb);
		ret = io_->read_bulk(&usbcb, &len);
	}
	if (ret == SCANNER_ERR_OK)
	{
		data = (SANE_Power)usbcb.u32_Data;
	}
	VLOG_MINI_1(LOG_LEVEL_WARNING, "get_sleep_time:%d\n", data);
	return ret;
}
int hg_scanner_300::set_sleep_time(int data)
{
	std::lock_guard<std::mutex>      lock(io_lock_);
	int ret = SCANNER_ERR_OK;
	if (data == -1)
		data = 0x7FFFFFFF;
	USBCB usbcb = { setting3288dsp::SET_SLEEP_TIME,data, 0};
	ret = writeusb(usbcb);
	return ret;
}

int hg_scanner_300::get_scanner_paperon(SANE_Bool& type)
{
	int ret 	= SCANNER_ERR_OK,
		len 	= 0;

	USBCB usbcb = { setting3288dsp::GET_PAPERFEEDER_STATUS, 0, 0};
	len = sizeof(USBCB);

	{
		std::lock_guard<std::mutex>      lock(io_lock_);
		ret = writeusb(usbcb);
		if (ret == SCANNER_ERR_OK)
		{
			ret = io_->read_bulk(&usbcb, &len);
			type = usbcb.u32_Data == 0 ? false : true;
		}
	}
	//if (usbcb.u32_Data == 0)
	//	ret = SCANNER_ERR_DEVICE_NO_PAPER;
	//else
	//	ret = SCANNER_ERR_OK;
	VLOG_MINI_1(LOG_LEVEL_WARNING, "get_scanner_paperon is(%s)\n", !type ? hg_scanner_err_description(SCANNER_ERR_DEVICE_NO_PAPER) : hg_scanner_err_description(SCANNER_ERR_OK));
	return ret;
}

int hg_scanner_300::get_scan_is_sleep(SANE_Bool& type)
{
	int ret = SCANNER_ERR_OK,
		len = 0;

	USBCB usbcb = { setting3288dsp::ACTIVE_SCANNER, 0, 0 };
	len = sizeof(USBCB);
	{
		std::lock_guard<std::mutex>      lock(io_lock_);

		ret = writeusb(usbcb);
		if (ret == SCANNER_ERR_OK)
		{
			ret = io_->read_bulk(&usbcb, &len);
		}
	}
	if (ret == SCANNER_ERR_OK)
	{
		if (usbcb.u32_Data == 0x10)
			type = true;
		//return SCANNER_ERR_OK;
		else if (usbcb.u32_Data == 0x100)
			type = false;
		//return SCANNER_ERR_DEVICE_SLEEPING;
	}
	VLOG_MINI_1(LOG_LEVEL_WARNING, "get_scan_is_sleep is(%s)\n", !type ? hg_scanner_err_description(SCANNER_ERR_DEVICE_SLEEPING) : hg_scanner_err_description(SCANNER_ERR_OK));
	return ret;
}
///此款设备无此功能
int hg_scanner_300::on_staple_check_changed(bool& check)
{
	return SCANNER_ERR_OK;
}
int hg_scanner_300::on_skew_check_changed(bool& check)
{
	return SCANNER_ERR_OK;
}
int hg_scanner_300::on_skew_check_level_changed(int& check)
{
	return SCANNER_ERR_OK;
}
int hg_scanner_300::on_set_feedmode(int feedmode)
{
	return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_300::on_pic_type(bool& pic)
{
	return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_300::on_pick_paper(bool autostrength)
{
	return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_300::on_pick_paper_threshold(double threshold)
{
	return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_300::on_is_auto_paper(bool isautopaper)
{
	return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_300::on_cis_get_image(bool isautopaper)
{
	is_cis_image = isautopaper;
	dsp_config.params_3288.isCorrect = isautopaper == true ? 0 : 1; 
	return writedown_device_configuration();
}
int hg_scanner_300::on_process_double_paper(bool type)
{
	if (!firmware_sup_double_check)
		return SCANNER_ERR_DEVICE_NOT_SUPPORT;

	dsp_config.params_3288.en_doublefeed_check = type;
	return SCANNER_ERR_OK;
}
int hg_scanner_300::on_detect_lens_dirty(bool &type)
{
	if (!firmware_sup_dirty_check)
		return SCANNER_ERR_DEVICE_NOT_SUPPORT;

	is_lens_dirty = type;
	dsp_config.params_3288.dirty_detect = type;
	return SCANNER_ERR_OK;
}
int hg_scanner_300::on_get_feedmode(int &feedmode)
{
	return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_300::get_device_log(string &log)
{
	if (firmware_sup_log_export_G300_)
	{
		std::string src_name = "/var/log/syslog";
		std::string save_path = hg_log::temporary_path() + PATH_SEPARATOR + "device.log";

		USBCB usbcb = { 0 };
		usbcb.u32_CMD = 0x301;
		usbcb.u32_Count = src_name.length();
		int len = src_name.length();
		int size = sizeof(usbcb);
		int ret = io_->write_bulk(&usbcb, &size);
		ret = io_->write_bulk(&src_name[0], &len);
		usbcb.u32_CMD = 0x300;
		ret = io_->write_bulk(&usbcb, &size);
		ret = io_->read_bulk(&usbcb, &size);
		ofstream out(save_path);
		usbcb.u32_CMD = 0x302;
		ret = io_->write_bulk(&usbcb, &size);
		int touch = 0;
		std::string buff;
		int unitsize = 512 * 1024;
		int bufsize = usbcb.u32_Count <= unitsize ? usbcb.u32_Count : unitsize;
		buff.resize(bufsize);
		while (touch < usbcb.u32_Count)
		{
			ret = io_->read_bulk(&buff[0], &bufsize);
			if (SCANNER_ERR_OK != ret)
				return ret;

			out.write(&buff[0], bufsize);
			touch += bufsize;
			bufsize = unitsize > usbcb.u32_Count - touch ? usbcb.u32_Count - touch : unitsize;
		}
		out.close();

		log = save_path;
	}
	else
	{
		int ret = SCANNER_ERR_OK,
			len = 0;
		string 	save_path = hg_log::temporary_path() + PATH_SEPARATOR + "device.log";
		string	str;
		string	str2;
		USBCB usbcb = { setting3288dsp::GET_LOG_FILES_INFO, 0, 0 };
		len = sizeof(USBCB);
		{
			std::lock_guard<std::mutex>      lock(io_lock_);

			ret = writeusb(usbcb);
			if (ret == SCANNER_ERR_OK)
			{
				ret = readusb(usbcb);
			}

			int block = usbcb.u32_Count,
				total = usbcb.u32_Count,
				index = 0;

			if (total == 0)
			{
				return SCANNER_ERR_NO_DATA;
			}
			str.resize(total);
			str2.resize(total);
			//ret = io_->read_bulk(&str[index], &block);//Reading too much data at once can cause error(TIME_OUT), it requires segmented reading. 2023-10-9
			while (total)
			{
				block = 1024 * 1024;
				if (total < block)
				{
					block = total;
				}
				ret = io_->read_bulk(&str[index], &block);
				if (ret != SCANNER_ERR_OK)
					return ret;

				index += block;
				total -= block;
			}
		}

		if (ret != SCANNER_ERR_OK)
			return ret;

		ofstream f;
		f.open(save_path, ios::out | ios::trunc);
		if (!f.is_open())
			return SCANNER_ERR_CREATE_FILE_FAILED;

		f << str << endl;
		f.close();
		log = save_path;
	}

	return SCANNER_ERR_OK;
}
int hg_scanner_300::set_devreboot(int data)
{
	USBCB usbcb = { setting3288dsp::REBOOT, data ,0 };
	return writeusb(usbcb);
}
int hg_scanner_300::set_devshtudown()
{
	return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_300::set_scan_islock(SANE_Bool type)
{
	return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_300::get_scan_islock(SANE_Bool& type)
{
	return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_300::set_scan_lock_check_val(string str)
{
	return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_300::set_firmware_upgrade(std::string str)
{
	std::lock_guard<std::mutex>      lock(io_lock_);

	std::ifstream filename;
	int ret = SCANNER_ERR_OK;
	int block = 1024 * 1024;
	char* sendbuf = new char[block];

	filename.open(str, std::ios_base::in | std::ios_base::binary);
	if (!filename.is_open())
	{
		return SCANNER_ERR_NO_DATA;
	}

	filename.seekg(0, std::ios::end);
	size_t total = filename.tellg();

	filename.seekg(0, std::ios::beg);

	USBCB pre = { setting3288dsp::PRE_UPGRADE,0,total };
	int len = sizeof(pre);
	ret = io_->write_bulk(&pre, &len);  //先告诉下面总字节数
	if (ret != SCANNER_ERR_OK)
	{
		VLOG_MINI_1(LOG_LEVEL_WARNING, "PRE_UPGRADE: %s\n", hg_scanner_err_name(ret));
		return ret;
	}
	USBCB update = { setting3288dsp::START_UPGRADE,0,total };
	len = sizeof(update);
	
	while (total > 0)
	{
		memset(sendbuf, 0, block);
		block = 1024 * 1024;
		if (total < block)
		{
			block = total;
		}
		io_->write_bulk(&update, &len);//数据分段写，每次都要先告诉下面？

		filename.read(sendbuf, block);
		
		//size_t pos = filename.tellg();

		io_->write_bulk(sendbuf,&block);

		ret = io_->read_bulk(&update, &len);
		if (ret != SCANNER_ERR_OK)
		{
			VLOG_MINI_1(LOG_LEVEL_WARNING, "START_UPGRADE: %s\n", hg_scanner_err_name(ret));
			return ret;
		}
		total -= block;
		this_thread::sleep_for(std::chrono::milliseconds(10));
	}
	if (sendbuf)
	{
		delete[]sendbuf;
	}
	USBCB updatefinished = { setting3288dsp::UPDATE_FINISHED,0,0 };
	len = sizeof(updatefinished);
	ret = io_->write_bulk(&updatefinished, &len);
	if (ret != SCANNER_ERR_OK)
	{
		VLOG_MINI_1(LOG_LEVEL_WARNING, "UPDATE_FINISHED: %s\n", hg_scanner_err_name(ret));
	}

	StopWatch sw;

	this_thread::sleep_for(std::chrono::milliseconds(2000));
	while (sw.elapsed_s() < 60)
	{
		this_thread::sleep_for(std::chrono::milliseconds(1000));
		io_->set_timeout(3000);

		USBCB result = { setting3288dsp::GET_UPDATE_RESULT,0,0 };
		len = sizeof(result);
		ret = io_->write_bulk(&result, &len);
		if (ret == SCANNER_ERR_OK)
			ret = io_->read_bulk(&result, &len);
		else
		{
			VLOG_MINI_1(LOG_LEVEL_WARNING, "Write  GET_UPDATE_RESULT failed: %d\n", ret);
		}

		if (ret != SCANNER_ERR_OK)
		{
			VLOG_MINI_1(LOG_LEVEL_WARNING, "updata result read_bulk:%s\n", hg_scanner_err_name(ret));
			//return ret;
		}
		if (result.u32_Data == 2 || result.u32_Data == 3)
		{
			VLOG_MINI_1(LOG_LEVEL_WARNING, "updata result:%d\n", result.u32_Data);
			break;
		}
		else if (result.u32_Data == 1)
		{
			VLOG_MINI_1(LOG_LEVEL_WARNING, "GET_UPDATE_RESULT---Failed : %d\n", result.u32_Data);
			return SCANNER_ERR_DEVICE_UPGRADE_FAIL;
		}
		else
		{
			VLOG_MINI_1(LOG_LEVEL_WARNING, "GET_UPDATE_RESULT---u32_Data:%d\n", result.u32_Data);
		}
	}
	return ret;
}
int hg_scanner_300::set_clean_paper_road()
{
	return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_300::get_dev_islock_file(int& data)
{
	return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_300::set_dev_islock_file(int data)
{
	return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_300::set_speed_mode(int data)
{
	int ret = SCANNER_ERR_OK,
		len = 0;

	USBCB usbcb = { setting3288dsp::SET_SPEED_MODE,data,0 };
	len = sizeof(usbcb);
	ret = io_->write_bulk(&usbcb, &len);
	return 0;
}
int hg_scanner_300::get_speed_mode(int& data)
{
	int ret = SCANNER_ERR_OK,
		len = 0;

	USBCB usbcb = { setting3288dsp::GET_SPEED_MODE,0,0 };
	len = sizeof(usbcb);
	ret = io_->write_bulk(&usbcb, &len);
	if (ret != SCANNER_ERR_OK)
	{
		return ret;
	}
	ret = io_->read_bulk(&usbcb, &len);
	if (ret == SCANNER_ERR_OK)
	{
		data = usbcb.u32_Data;
	}
	return ret;
}
int hg_scanner_300::set_devs_distortion_check_val(float data)
{
	int val = *(int*)&data; //float to int send
	int ret = SCANNER_ERR_OK,
		len = 0;

	int protocol_dpi = resolution_ == 200 ? 1 : (resolution_ == 300 ? 2 : 3);
	USBCB usbcb = { setting3288dsp::SET_JUST_COF_V ,val,protocol_dpi };
	len = sizeof(usbcb);
	float f = *(float*)&(val);
	VLOG_MINI_3(LOG_LEVEL_WARNING, "set_devs_distortion_check_val dpi is:%d,config dpi = %d,distortion_check_val(%f)\n", resolution_, protocol_dpi,f);
	io_->set_timeout(5000);
	{
		std::lock_guard<std::mutex>      lock(io_lock_);
		ret = io_->write_bulk(&usbcb, &len);
	}
	return ret;
}
int hg_scanner_300::get_devs_distortion_check_val(float& data)
{
	int ret = SCANNER_ERR_OK,
		len = 0,
		val = 0;

	int protocol_dpi = resolution_ == 200 ? 1 : (resolution_ == 300 ? 2 : 3);
	USBCB usbcb = { setting3288dsp::GET_JUST_COF_V ,0,protocol_dpi };
	len = sizeof(usbcb);
	{
		std::lock_guard<std::mutex>      lock(io_lock_);

		ret = io_->write_bulk(&usbcb, &len);
		if (ret != SCANNER_ERR_OK)
		{
			return ret;
		}

		io_->set_timeout(3000);
		ret = io_->read_bulk(&usbcb, &len);
	}
	if (ret != SCANNER_ERR_OK)
	{
		return ret;
	}

	val = usbcb.u32_Data;
	data = *(float *) &val;

	VLOG_MINI_3(LOG_LEVEL_WARNING, "get_distortion_check_val dpi is:%d,protocol_dpi = %d get_distortion_check_val(%f)\n", resolution_, protocol_dpi, data);
	return ret;
}
int hg_scanner_300::set_auto_flat(int data)
{
	if (data < 0 && data >6)
	{
		data = 0;
	}
	USBCB usbcb = { setting3288dsp::START_FLAT,data,0 };
	int len = sizeof(usbcb);
	int ret = SCANNER_ERR_OK;
	
	{
		std::lock_guard<std::mutex>      lock(io_lock_);
		ret = writeusb(usbcb);
	}
	 
	if (ret == SCANNER_ERR_OK && wait_usb_.is_waiting())
	{
		//status_ = SCANNER_ERR_DEVICE_BUSY;
		wait_usb_.notify();
		std::this_thread::sleep_for(std::chrono::milliseconds(300));
		ret = try_third_app_after_start(ret);
	}
	else
		status_ = ret;
	VLOG_MINI_1(LOG_LEVEL_WARNING, "set_auto_flat ret: %s\n", hg_scanner_err_name(ret));
	return ret;
}
int hg_scanner_300::set_updata0303(void)
{
	string fw = get_firmware_version();
	if (!fw.empty())
	{
		if (fw.substr(4, 6) == "230303")
		{
			string scanner_path = hg_log::get_module_full_path(MODULE_NAME_SCANNER);
			scanner_path = scanner_path.substr(0, scanner_path.size() - strlen(MODULE_NAME_SCANNER));
			scanner_path += "update.zip";
			set_firmware_upgrade(scanner_path);
		}
	}
	return 0;
}
int hg_scanner_300::get_devs_cpu(string& cpu)
{
	std::string src_name = "/usr/local/huago/sysinfo.json";
	std::string dst_name = "./sys.log";

	USBCB usbcb = { 0 };
	usbcb.u32_CMD = 0x301;
	usbcb.u32_Count = src_name.length();
	int len = src_name.length();
	int size = sizeof(usbcb);
	int ret = io_->write_bulk(&usbcb, &size);
	ret = io_->write_bulk(&src_name[0], &len);
	usbcb.u32_CMD = 0x300;
	ret = io_->write_bulk(&usbcb, &size);
	ret = io_->read_bulk(&usbcb, &size);
	ofstream out(dst_name);
	usbcb.u32_CMD = 0x302;
	ret = io_->write_bulk(&usbcb, &size);
	int touch = 0;
	std::string buff;
	int bufsize = usbcb.u32_Count < 512 * 1024 ? usbcb.u32_Count : 512 * 1024;
	buff.resize(bufsize);
	while (touch < usbcb.u32_Count) 
	{
		ret = io_->read_bulk(&buff[0], &bufsize);
		if (SCANNER_ERR_OK != ret)
			return ret;

		out.write(&buff[0], bufsize);
		touch += bufsize;
		bufsize = bufsize > usbcb.u32_Count - touch ? usbcb.u32_Count - touch : bufsize;
	}
	out.close();

	long long cpu_size = 0;
	json js = json::parse(buff);
	if (js.contains("MemTotal"))
	{
		cpu_size = js["MemTotal"];
	}

	float num = (float)cpu_size / 1024 / 1024 / 1024;
	char buf[10] = { 0 };
	sprintf(buf, "%.2f", num);
	strcat(buf, "GB");
	cpu = buf;

	return ret;
}
int hg_scanner_300::get_devs_disk(string& disk)
{
	std::string src_name = "/usr/local/huago/sysinfo.json";
	std::string dst_name = "./sys.log";

	USBCB usbcb = { 0 };
	usbcb.u32_CMD = 0x301;
	usbcb.u32_Count = src_name.length();
	int len = src_name.length();
	int size = sizeof(usbcb);
	int ret = io_->write_bulk(&usbcb, &size);
	ret = io_->write_bulk(&src_name[0], &len);
	usbcb.u32_CMD = 0x300;
	ret = io_->write_bulk(&usbcb, &size);
	ret = io_->read_bulk(&usbcb, &size);
	ofstream out(dst_name);
	usbcb.u32_CMD = 0x302;
	ret = io_->write_bulk(&usbcb, &size);
	int touch = 0;
	std::string buff;
	int bufsize = usbcb.u32_Count < 512 * 1024 ? usbcb.u32_Count : 512 * 1024;
	buff.resize(bufsize);
	while (touch < usbcb.u32_Count)
	{
		ret = io_->read_bulk(&buff[0], &bufsize);
		if (SCANNER_ERR_OK != ret)
			return ret;

		out.write(&buff[0], bufsize);
		touch += bufsize;
		bufsize = bufsize > usbcb.u32_Count - touch ? usbcb.u32_Count - touch : bufsize;
	}
	out.close();

	long disk_size = 0;
	json js = json::parse(buff);
	if (js.contains("DiskTotal"))
	{
		disk_size = js["DiskTotal"];
	}

	float num = (float)disk_size / 1024 / 1024;
	char buf[10] = { 0 };
	sprintf(buf, "%.2f", num);
	strcat(buf, "GB");
	disk = buf;

	return ret;
}
int hg_scanner_300::set_restore()
{
	if (!firmware_sup_backup_restore)
		return SCANNER_ERR_DEVICE_NOT_SUPPORT;

	USBCB usbcb = { 0,0,0 };
	//usbcb.u32_CMD = setting3288dsp::SET_BACKUP_CONFIG;
	int len = sizeof(usbcb);
	usbcb.u32_CMD = setting3288dsp::SET_RECOVERY;
	int ret = io_->write_bulk(&usbcb, &len);

	usbcb.u32_CMD = setting3288dsp::GET_RECOVERY_STATUS;
	StopWatch sw;
	while (sw.elapsed_ms()< 8000.0)
	{
		len = sizeof(USBCB);
		ret = io_->write_bulk(&usbcb, &len);
		len = sizeof(USBCB);
		ret = io_->read_bulk(&usbcb, &len);
		if (usbcb.u32_Data == 2)
			break;
		std::this_thread::sleep_for(std::chrono::milliseconds(5));
	}

	std::string log_info = usbcb.u32_Data == 2 ? "RECOVERY  success " : " RECOVERY failed " + std::to_string(usbcb.u32_Data);
	VLOG_MINI_1(LOG_LEVEL_FATAL, log_info.c_str(), 0);
	return usbcb.u32_Data == 2? SCANNER_ERR_OK: SCANNER_ERR_ACCESS_DENIED;
}

int hg_scanner_300::set_backup()
{
	if (!firmware_sup_backup_restore)
		return SCANNER_ERR_DEVICE_NOT_SUPPORT;

	USBCB usbcb = { 0,0,0 };
	int len = sizeof(usbcb);
	usbcb.u32_CMD = setting3288dsp::SET_BACKUP_CONFIG;
	int ret = io_->write_bulk(&usbcb, &len);

	usbcb.u32_CMD = setting3288dsp::GET_BACKUP_STATUS;
	StopWatch sw;
	while (sw.elapsed_ms() < 5000.0)
	{
		ret = io_->write_bulk(&usbcb, &len);
		ret = io_->read_bulk(&usbcb, &len);
		if (usbcb.u32_Data == 2)
			break;
		std::this_thread::sleep_for(std::chrono::milliseconds(5));
	}

	std::string log_info = usbcb.u32_Data == 2 ? "Back up success " : " Backup failed "+ std::to_string(usbcb.u32_Data);
	VLOG_MINI_1(LOG_LEVEL_FATAL, log_info.c_str(),0);
	return usbcb.u32_Data == 2 ? SCANNER_ERR_OK : SCANNER_ERR_INVALID_PARAMETER;
}

int hg_scanner_300::set_serial_num(string str)
{
	std::lock_guard<std::mutex>      lock(io_lock_);

	USBCB usbcb = { setting3288dsp::SEND_SERIAL,0,14 };
	int len = sizeof(usbcb),
		ret = SCANNER_ERR_OK;
	ret = io_->write_bulk(&usbcb, &len);
	if (ret == SCANNER_ERR_OK)
	{
		len = str.size();

		ret = io_->write_bulk(&str, &len);
	}
	return ret;
}
int hg_scanner_300::set_vid_pid(int data)
{
	std::lock_guard<std::mutex>      lock(io_lock_);
	USBCB usbcb = { setting3288dsp::SET_USB_INFOR_VIDPID,data,0 };
	int len = sizeof(usbcb);
	return io_->write_bulk(&usbcb, &len);
}
int hg_scanner_300::get_vid_pid(int& data)
{
	std::lock_guard<std::mutex>      lock(io_lock_);
	USBCB usbcb = { setting3288dsp::GET_USB_INFOR_VIDPID,0,0 };
	int ret = SCANNER_ERR_OK,
		len = sizeof(usbcb);
	io_->write_bulk(&usbcb, &len);
	io_->read_bulk(&usbcb, &len);
	if (ret == SCANNER_ERR_OK)
	{
		data = usbcb.u32_Data;
	}
	return ret;
}
int hg_scanner_300::set_notify_sleep()
{
	return SCANNER_ERR_DEVICE_NOT_SUPPORT;
}
int hg_scanner_300::get_history_scan_count(int& num)
{
	int ret = SCANNER_ERR_OK,
		len = 0;
	USBCB usbcb = { setting3288dsp::GET_SCANN_NUM,0, 0 };
	len = sizeof(usbcb);
	{
		std::lock_guard<std::mutex>      lock(io_lock_);

		ret = io_->write_bulk(&usbcb, &len);
		if (ret != SCANNER_ERR_OK)
		{
			return ret;
		}
		ret = io_->read_bulk(&usbcb, &len);
	}
	if (ret != SCANNER_ERR_OK)
	{
		return ret;
	}
	num = usbcb.u32_Data;
	return ret;
}
int hg_scanner_300::get_roller_num(int& val)
{
	int ret = SCANNER_ERR_OK,
		len = 0;
	USBCB usbcb = { setting3288dsp::GET_ROLLER_NUM,0, 0 };
	len = sizeof(usbcb);
	{
		std::lock_guard<std::mutex>      lock(io_lock_);

		ret = io_->write_bulk(&usbcb, &len);
		if (ret != SCANNER_ERR_OK)
		{
			return ret;
		}
		ret = io_->read_bulk(&usbcb, &len);
	}
	if (ret != SCANNER_ERR_OK)
	{
		return ret;
	}
	val = usbcb.u32_Data;
	return ret;
}