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

调整sane_start/sane_stop流程，start等到一张图后返回第一张图状态或者结束状态；stop等到工作线程退出后才返回

This commit is contained in:
gb 2023-10-28 14:47:15 +08:00
parent 3af53b5dae
commit 927b0199d3
12 changed files with 182 additions and 58 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

137
hgdriver/hgdev/hg_scanner.cpp
View File

@ -3459,9 +3459,22 @@ int hg_scanner::try_third_app_handle_start(bool& handled)
{ {
int ret = SCANNER_ERR_OK; int ret = SCANNER_ERR_OK;
handled = false;
return ret;
handled = !async_io_; handled = !async_io_;
if (handled) if (handled)
{ {
if (user_cancel_)
{
if (status_ != SCANNER_ERR_OK && status_ != SCANNER_ERR_USER_CANCELED) // call stop after exception occurs, start a new scanning ...
{
handled = false;
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "call start after user cancelled while status is %s, we start a new scanning\n", hg_scanner_err_description(status_));
return ret;
}
}
while (wait_usb_result_.try_wait()) while (wait_usb_result_.try_wait())
std::this_thread::sleep_for(std::chrono::milliseconds(3)); std::this_thread::sleep_for(std::chrono::milliseconds(3));
@ -3505,13 +3518,14 @@ int hg_scanner::try_third_app_handle_start(bool& handled)
} }
int hg_scanner::try_third_app_after_start(int err) int hg_scanner::try_third_app_after_start(int err)
{ {
if (!async_io_) //if (!async_io_)
{ //{
while (wait_img_.is_waiting() && !wait_usb_.is_waiting()) // while (wait_img_.is_waiting() && !wait_usb_.is_waiting())
std::this_thread::sleep_for(std::chrono::milliseconds(10)); // std::this_thread::sleep_for(std::chrono::milliseconds(10));
if (wait_img_.is_waiting() && wait_usb_.is_waiting()) // if (wait_img_.is_waiting() && wait_usb_.is_waiting())
err = status_; // err = status_;
} //
//}
return err; return err;
} }
@ -3609,7 +3623,7 @@ int hg_scanner::save_usb_data(std::shared_ptr<tiny_buffer> data)
unsigned int bytes = data->size(); unsigned int bytes = data->size();
usb_img_index_++; usb_img_index_++;
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "USB read one picture with %u bytes\n", data->size()); VLOG_MINI_3(LOG_LEVEL_DEBUG_INFO, "USB packet(%04d) of picture with %u bytes(status: %d)\n", usb_img_index_, data->size(), data->get_image_statu());
if (dump_usb_path_.length()) //这两台设备不是jpg的图 所以不能直接处理 if (dump_usb_path_.length()) //这两台设备不是jpg的图 所以不能直接处理
{ {
char name[80] = { 0 }; char name[80] = { 0 };
@ -4081,11 +4095,98 @@ void hg_scanner::on_language_changed(void)
} }
} }
} }
int hg_scanner::wait_one_image_from_start(bool& handled)
{
int ret = SCANNER_ERR_OK;
handled = false;
if (!async_io_) // non-callback
{
while (is_running() != THREAD_RUNNING_IDLE)
{
handled = true;
if (final_imgs_.size())
{
break;
}
}
if (final_imgs_.size())
{
IMH head = { 0 };
handled = true;
if (final_imgs_.front(&head))
{
if (head.statu & IMG_STATUS_DOUBLE)
ret = SCANNER_ERR_DEVICE_DOUBLE_FEEDING;
else if (head.statu & IMG_STATUS_JAM)
ret = SCANNER_ERR_DEVICE_PAPER_JAMMED;
else if (head.statu & IMG_STATUS_STAPLE)
ret = SCANNER_ERR_DEVICE_STAPLE_ON;
else if (head.statu & IMG_STATUS_SIZE_ERR)
ret = SCANNER_ERR_DEVICE_SIZE_CHECK;
else if (head.statu & IMG_STATUS_DOGEAR)
ret = SCANNER_ERR_DEVICE_DOGEAR;
}
}
else if (handled) // overed normal or exception
{
if (status_ == SCANNER_ERR_OK
|| status_ == SCANNER_ERR_DEVICE_DOUBLE_FEEDING) // 双张特殊处理，视为成功
{
SANE_Bool has_paper = SANE_FALSE;
get_scanner_paperon(has_paper);
if (has_paper == SANE_TRUE)
handled = false;
else
ret = SCANNER_ERR_DEVICE_NO_PAPER;
}
else
ret = status_;
}
}
return ret;
}
int hg_scanner::start(void) int hg_scanner::start(void)
{ {
user_cancel_ = false; int ret = SCANNER_ERR_OK;
bool handled = false;
return status_; if (user_cancel_)
{
user_cancel_ = false; // stopped by user, reset flag and starting a new scanning ...
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "start after user stopped just now while with %d image(s) in queue, a new scanning will to be started ...\n", final_imgs_.size());
}
else
{
ret = wait_one_image_from_start(handled);
if (handled)
{
VLOG_MINI_2(LOG_LEVEL_DEBUG_INFO, "start in previous scanning and result is %s, image count %d\n", hg_scanner_err_description(ret), final_imgs_.size());
return ret;
}
}
// clear ...
imgs_.Clear();
final_imgs_.clear();
usb_img_index_ = final_img_index_ = 0;
status_ = SCANNER_ERR_OK;
// start ...
ret = do_start();
if (ret == SCANNER_ERR_OK)
{
// wait ONE picture or stopped
ret = wait_one_image_from_start(handled);
}
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "start scanning result = %s\n", hg_scanner_err_description(ret));
return ret;
} }
int hg_scanner::get_image_info(SANE_Parameters* ii, int len) int hg_scanner::get_image_info(SANE_Parameters* ii, int len)
{ {
@ -4197,9 +4298,21 @@ int hg_scanner::read_image_data(unsigned char* buf, int* len)
} }
int hg_scanner::stop(void) int hg_scanner::stop(void)
{ {
user_cancel_ = true; int ret = SCANNER_ERR_OK;
return status_; user_cancel_ = true;
ret = do_stop();
// wait until really stopped ...
if (ret == SCANNER_ERR_OK)
{
while (is_running() != THREAD_RUNNING_IDLE)
std::this_thread::sleep_for(std::chrono::milliseconds(3));
ret = status_;
}
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "user stopped result = %s\n", hg_scanner_err_description(ret));
return ret;
} }
int hg_scanner::reset(void) int hg_scanner::reset(void)
{ {

8
hgdriver/hgdev/hg_scanner.h
View File

@ -439,6 +439,7 @@ protected:
int save_final_image(hg_imgproc::LPIMGHEAD head, void* buf, uint32_t id = -1); int save_final_image(hg_imgproc::LPIMGHEAD head, void* buf, uint32_t id = -1);
void adjust_filling_hole(LPSCANCONF conf); void adjust_filling_hole(LPSCANCONF conf);
int wait_one_image_from_start(bool& handled);
//////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////
// 新增自定义伽玛曲线及扫描区域属性 - 2022-05-05 // 新增自定义伽玛曲线及扫描区域属性 - 2022-05-05
@ -461,6 +462,9 @@ protected:
bool is_white_0_; // 是否‘0’代表白色 bool is_white_0_; // 是否‘0’代表白色
public: public:
int start(void);
int stop(void);
void set_ui_callback(sane_callback cb, bool enable_async_io); void set_ui_callback(sane_callback cb, bool enable_async_io);
void set_dev_family(const char* family); void set_dev_family(const char* family);
void set_read_over_with_no_data(bool no_data); void set_read_over_with_no_data(bool no_data);
@ -487,10 +491,10 @@ public:
int is_running(void); // return thread_running int is_running(void); // return thread_running
public: public:
virtual int start(void); virtual int do_start(void) = 0;
virtual int do_stop(void) = 0;
virtual int get_image_info(SANE_Parameters* ii, int len); virtual int get_image_info(SANE_Parameters* ii, int len);
virtual int read_image_data(unsigned char* buf, int* len); virtual int read_image_data(unsigned char* buf, int* len);
virtual int stop(void);
virtual int reset(void); virtual int reset(void);
virtual int device_io_control(unsigned long code, void* data, unsigned* len); virtual int device_io_control(unsigned long code, void* data, unsigned* len);
virtual int discard_all_images(void) = 0; virtual int discard_all_images(void) = 0;

7
hgdriver/hgdev/hg_scanner_200.cpp
View File

@ -265,7 +265,7 @@ void hg_scanner_200::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_description(status_)); 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_200::start(void) int hg_scanner_200::do_start(void)
{ {
bool handled = false; bool handled = false;
int ret = try_third_app_handle_start(handled), int ret = try_third_app_handle_start(handled),
@ -318,7 +318,7 @@ int hg_scanner_200::start(void)
return ret; return ret;
} }
int hg_scanner_200::stop(void) int hg_scanner_200::do_stop(void)
{ {
int ret = SCANNER_ERR_OK; int ret = SCANNER_ERR_OK;
@ -337,7 +337,8 @@ int hg_scanner_200::stop(void)
{ {
status_ = SCANNER_ERR_DEVICE_STOPPED; status_ = SCANNER_ERR_DEVICE_STOPPED;
} }
return status_;
return ret;
} }
int hg_scanner_200::writeusb(USBCB &usb) int hg_scanner_200::writeusb(USBCB &usb)
{ {

4
hgdriver/hgdev/hg_scanner_200.h
View File

@ -50,8 +50,8 @@ public:
~hg_scanner_200(); ~hg_scanner_200();
public: public:
virtual int start(void)override; virtual int do_start(void) override;
virtual int stop(void)override; virtual int do_stop(void) override;
private: private:
int initdevice(); int initdevice();

39
hgdriver/hgdev/hg_scanner_239.cpp
View File

@ -1337,6 +1337,7 @@ void hg_scanner_239::thread_get_dves_image(void)
{ {
std::lock_guard<std::mutex> lock(io_lock_); std::lock_guard<std::mutex> lock(io_lock_);
memset(buf, 0, size);
ret = io_->read_interrupt(buf, &size); ret = io_->read_interrupt(buf, &size);
io_->set_timeout(1000); io_->set_timeout(1000);
} }
@ -1354,7 +1355,7 @@ void hg_scanner_239::thread_get_dves_image(void)
if (is_auto_paper_scan && sw.elapsed_s() >= is_auto_paper_scan_exit_time && is_auto_paper_scan_exit_time != 0) if (is_auto_paper_scan && sw.elapsed_s() >= is_auto_paper_scan_exit_time && is_auto_paper_scan_exit_time != 0)
{ {
stop(); do_stop();
notify_ui_working_status(from_default_language(STATU_DESC_SCANNER_ERR_DEVICE_EXIT_WAIT_SCAN), SANE_EVENT_ERROR, status_); notify_ui_working_status(from_default_language(STATU_DESC_SCANNER_ERR_DEVICE_EXIT_WAIT_SCAN), SANE_EVENT_ERROR, status_);
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "auto paper scan exit :%s\n", from_default_language(STATU_DESC_SCANNER_ERR_DEVICE_EXIT_WAIT_SCAN)); VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "auto paper scan exit :%s\n", from_default_language(STATU_DESC_SCANNER_ERR_DEVICE_EXIT_WAIT_SCAN));
} }
@ -1397,7 +1398,7 @@ void hg_scanner_239::thread_get_dves_image(void)
&& status_ != SCANNER_ERR_DEVICE_AUTO_FAIL_INFO && status_ != SCANNER_ERR_DEVICE_AUTO_FAIL_INFO
) )
{ {
if (info->From != setting3399::IMG && status_ != SCANNER_ERR_DEVICE_DOUBLE_FEEDING) if (info->From != setting3399::IMG /*&& status_ != SCANNER_ERR_DEVICE_DOUBLE_FEEDING*/)
svdevs_err_.push_back(status_); svdevs_err_.push_back(status_);
} }
@ -1413,13 +1414,13 @@ void hg_scanner_239::thread_get_dves_image(void)
while (get_image_count() > 0) while (get_image_count() > 0)
{ {
ret = read_one_image_from_usb((status_ == SCANNER_ERR_DEVICE_DOUBLE_FEEDING && dev_conf_.params_3399.double_out_en) ? IMG_STATUS_DOUBLE : IMG_STATUS_OK); ret = read_one_image_from_usb((status_ == SCANNER_ERR_DEVICE_DOUBLE_FEEDING /*&& dev_conf_.params_3399.double_out_en*/) ? IMG_STATUS_DOUBLE : IMG_STATUS_OK);
//if (status_ == SCANNER_ERR_DEVICE_DOUBLE_FEEDING) //if (status_ == SCANNER_ERR_DEVICE_DOUBLE_FEEDING)
// svdevs_err_.push_back(IMG_STATUS_DOUBLE); // svdevs_err_.push_back(IMG_STATUS_DOUBLE);
count++; count++;
if (ret != SCANNER_ERR_OK //if (ret != SCANNER_ERR_OK
&& ret != SCANNER_ERR_CREATE_FILE_FAILED // && ret != SCANNER_ERR_CREATE_FILE_FAILED
&& ret != SCANNER_ERR_WRITE_FILE_FAILED) // && ret != SCANNER_ERR_WRITE_FILE_FAILED)
break; break;
} }
} }
@ -1441,15 +1442,22 @@ void hg_scanner_239::thread_get_dves_image(void)
else else
std::this_thread::sleep_for(std::chrono::milliseconds(2000)); std::this_thread::sleep_for(std::chrono::milliseconds(2000));
int rest = 0;
while (get_image_count() > 0) while (get_image_count() > 0)
{ {
ret = read_one_image_from_usb(); ret = read_one_image_from_usb();
count++; rest++;
if (ret != SCANNER_ERR_OK if (ret != SCANNER_ERR_OK
&& ret != SCANNER_ERR_CREATE_FILE_FAILED && ret != SCANNER_ERR_CREATE_FILE_FAILED
&& ret != SCANNER_ERR_WRITE_FILE_FAILED) && ret != SCANNER_ERR_WRITE_FILE_FAILED)
break; break;
} }
count += rest;
if (rest)
{
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "STOPSCAN message is ahead of %d image(s)!\n", rest);
}
if (user_cancel_ && !is_auto_paper_scan) if (user_cancel_ && !is_auto_paper_scan)
{ {
if (status_ && status_ != SCANNER_ERR_DEVICE_STOPPED) // thread_handle_image_process maybe call stop() when insufficient memory occurs . if (status_ && status_ != SCANNER_ERR_DEVICE_STOPPED) // thread_handle_image_process maybe call stop() when insufficient memory occurs .
@ -1492,7 +1500,7 @@ void hg_scanner_239::thread_get_dves_image(void)
else if (info->From == setting3399::V4L2) else if (info->From == setting3399::V4L2)
{ {
VLOG_MINI_2(LOG_LEVEL_WARNING, "V4L2 message received, code = %d, index = %d\n", info->Code, info->Img_Index); VLOG_MINI_2(LOG_LEVEL_WARNING, "V4L2 message received, code = %d, index = %d\n", info->Code, info->Img_Index);
// stop(); // do_stop();
break; break;
} }
else if (info->From == setting3399::AutoCorrect) else if (info->From == setting3399::AutoCorrect)
@ -1526,7 +1534,7 @@ void hg_scanner_239::thread_handle_usb_read(void)
thread_get_dves_image(); thread_get_dves_image();
} }
int hg_scanner_239::start(void) int hg_scanner_239::do_start(void)
{ {
bool handled = false; bool handled = false;
int ret = try_third_app_handle_start(handled), int ret = try_third_app_handle_start(handled),
@ -1536,8 +1544,6 @@ int hg_scanner_239::start(void)
return ret; return ret;
user_cancel_ = false;
split3399_ = 0; split3399_ = 0;
cb_mem_ = true; cb_mem_ = true;
@ -1614,15 +1620,14 @@ int hg_scanner_239::start(void)
return ret; return ret;
} }
int hg_scanner_239::stop(void) int hg_scanner_239::do_stop(void)
{ {
int ret = SCANNER_ERR_OK; int ret = SCANNER_ERR_OK;
user_cancel_ = true;
ret = write_command(setting3399::SC_STOP); ret = write_command(setting3399::SC_STOP);
io_->set_timeout(500); io_->set_timeout(500);
return status_;
return ret;
} }
int hg_scanner_239::reset(void) int hg_scanner_239::reset(void)
{ {
@ -1824,9 +1829,9 @@ int hg_scanner_239::get_scanner_paperon(SANE_Bool& type)
int ret = read_register(setting3399::SR_GET_PAPERON, &val); //0无纸 1有纸 int ret = read_register(setting3399::SR_GET_PAPERON, &val); //0无纸 1有纸
if (ret == SCANNER_ERR_OK) if (ret == SCANNER_ERR_OK)
{ {
type = val == 0 ? false : true; type = val == 0 ? SANE_FALSE : SANE_TRUE;
} }
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)); VLOG_MINI_1(LOG_LEVEL_WARNING, "get_scanner_paperon is(%s)\n", val == 0 ? hg_scanner_err_description(SCANNER_ERR_DEVICE_NO_PAPER) : "paper on");
return ret; return ret;
} }

4
hgdriver/hgdev/hg_scanner_239.h
View File

@ -86,8 +86,8 @@ public:
public: public:
//virtual int get_image_info(IMG_PARAM* ii) override; //virtual int get_image_info(IMG_PARAM* ii) override;
//virtual int read_image_data(unsigned char* buf, int* len) override; //virtual int read_image_data(unsigned char* buf, int* len) override;
virtual int start(void) override; virtual int do_start(void) override;
virtual int stop(void) override; virtual int do_stop(void) override;
virtual int reset(void) override; virtual int reset(void) override;
virtual int device_io_control(unsigned long code, void* data, unsigned* len) override; virtual int device_io_control(unsigned long code, void* data, unsigned* len) override;
virtual int get_roller_life(void) override; virtual int get_roller_life(void) override;

8
hgdriver/hgdev/hg_scanner_300.cpp
View File

@ -334,7 +334,7 @@ int hg_scanner_300::get_roller_life(void)
{ {
return pid_ == 300 ? 150000 : 200000; return pid_ == 300 ? 150000 : 200000;
} }
int hg_scanner_300::start(void) int hg_scanner_300::do_start(void)
{ {
bool handled = false; bool handled = false;
int ret = try_third_app_handle_start(handled), //sane调用是每次都会调用一次start和stop int ret = try_third_app_handle_start(handled), //sane调用是每次都会调用一次start和stop
@ -408,7 +408,7 @@ int hg_scanner_300::start(void)
VLOG_MINI_1(LOG_LEVEL_WARNING, "----------Main start scan status : %s----------\n", hg_scanner_err_description(ret)); VLOG_MINI_1(LOG_LEVEL_WARNING, "----------Main start scan status : %s----------\n", hg_scanner_err_description(ret));
return ret; return ret;
} }
int hg_scanner_300::stop(void) int hg_scanner_300::do_stop(void)
{ {
int ret = SCANNER_ERR_OK; int ret = SCANNER_ERR_OK;
@ -431,7 +431,7 @@ int hg_scanner_300::stop(void)
} }
//final_imgs_.clear(); //final_imgs_.clear();
return status_; return ret;
} }
int hg_scanner_300::writeusb(USBCB &usb) int hg_scanner_300::writeusb(USBCB &usb)
{ {
@ -554,7 +554,7 @@ int hg_scanner_300::get_img_data(std::shared_ptr<tiny_buffer>& imagedata)
else else
{ {
VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "Read image data from USB err: %s\n", hg_scanner_err_name(ret)); VLOG_MINI_1(LOG_LEVEL_DEBUG_INFO, "Read image data from USB err: %s\n", hg_scanner_err_name(ret));
stop(); do_stop();
string str = STATU_DESC_SCANNER_ERR_DEVICE_GET_IMAGE_ERR; string str = STATU_DESC_SCANNER_ERR_DEVICE_GET_IMAGE_ERR;
str = str + '-' + STATU_DESC_SCANNER_ERR_DEVICE_STOPPED; str = str + '-' + STATU_DESC_SCANNER_ERR_DEVICE_STOPPED;
notify_ui_working_status(str.c_str(), SANE_EVENT_ERROR, ret); notify_ui_working_status(str.c_str(), SANE_EVENT_ERROR, ret);

5
hgdriver/hgdev/hg_scanner_300.h
View File

@ -51,8 +51,9 @@ public:
hg_scanner_300(const char* dev_name,int pid, usb_io* io); hg_scanner_300(const char* dev_name,int pid, usb_io* io);
~hg_scanner_300(); ~hg_scanner_300();
public: public:
virtual int start(void)override; virtual int do_start(void) override;
virtual int stop(void)override; virtual int do_stop(void) override;
private: private:
int set_kernelsnap_ver(); int set_kernelsnap_ver();
int agreement(TwSS tw,int align); int agreement(TwSS tw,int align);

8
hgdriver/hgdev/hg_scanner_302.cpp
View File

@ -1020,7 +1020,7 @@ void hg_scanner_302::thread_handle_usb_read(void)
VLOG_MINI_1(LOG_LEVEL_FATAL, "V4L2 error: %d\n", info->Code); VLOG_MINI_1(LOG_LEVEL_FATAL, "V4L2 error: %d\n", info->Code);
{ {
bool cancel = user_cancel_; bool cancel = user_cancel_;
stop(); do_stop();
user_cancel_ = cancel; user_cancel_ = cancel;
go = false; go = false;
} }
@ -1052,7 +1052,7 @@ void hg_scanner_302::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_)); 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_));
} }
int hg_scanner_302::start(void) int hg_scanner_302::do_start(void)
{ {
bool handled = false; bool handled = false;
@ -1129,7 +1129,7 @@ int hg_scanner_302::start(void)
return ret; return ret;
} }
int hg_scanner_302::stop(void) int hg_scanner_302::do_stop(void)
{ {
std::lock_guard<std::mutex> lock(io_lock_); std::lock_guard<std::mutex> lock(io_lock_);
int ret = SCANNER_ERR_OK; int ret = SCANNER_ERR_OK;
@ -1139,7 +1139,7 @@ int hg_scanner_302::stop(void)
// io_->set_timeout(500); // io_->set_timeout(500);
//final_imgs_.clear(); //final_imgs_.clear();
return status_; return ret;
} }
int hg_scanner_302::reset(void) int hg_scanner_302::reset(void)
{ {

7
hgdriver/hgdev/hg_scanner_302.h
View File

@ -83,10 +83,9 @@ public:
~hg_scanner_302(); ~hg_scanner_302();
public: public:
virtual int start(void) override; virtual int do_start(void) override;
//virtual int get_image_info(IMG_PARAM* ii) override; virtual int do_stop(void) override;
//virtual int read_image_data(unsigned char* buf, int* len) override;
virtual int stop(void) override;
virtual int reset(void) override; virtual int reset(void) override;
virtual int device_io_control(unsigned long code, void* data, unsigned* len) override; virtual int device_io_control(unsigned long code, void* data, unsigned* len) override;

6
hgdriver/hgdev/hg_scanner_306.cpp
View File

@ -294,7 +294,7 @@ int hg_scanner_306::get_roller_life(void)
{ {
return pid_ == 300 ? 150000 : 200000; return pid_ == 300 ? 150000 : 200000;
} }
int hg_scanner_306::start(void) int hg_scanner_306::do_start(void)
{ {
bool handled = false; bool handled = false;
int ret = try_third_app_handle_start(handled), //sane调用是每次都会调用一次start和stop int ret = try_third_app_handle_start(handled), //sane调用是每次都会调用一次start和stop
@ -368,7 +368,7 @@ int hg_scanner_306::start(void)
VLOG_MINI_1(LOG_LEVEL_WARNING, "----------Main start scan status : %s----------\n", hg_scanner_err_description(ret)); VLOG_MINI_1(LOG_LEVEL_WARNING, "----------Main start scan status : %s----------\n", hg_scanner_err_description(ret));
return ret; return ret;
} }
int hg_scanner_306::stop(void) int hg_scanner_306::do_stop(void)
{ {
int ret = SCANNER_ERR_OK; int ret = SCANNER_ERR_OK;
@ -391,7 +391,7 @@ int hg_scanner_306::stop(void)
} }
//final_imgs_.clear(); //final_imgs_.clear();
return status_; return ret;
} }
int hg_scanner_306::writeusb(USBCB &usb) int hg_scanner_306::writeusb(USBCB &usb)
{ {

5
hgdriver/hgdev/hg_scanner_306.h
View File

@ -52,8 +52,9 @@ public:
hg_scanner_306(const char* dev_name,int pid, usb_io* io); hg_scanner_306(const char* dev_name,int pid, usb_io* io);
~hg_scanner_306(); ~hg_scanner_306();
public: public:
virtual int start(void)override; virtual int do_start(void) override;
virtual int stop(void)override; virtual int do_stop(void) override;
private: private:
int set_kernelsnap_ver(); int set_kernelsnap_ver();
int agreement(TwSS tw,int align); int agreement(TwSS tw,int align);