2075 lines
51 KiB
C++
2075 lines
51 KiB
C++
#include "Manager.h"
|
|
#include "MsgLoop.h"
|
|
#include "../../base/HGBuffer.h"
|
|
#include "../../base/HGBase64.h"
|
|
#include "../../base/HGUtility.h"
|
|
#include "../../base/HGInfo.h"
|
|
#include "../../imgfmt/HGJpeg.h"
|
|
#include "../../imgfmt/HGOfd.h"
|
|
#include "../../imgfmt/HGPdf.h"
|
|
#include "../../imgfmt/HGTiff.h"
|
|
#include "../../imgfmt/HGImgFmt.h"
|
|
#include "../../utility/HGString.h"
|
|
extern "C"
|
|
{
|
|
#include "zip.h"
|
|
};
|
|
#include <curl/curl.h>
|
|
#include <list>
|
|
#include <algorithm>
|
|
|
|
DevParam::DevParam()
|
|
{
|
|
Reset();
|
|
}
|
|
|
|
DevParam::~DevParam()
|
|
{
|
|
|
|
}
|
|
|
|
void DevParam::Reset()
|
|
{
|
|
autofeeder = true;
|
|
pixel = 1;
|
|
white = false;
|
|
discardBlankThre = 5;
|
|
single = false;
|
|
format = "jpg";
|
|
resolution = 200;
|
|
orentation = 0;
|
|
paperType = "Auto";
|
|
splitImage = 0;
|
|
noiseDetachEnable = true;
|
|
noiseDetach = 15;
|
|
|
|
uploadMode = 2;
|
|
ftpPath = "/images";
|
|
ftpPort = 21;
|
|
ftpMode = 2;
|
|
}
|
|
|
|
void DevParam::Load(const std::string& cfgPath)
|
|
{
|
|
HGInt intValue;
|
|
HGChar strValue[256];
|
|
|
|
HGBase_GetProfileString(cfgPath.c_str(), "devParam", "device", "", strValue, 256);
|
|
device = strValue;
|
|
HGBase_GetProfileInt(cfgPath.c_str(), "devParam", "autofeeder", 1, &intValue);
|
|
autofeeder = (bool)intValue;
|
|
HGBase_GetProfileInt(cfgPath.c_str(), "devParam", "pixel", 1, &intValue);
|
|
pixel = intValue;
|
|
HGBase_GetProfileInt(cfgPath.c_str(), "devParam", "white", 0, &intValue);
|
|
white = (bool)intValue;
|
|
HGBase_GetProfileInt(cfgPath.c_str(), "devParam", "discardBlankThre", 5, &intValue);
|
|
discardBlankThre = intValue;
|
|
HGBase_GetProfileInt(cfgPath.c_str(), "devParam", "single", 0, &intValue);
|
|
single = (bool)intValue;
|
|
HGBase_GetProfileString(cfgPath.c_str(), "devParam", "format", "jpg", strValue, 256);
|
|
format = strValue;
|
|
HGBase_GetProfileInt(cfgPath.c_str(), "devParam", "resolution", 200, &intValue);
|
|
resolution = intValue;
|
|
HGBase_GetProfileInt(cfgPath.c_str(), "devParam", "orentation", 0, &intValue);
|
|
orentation = intValue;
|
|
HGBase_GetProfileString(cfgPath.c_str(), "devParam", "paperType", "Auto", strValue, 256);
|
|
paperType = strValue;
|
|
HGBase_GetProfileInt(cfgPath.c_str(), "devParam", "splitImage", 0, &intValue);
|
|
splitImage = intValue;
|
|
HGBase_GetProfileInt(cfgPath.c_str(), "devParam", "noiseDetachEnable”", 1, &intValue);
|
|
noiseDetachEnable = (bool)intValue;
|
|
HGBase_GetProfileInt(cfgPath.c_str(), "devParam", "noiseDetach", 15, &intValue);
|
|
noiseDetach = intValue;
|
|
|
|
HGBase_GetProfileInt(cfgPath.c_str(), "devParam", "uploadMode", 2, &intValue);
|
|
uploadMode = intValue;
|
|
HGBase_GetProfileString(cfgPath.c_str(), "devParam", "httpUrl", "", strValue, 256);
|
|
httpUrl = strValue;
|
|
HGBase_GetProfileString(cfgPath.c_str(), "devParam", "fileName", "", strValue, 256);
|
|
fileName = strValue;
|
|
HGBase_GetProfileString(cfgPath.c_str(), "devParam", "httpMethod", "", strValue, 256);
|
|
httpMethod = strValue;
|
|
HGBase_GetProfileString(cfgPath.c_str(), "devParam", "header", "", strValue, 256);
|
|
header = strValue;
|
|
HGBase_GetProfileString(cfgPath.c_str(), "devParam", "param", "", strValue, 256);
|
|
param = strValue;
|
|
HGBase_GetProfileString(cfgPath.c_str(), "devParam", "ftpUrl", "", strValue, 256);
|
|
ftpUrl = strValue;
|
|
HGBase_GetProfileString(cfgPath.c_str(), "devParam", "ftpPath", "", strValue, 256);
|
|
ftpPath = strValue;
|
|
HGBase_GetProfileString(cfgPath.c_str(), "devParam", "ftpUser", "", strValue, 256);
|
|
ftpUser = strValue;
|
|
HGBase_GetProfileString(cfgPath.c_str(), "devParam", "ftpPassword", "", strValue, 256);
|
|
ftpPassword = strValue;
|
|
HGBase_GetProfileInt(cfgPath.c_str(), "devParam", "ftpPort", 21, &intValue);
|
|
ftpPort = intValue;
|
|
HGBase_GetProfileInt(cfgPath.c_str(), "devParam", "ftpMode", 2, &intValue);
|
|
ftpMode = intValue;
|
|
}
|
|
|
|
void DevParam::Save(const std::string& cfgPath)
|
|
{
|
|
HGBase_SetProfileString(cfgPath.c_str(), "devParam", "device", device.c_str());
|
|
HGBase_SetProfileInt(cfgPath.c_str(), "devParam", "autofeeder", autofeeder);
|
|
HGBase_SetProfileInt(cfgPath.c_str(), "devParam", "pixel", pixel);
|
|
HGBase_SetProfileInt(cfgPath.c_str(), "devParam", "white", white);
|
|
HGBase_SetProfileInt(cfgPath.c_str(), "devParam", "discardBlankThre", discardBlankThre);
|
|
HGBase_SetProfileInt(cfgPath.c_str(), "devParam", "single", single);
|
|
HGBase_SetProfileString(cfgPath.c_str(), "devParam", "format", format.c_str());
|
|
HGBase_SetProfileInt(cfgPath.c_str(), "devParam", "resolution", resolution);
|
|
HGBase_SetProfileInt(cfgPath.c_str(), "devParam", "orentation", orentation);
|
|
HGBase_SetProfileString(cfgPath.c_str(), "devParam", "paperType", paperType.c_str());
|
|
HGBase_SetProfileInt(cfgPath.c_str(), "devParam", "splitImage", splitImage);
|
|
HGBase_SetProfileInt(cfgPath.c_str(), "devParam", "noiseDetachEnable", noiseDetachEnable);
|
|
HGBase_SetProfileInt(cfgPath.c_str(), "devParam", "noiseDetach", noiseDetach);
|
|
|
|
HGBase_SetProfileInt(cfgPath.c_str(), "devParam", "uploadMode", uploadMode);
|
|
HGBase_SetProfileString(cfgPath.c_str(), "devParam", "httpUrl", httpUrl.c_str());
|
|
HGBase_SetProfileString(cfgPath.c_str(), "devParam", "fileName", fileName.c_str());
|
|
HGBase_SetProfileString(cfgPath.c_str(), "devParam", "httpMethod", httpMethod.c_str());
|
|
HGBase_SetProfileString(cfgPath.c_str(), "devParam", "header", header.c_str());
|
|
HGBase_SetProfileString(cfgPath.c_str(), "devParam", "param", param.c_str());
|
|
HGBase_SetProfileString(cfgPath.c_str(), "devParam", "ftpUrl", ftpUrl.c_str());
|
|
HGBase_SetProfileString(cfgPath.c_str(), "devParam", "ftpPath", ftpPath.c_str());
|
|
HGBase_SetProfileString(cfgPath.c_str(), "devParam", "ftpUser", ftpUser.c_str());
|
|
HGBase_SetProfileString(cfgPath.c_str(), "devParam", "ftpPassword", ftpPassword.c_str());
|
|
HGBase_SetProfileInt(cfgPath.c_str(), "devParam", "ftpPort", ftpPort);
|
|
HGBase_SetProfileInt(cfgPath.c_str(), "devParam", "ftpMode", ftpMode);
|
|
}
|
|
|
|
Manager::Manager(class MsgLoop* loop)
|
|
{
|
|
m_loop = loop;
|
|
HGBase_CreateLock(&m_lock);
|
|
m_devName.clear();
|
|
m_devHandle = NULL;
|
|
m_scanEvent = NULL;
|
|
m_scanParam = NULL;
|
|
|
|
m_scanInsertImgName.clear();
|
|
m_scanIsInsert = false;
|
|
m_scanning = false;
|
|
|
|
SANE_Int version_code = 0;
|
|
SANE_Status status = sane_init_ex(&version_code, sane_ex_callback, this);
|
|
assert(SANE_STATUS_GOOD == status);
|
|
}
|
|
|
|
Manager::~Manager()
|
|
{
|
|
if (NULL != m_devHandle)
|
|
{
|
|
StopScan();
|
|
|
|
m_devParam.Reset();
|
|
sane_close(m_devHandle);
|
|
m_devHandle = NULL;
|
|
m_devName.clear();
|
|
}
|
|
|
|
sane_exit();
|
|
|
|
HGBase_DestroyLock(m_lock);
|
|
m_lock = NULL;
|
|
}
|
|
|
|
void Manager::OpenDev(const OpenDevParam* param)
|
|
{
|
|
if (!m_devName.empty() || NULL != m_devHandle)
|
|
{
|
|
return;
|
|
}
|
|
|
|
SANE_Handle devHandle = NULL;
|
|
SANE_Status status = sane_open(param->devName.c_str(), &devHandle);
|
|
if (SANE_STATUS_GOOD == status)
|
|
{
|
|
assert(NULL != devHandle);
|
|
|
|
m_devName = param->devName;
|
|
m_devHandle = devHandle;
|
|
|
|
std::string filePath = GetFilePath(m_devName);
|
|
std::string cfgPath = filePath + "config.ini";
|
|
m_devParam.Load(cfgPath);
|
|
SetDevParam(m_devName, m_devParam);
|
|
}
|
|
}
|
|
|
|
void Manager::CloseDev(const CloseDevParam* param)
|
|
{
|
|
if (m_devName.empty() || NULL == m_devHandle || m_devName != param->devName)
|
|
{
|
|
return;
|
|
}
|
|
|
|
assert(NULL != m_devHandle);
|
|
|
|
StopScan();
|
|
|
|
m_devParam.Reset();
|
|
sane_close(m_devHandle);
|
|
m_devHandle = NULL;
|
|
m_devName.clear();
|
|
}
|
|
|
|
void Manager::ScanFinish()
|
|
{
|
|
m_scanInsertImgName.clear();
|
|
m_scanIsInsert = false;
|
|
m_scanning = false;
|
|
}
|
|
|
|
void Manager::SetScanEvent(ScanEvent event, void* param)
|
|
{
|
|
assert(NULL != event && NULL != param);
|
|
|
|
HGBase_EnterLock(m_lock);
|
|
m_scanEvent = event;
|
|
m_scanParam = param;
|
|
HGBase_LeaveLock(m_lock);
|
|
}
|
|
|
|
void Manager::ResetScanEvent()
|
|
{
|
|
HGBase_EnterLock(m_lock);
|
|
m_scanEvent = NULL;
|
|
m_scanParam = NULL;
|
|
HGBase_LeaveLock(m_lock);
|
|
}
|
|
|
|
bool Manager::Scan(const std::string& insertImgName, bool isInsert)
|
|
{
|
|
if (m_scanning)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
bool ret = false;
|
|
if (NULL != m_devHandle)
|
|
{
|
|
m_scanInsertImgName = insertImgName;
|
|
m_scanIsInsert = isInsert;
|
|
if (SANE_STATUS_GOOD == sane_start(m_devHandle))
|
|
{
|
|
m_scanning = true;
|
|
ret = true;
|
|
}
|
|
else
|
|
{
|
|
m_scanInsertImgName.clear();
|
|
m_scanIsInsert = false;
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
bool Manager::StopScan()
|
|
{
|
|
if (m_scanning)
|
|
{
|
|
assert(NULL != m_devHandle);
|
|
sane_cancel(m_devHandle);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool Manager::GetCurDevId(std::string& devId)
|
|
{
|
|
devId.clear();
|
|
if (m_scanning)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
devId = m_devName;
|
|
return true;
|
|
}
|
|
|
|
bool Manager::GetDevNames(std::vector<std::string>& devNameList)
|
|
{
|
|
devNameList.clear();
|
|
if (m_scanning)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
const SANE_Device** device_list;
|
|
if (SANE_STATUS_GOOD == sane_get_devices(&device_list, SANE_TRUE))
|
|
{
|
|
const SANE_Device** p;
|
|
for (p = device_list; *p != NULL; ++p)
|
|
{
|
|
devNameList.push_back((*p)->name);
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool Manager::GetImageByDevId(const std::string& devId, std::vector<std::string>& imgNameList,
|
|
std::vector<std::string>& imgBase64List)
|
|
{
|
|
imgNameList.clear();
|
|
imgBase64List.clear();
|
|
if (m_scanning)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
std::string filePath = GetFilePath(devId);
|
|
std::vector<std::string> fileNameList = GetFileNameList(devId);
|
|
HGBase_WriteInfo(HGBASE_INFOTYPE_DEBUG, "filePath=%s", filePath.c_str());
|
|
|
|
for (int i = 0; i < (int)fileNameList.size(); ++i)
|
|
{
|
|
std::string fileName = filePath + fileNameList[i];
|
|
|
|
HGImage img = NULL;
|
|
HGImgFmt_LoadImage(fileName.c_str(), 0, NULL, HGBASE_IMGTYPE_RGB, HGBASE_IMGORIGIN_TOP, &img);
|
|
if (NULL != img)
|
|
{
|
|
std::string imgBase64 = "data:image/jpeg;base64,";
|
|
imgBase64 += GetBase64(img, 0);
|
|
|
|
imgNameList.push_back(fileNameList[i]);
|
|
imgBase64List.push_back(imgBase64);
|
|
HGBase_DestroyImage(img);
|
|
}
|
|
}
|
|
|
|
SaveFileNameList(devId, imgNameList);
|
|
return true;
|
|
}
|
|
|
|
bool Manager::GetDevParam(const std::string& devId, DevParam& devParam)
|
|
{
|
|
devParam.Reset();
|
|
if (m_scanning)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
bool ret = false;
|
|
if (NULL != m_devHandle)
|
|
{
|
|
m_devParam.device = m_devName;
|
|
|
|
// 从设备获取到m_devParam
|
|
|
|
SANE_Int num_dev_options = 0;
|
|
sane_control_option(m_devHandle, 0, SANE_ACTION_GET_VALUE, &num_dev_options, NULL);
|
|
for (int i = 1; i < num_dev_options; ++i)
|
|
{
|
|
const SANE_Option_Descriptor* desp = sane_get_option_descriptor(m_devHandle, i);
|
|
if (NULL == desp)
|
|
continue;
|
|
|
|
HGBase_WriteInfo(HGBASE_INFOTYPE_DESC, "title=%s", Utf8ToStdString(desp->title).c_str());
|
|
|
|
if (SANE_TYPE_BOOL == desp->type)
|
|
{
|
|
SANE_Bool value = 0;
|
|
sane_control_option(m_devHandle, i, SANE_ACTION_GET_VALUE, &value, NULL);
|
|
HGBase_WriteInfo(HGBASE_INFOTYPE_DESC, " valueType=BOOL, value=%s", value ? "TRUE" : "FALSE");
|
|
|
|
if (0 == strcmp(desp->title, OPTION_TITLE_TXCF))
|
|
m_devParam.splitImage = value ? 1 : 0;
|
|
else if (0 == strcmp(desp->title, OPTION_TITLE_HBTXZDYH))
|
|
m_devParam.noiseDetachEnable = (bool)value;
|
|
}
|
|
else if (SANE_TYPE_INT == desp->type)
|
|
{
|
|
SANE_Int value = 0;
|
|
sane_control_option(m_devHandle, i, SANE_ACTION_GET_VALUE, &value, NULL);
|
|
HGBase_WriteInfo(HGBASE_INFOTYPE_DESC, " valueType=INT, value=%d", value);
|
|
|
|
if (0 == strcmp(desp->title, OPTION_TITLE_TGKBYLMD))
|
|
m_devParam.discardBlankThre = value;
|
|
else if (0 == strcmp(desp->title, OPTION_TITLE_FBL))
|
|
m_devParam.resolution = value;
|
|
}
|
|
else if (SANE_TYPE_FIXED == desp->type)
|
|
{
|
|
HGBase_WriteInfo(HGBASE_INFOTYPE_DESC, " valueType=FIXED");
|
|
}
|
|
else if (SANE_TYPE_STRING == desp->type)
|
|
{
|
|
char value[256] = {0};
|
|
sane_control_option(m_devHandle, i, SANE_ACTION_GET_VALUE, value, NULL);
|
|
HGBase_WriteInfo(HGBASE_INFOTYPE_DESC, " valueType=STRING, value=%s", Utf8ToStdString(value).c_str());
|
|
|
|
if (0 == strcmp(OPTION_TITLE_SMZS, desp->title) && 0 == strcmp(OPTION_VALUE_SMZS_LXSM, value))
|
|
m_devParam.autofeeder = true;
|
|
else if (0 == strcmp(OPTION_TITLE_SMZS, desp->title) && 0 == strcmp(OPTION_VALUE_SMZS_SMZDZS, value))
|
|
m_devParam.autofeeder = false;
|
|
else if (0 == strcmp(OPTION_TITLE_YSMS, desp->title) && (0 == strcmp(OPTION_VALUE_YSMS_24WCS, value)
|
|
|| 0 == strcmp(OPTION_VALUE_YSMS_YSZDSB, value)))
|
|
m_devParam.pixel = 2;
|
|
else if (0 == strcmp(OPTION_TITLE_YSMS, desp->title) && 0 == strcmp(OPTION_VALUE_YSMS_256JHD, value))
|
|
m_devParam.pixel = 1;
|
|
else if (0 == strcmp(OPTION_TITLE_YSMS, desp->title) && 0 == strcmp(OPTION_VALUE_YSMS_HB, value))
|
|
m_devParam.pixel = 0;
|
|
else if (0 == strcmp(OPTION_TITLE_SMYM, desp->title) && 0 == strcmp(OPTION_VALUE_SMYM_SM, value))
|
|
{
|
|
m_devParam.white = false;
|
|
m_devParam.single = false;
|
|
}
|
|
else if (0 == strcmp(OPTION_TITLE_SMYM, desp->title) && 0 == strcmp(OPTION_VALUE_SMYM_DM, value))
|
|
{
|
|
m_devParam.white = false;
|
|
m_devParam.single = true;
|
|
}
|
|
else if (0 == strcmp(OPTION_TITLE_SMYM, desp->title) && (0 == strcmp(OPTION_VALUE_SMYM_TGKBYTY, value)
|
|
|| 0 == strcmp(OPTION_VALUE_SMYM_TGKBYFPZ, value)))
|
|
{
|
|
m_devParam.white = true;
|
|
m_devParam.single = false;
|
|
}
|
|
else if (0 == strcmp(OPTION_TITLE_WGFX, desp->title) && 0 == strcmp(OPTION_VALUE_WGFX_0, value))
|
|
m_devParam.orentation = 0;
|
|
else if (0 == strcmp(OPTION_TITLE_WGFX, desp->title) && 0 == strcmp(OPTION_VALUE_WGFX_90, value))
|
|
m_devParam.orentation = 90;
|
|
else if (0 == strcmp(OPTION_TITLE_WGFX, desp->title) && 0 == strcmp(OPTION_VALUE_WGFX_180, value))
|
|
m_devParam.orentation = 180;
|
|
else if (0 == strcmp(OPTION_TITLE_WGFX, desp->title) && 0 == strcmp(OPTION_VALUE_WGFX__90, value))
|
|
m_devParam.orentation = 270;
|
|
else if (0 == strcmp(OPTION_TITLE_ZZCC, desp->title) && 0 == strcmp(OPTION_VALUE_ZZCC_PPYSCC, value))
|
|
m_devParam.paperType = "Auto";
|
|
else if (0 == strcmp(OPTION_TITLE_ZZCC, desp->title) && 0 == strcmp(OPTION_VALUE_ZZCC_A3, value))
|
|
m_devParam.paperType = "A3";
|
|
else if (0 == strcmp(OPTION_TITLE_ZZCC, desp->title) && 0 == strcmp(OPTION_VALUE_ZZCC_A4, value))
|
|
m_devParam.paperType = "A4";
|
|
}
|
|
else if (SANE_TYPE_BUTTON == desp->type)
|
|
{
|
|
HGBase_WriteInfo(HGBASE_INFOTYPE_DESC, " valueType=BUTTON");
|
|
}
|
|
else if (SANE_TYPE_GROUP == desp->type)
|
|
{
|
|
HGBase_WriteInfo(HGBASE_INFOTYPE_DESC, " valueType=GROUP");
|
|
}
|
|
}
|
|
|
|
std::string filePath = GetFilePath(m_devName);
|
|
std::string cfgPath = filePath + "config.ini";
|
|
m_devParam.Save(cfgPath);
|
|
ret = true;
|
|
}
|
|
|
|
devParam = m_devParam;
|
|
return ret;
|
|
}
|
|
|
|
bool Manager::SetDevParam(const std::string& devId, const DevParam& devParam)
|
|
{
|
|
if (m_scanning)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
m_devParam = devParam;
|
|
|
|
std::string filePath = GetFilePath(m_devName);
|
|
std::string cfgPath = filePath + "config.ini";
|
|
m_devParam.Save(cfgPath);
|
|
|
|
bool ret = false;
|
|
if (NULL != m_devHandle)
|
|
{
|
|
// 设置m_devParam到设备
|
|
|
|
SANE_Int num_dev_options = 0;
|
|
sane_control_option(m_devHandle, 0, SANE_ACTION_GET_VALUE, &num_dev_options, NULL);
|
|
for (int i = 1; i < num_dev_options; ++i)
|
|
{
|
|
const SANE_Option_Descriptor* desp = sane_get_option_descriptor(m_devHandle, i);
|
|
if (NULL == desp)
|
|
continue;
|
|
|
|
if (SANE_TYPE_BOOL == desp->type)
|
|
{
|
|
if (0 == strcmp(desp->title, OPTION_TITLE_TXCF))
|
|
{
|
|
SANE_Bool value = SANE_FALSE;
|
|
if (0 != m_devParam.splitImage)
|
|
value = SANE_TRUE;
|
|
sane_control_option(m_devHandle, i, SANE_ACTION_SET_VALUE, &value, NULL);
|
|
}
|
|
else if (0 == strcmp(desp->title, OPTION_TITLE_HBTXZDYH))
|
|
{
|
|
SANE_Bool value = SANE_FALSE;
|
|
if (m_devParam.noiseDetachEnable)
|
|
value = SANE_TRUE;
|
|
sane_control_option(m_devHandle, i, SANE_ACTION_SET_VALUE, &value, NULL);
|
|
}
|
|
}
|
|
else if (SANE_TYPE_INT == desp->type)
|
|
{
|
|
if (0 == strcmp(desp->title, OPTION_TITLE_TGKBYLMD))
|
|
{
|
|
SANE_Int value = m_devParam.discardBlankThre;
|
|
sane_control_option(m_devHandle, i, SANE_ACTION_SET_VALUE, &value, NULL);
|
|
}
|
|
else if (0 == strcmp(desp->title, OPTION_TITLE_FBL))
|
|
{
|
|
SANE_Int value = m_devParam.resolution;
|
|
sane_control_option(m_devHandle, i, SANE_ACTION_SET_VALUE, &value, NULL);
|
|
}
|
|
else if (0 == strcmp(desp->title, OPTION_TITLE_SMSL))
|
|
{
|
|
SANE_Int value = 1;
|
|
sane_control_option(m_devHandle, i, SANE_ACTION_SET_VALUE, &value, NULL);
|
|
}
|
|
}
|
|
else if (SANE_TYPE_FIXED == desp->type)
|
|
{
|
|
|
|
}
|
|
else if (SANE_TYPE_STRING == desp->type)
|
|
{
|
|
if (0 == strcmp(OPTION_TITLE_SMZS, desp->title))
|
|
{
|
|
char value[256] = { 0 };
|
|
strcpy(value, OPTION_VALUE_SMZS_LXSM);
|
|
if (!m_devParam.autofeeder)
|
|
strcpy(value, OPTION_VALUE_SMZS_SMZDZS);
|
|
sane_control_option(m_devHandle, i, SANE_ACTION_SET_VALUE, (void*)value, NULL);
|
|
}
|
|
else if (0 == strcmp(OPTION_TITLE_YSMS, desp->title))
|
|
{
|
|
char value[256] = { 0 };
|
|
strcpy(value, OPTION_VALUE_YSMS_24WCS);
|
|
if (1 == m_devParam.pixel)
|
|
strcpy(value, OPTION_VALUE_YSMS_256JHD);
|
|
else if (0 == m_devParam.pixel)
|
|
strcpy(value, OPTION_VALUE_YSMS_HB);
|
|
sane_control_option(m_devHandle, i, SANE_ACTION_SET_VALUE, (void *)value, NULL);
|
|
}
|
|
else if (0 == strcmp(OPTION_TITLE_SMYM, desp->title))
|
|
{
|
|
char value[256] = { 0 };
|
|
strcpy(value, OPTION_VALUE_SMYM_SM);
|
|
if (m_devParam.single)
|
|
strcpy(value, OPTION_VALUE_SMYM_DM);
|
|
else if (m_devParam.white)
|
|
strcpy(value, OPTION_VALUE_SMYM_TGKBYTY);
|
|
sane_control_option(m_devHandle, i, SANE_ACTION_SET_VALUE, (void*)value, NULL);
|
|
}
|
|
else if (0 == strcmp(OPTION_TITLE_WGFX, desp->title))
|
|
{
|
|
char value[256] = { 0 };
|
|
strcpy(value, OPTION_VALUE_WGFX_0);
|
|
if (90 == m_devParam.orentation)
|
|
strcpy(value, OPTION_VALUE_WGFX_90);
|
|
else if (180 == m_devParam.orentation)
|
|
strcpy(value, OPTION_VALUE_WGFX_180);
|
|
else if (270 == m_devParam.orentation)
|
|
strcpy(value, OPTION_VALUE_WGFX__90);
|
|
sane_control_option(m_devHandle, i, SANE_ACTION_SET_VALUE, (void*)value, NULL);
|
|
}
|
|
else if (0 == strcmp(OPTION_TITLE_ZZCC, desp->title))
|
|
{
|
|
char value[256] = { 0 };
|
|
strcpy(value, OPTION_VALUE_ZZCC_PPYSCC);
|
|
if ("A3" == m_devParam.paperType)
|
|
strcpy(value, OPTION_VALUE_ZZCC_A3);
|
|
else if ("A4" == m_devParam.paperType)
|
|
strcpy(value, OPTION_VALUE_ZZCC_A4);
|
|
sane_control_option(m_devHandle, i, SANE_ACTION_SET_VALUE, (void*)value, NULL);
|
|
}
|
|
}
|
|
else if (SANE_TYPE_BUTTON == desp->type)
|
|
{
|
|
|
|
}
|
|
else if (SANE_TYPE_GROUP == desp->type)
|
|
{
|
|
|
|
}
|
|
}
|
|
|
|
ret = true;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
bool Manager::ExportOfd(const std::string& devId, bool isAuto, std::string& imgBase64)
|
|
{
|
|
imgBase64.clear();
|
|
if (m_scanning)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
HGByte* data = NULL;
|
|
HGUInt size = 0;
|
|
ExportOfdFile(devId, isAuto, &data, &size);
|
|
if (NULL != data)
|
|
{
|
|
imgBase64 = GetBase64(data, size);
|
|
delete[] data;
|
|
}
|
|
|
|
return !imgBase64.empty();
|
|
}
|
|
|
|
bool Manager::ExportOfdFile(const std::string& devId, bool isAuto, const std::string& fileName)
|
|
{
|
|
std::string filePath = GetFilePath(devId);
|
|
std::vector<std::string> fileNameList = GetFileNameList(devId);
|
|
if (fileNameList.empty())
|
|
{
|
|
return false;
|
|
}
|
|
|
|
HGOfdImageWriter writer = NULL;
|
|
HGImgFmt_OpenOfdImageWriter(fileName.c_str(), &writer);
|
|
if (NULL == writer)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
bool ret = false;
|
|
for (int i = 0; i < (int)fileNameList.size(); ++i)
|
|
{
|
|
HGImage img = NULL;
|
|
std::string fileName = filePath + fileNameList[i];
|
|
HGImgFmt_LoadImage(fileName.c_str(), 0, NULL, HGBASE_IMGTYPE_RGB, HGBASE_IMGORIGIN_TOP, &img);
|
|
if (NULL != img)
|
|
{
|
|
if (HGBASE_ERR_OK == HGImgFmt_SaveJpegImageToOfdImageWriter(writer, img, NULL, 0))
|
|
ret = true;
|
|
HGBase_DestroyImage(img);
|
|
}
|
|
}
|
|
|
|
HGImgFmt_CloseOfdImageWriter(writer);
|
|
|
|
if (!ret)
|
|
{
|
|
HGBase_DeleteFile(fileName.c_str());
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool Manager::ExportOfdFile(const std::string& devId, bool isAuto, HGByte** data, HGUInt* size)
|
|
{
|
|
*data = NULL;
|
|
*size = 0;
|
|
if (m_scanning)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
HGChar tmpFileName[512];
|
|
HGBase_GetTmpFileName(tmpFileName, 512);
|
|
ExportOfdFile(devId, isAuto, tmpFileName);
|
|
|
|
*data = GetBuffer(tmpFileName, size);
|
|
HGBase_DeleteFile(tmpFileName);
|
|
return (NULL != *data);
|
|
}
|
|
|
|
bool Manager::ExportPdf(const std::string& devId, std::string& imgBase64)
|
|
{
|
|
imgBase64.clear();
|
|
if (m_scanning)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
HGByte* data = NULL;
|
|
HGUInt size = 0;
|
|
ExportPdfFile(devId, &data, &size);
|
|
if (NULL != data)
|
|
{
|
|
imgBase64 = GetBase64(data, size);
|
|
delete[] data;
|
|
}
|
|
|
|
return !imgBase64.empty();
|
|
}
|
|
|
|
bool Manager::ExportPdfFile(const std::string& devId, const std::string& fileName)
|
|
{
|
|
std::string filePath = GetFilePath(devId);
|
|
std::vector<std::string> fileNameList = GetFileNameList(devId);
|
|
if (fileNameList.empty())
|
|
{
|
|
return false;
|
|
}
|
|
|
|
HGPdfImageWriter writer = NULL;
|
|
HGImgFmt_OpenPdfImageWriter(fileName.c_str(), &writer);
|
|
if (NULL == writer)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
bool ret = false;
|
|
for (int i = 0; i < (int)fileNameList.size(); ++i)
|
|
{
|
|
HGImage img = NULL;
|
|
std::string fileName = filePath + fileNameList[i];
|
|
HGImgFmt_LoadImage(fileName.c_str(), 0, NULL, HGBASE_IMGTYPE_RGB, HGBASE_IMGORIGIN_TOP, &img);
|
|
if (NULL != img)
|
|
{
|
|
if (HGBASE_ERR_OK == HGImgFmt_SaveJpegImageToPdfImageWriter(writer, img, NULL, 0))
|
|
ret = true;
|
|
HGBase_DestroyImage(img);
|
|
}
|
|
}
|
|
|
|
HGImgFmt_ClosePdfImageWriter(writer);
|
|
|
|
if (!ret)
|
|
{
|
|
HGBase_DeleteFile(fileName.c_str());
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool Manager::ExportPdfFile(const std::string& devId, HGByte** data, HGUInt* size)
|
|
{
|
|
*data = NULL;
|
|
*size = 0;
|
|
if (m_scanning)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
HGChar tmpFileName[512];
|
|
HGBase_GetTmpFileName(tmpFileName, 512);
|
|
ExportPdfFile(devId, tmpFileName);
|
|
|
|
*data = GetBuffer(tmpFileName, size);
|
|
HGBase_DeleteFile(tmpFileName);
|
|
return (NULL != *data);
|
|
}
|
|
|
|
bool Manager::ExportTiff(const std::string& devId, std::string& imgBase64)
|
|
{
|
|
imgBase64.clear();
|
|
if (m_scanning)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
HGByte* data = NULL;
|
|
HGUInt size = 0;
|
|
ExportTiffFile(devId, &data, &size);
|
|
if (NULL != data)
|
|
{
|
|
imgBase64 = GetBase64(data, size);
|
|
delete[] data;
|
|
}
|
|
|
|
return !imgBase64.empty();
|
|
}
|
|
|
|
bool Manager::ExportTiff(const std::string& devId, const std::string& fileName)
|
|
{
|
|
std::string filePath = GetFilePath(devId);
|
|
std::vector<std::string> fileNameList = GetFileNameList(devId);
|
|
if (fileNameList.empty())
|
|
{
|
|
return false;
|
|
}
|
|
|
|
HGTiffWriter writer = NULL;
|
|
HGImgFmt_OpenTiffWriter(fileName.c_str(), &writer);
|
|
if (NULL == writer)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
bool ret = false;
|
|
for (int i = 0; i < (int)fileNameList.size(); ++i)
|
|
{
|
|
HGImage img = NULL;
|
|
std::string fileName = filePath + fileNameList[i];
|
|
HGImgFmt_LoadImage(fileName.c_str(), 0, NULL, HGBASE_IMGTYPE_RGB, HGBASE_IMGORIGIN_TOP, &img);
|
|
if (NULL != img)
|
|
{
|
|
if (HGBASE_ERR_OK == HGImgFmt_SaveImageToTiffWriter(writer, img, NULL))
|
|
ret = true;
|
|
HGBase_DestroyImage(img);
|
|
}
|
|
}
|
|
|
|
HGImgFmt_CloseTiffWriter(writer);
|
|
|
|
if (!ret)
|
|
{
|
|
HGBase_DeleteFile(fileName.c_str());
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool Manager::ExportTiffFile(const std::string& devId, HGByte** data, HGUInt* size)
|
|
{
|
|
*data = NULL;
|
|
*size = 0;
|
|
if (m_scanning)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
HGChar tmpFileName[512];
|
|
HGBase_GetTmpFileName(tmpFileName, 512);
|
|
ExportTiff(devId, tmpFileName);
|
|
|
|
*data = GetBuffer(tmpFileName, size);
|
|
HGBase_DeleteFile(tmpFileName);
|
|
return (NULL != *data);
|
|
}
|
|
|
|
bool Manager::ExportZip(const std::string& devId, std::string& imgBase64)
|
|
{
|
|
imgBase64.clear();
|
|
if (m_scanning)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
HGByte* data = NULL;
|
|
HGUInt size = 0;
|
|
ExportZipFile(devId, &data, &size);
|
|
if (NULL != data)
|
|
{
|
|
imgBase64 = GetBase64(data, size);
|
|
delete[] data;
|
|
}
|
|
|
|
return !imgBase64.empty();
|
|
}
|
|
|
|
bool Manager::ExportZipFile(const std::string& devId, const std::string& fileName)
|
|
{
|
|
std::string filePath = GetFilePath(devId);
|
|
std::vector<std::string> fileNameList = GetFileNameList(devId);
|
|
if (fileNameList.empty())
|
|
{
|
|
return false;
|
|
}
|
|
|
|
int error = 0;
|
|
zip* z = zip_open(StdStringToUtf8(fileName.c_str()).c_str(), ZIP_CREATE | ZIP_TRUNCATE, &error);
|
|
if (NULL == z)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
bool ret = false;
|
|
for (int i = 0; i < (int)fileNameList.size(); ++i)
|
|
{
|
|
std::string fileName = filePath + fileNameList[i];
|
|
zip_source_t* s = zip_source_file(z, StdStringToUtf8(fileName.c_str()).c_str(), 0, 0);
|
|
if (NULL != s)
|
|
{
|
|
if (zip_file_add(z, StdStringToUtf8(fileNameList[i].c_str()).c_str(), s, ZIP_FL_OVERWRITE) >= 0)
|
|
{
|
|
ret = true;
|
|
}
|
|
else
|
|
{
|
|
zip_source_free(s);
|
|
}
|
|
}
|
|
}
|
|
|
|
zip_close(z);
|
|
z = NULL;
|
|
|
|
if (!ret)
|
|
{
|
|
HGBase_DeleteFile(fileName.c_str());
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool Manager::ExportZipFile(const std::string& devId, HGByte** data, HGUInt* size)
|
|
{
|
|
*data = NULL;
|
|
*size = 0;
|
|
if (m_scanning)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
HGChar tmpFileName[512];
|
|
HGBase_GetTmpFileName(tmpFileName, 512);
|
|
ExportZipFile(devId, tmpFileName);
|
|
|
|
*data = GetBuffer(tmpFileName, size);
|
|
HGBase_DeleteFile(tmpFileName);
|
|
return (NULL != *data);
|
|
}
|
|
|
|
bool Manager::UploadImage(const UploadParam& uploadParam)
|
|
{
|
|
if (m_scanning)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
std::string devId;
|
|
GetCurDevId(devId);
|
|
|
|
HGChar tmpFileName[512];
|
|
HGBase_GetTmpFileName(tmpFileName, 512);
|
|
if (0 == uploadParam.format)
|
|
{
|
|
strcat(tmpFileName, ".ofd");
|
|
ExportOfdFile(devId, true, tmpFileName);
|
|
}
|
|
else if (1 == uploadParam.format)
|
|
{
|
|
strcat(tmpFileName, ".pdf");
|
|
ExportPdfFile(devId, tmpFileName);
|
|
}
|
|
else
|
|
{
|
|
strcat(tmpFileName, ".zip");
|
|
ExportZipFile(devId, tmpFileName);
|
|
}
|
|
|
|
bool ret = false;
|
|
if (0 == uploadParam.uploadMode) // HTTP
|
|
{
|
|
ret = HTTPUpload(tmpFileName, uploadParam.httpUrl, uploadParam.fileName, uploadParam.httpMethod,
|
|
uploadParam.header, uploadParam.param);
|
|
}
|
|
else if (1 == uploadParam.uploadMode) // FTP
|
|
{
|
|
ret = FTPUpload(tmpFileName, uploadParam.ftpUrl, uploadParam.ftpPort, uploadParam.ftpPath,
|
|
uploadParam.ftpUser, uploadParam.ftpPassword, uploadParam.ftpMode);
|
|
}
|
|
|
|
HGBase_DeleteFile(tmpFileName);
|
|
return ret;
|
|
}
|
|
|
|
bool Manager::SaveImage(const std::string& devId, const std::string& imgName, const std::string& imgBase64)
|
|
{
|
|
if (m_scanning)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
std::string filePath = GetFilePath(devId);
|
|
std::string fileName = filePath + imgName;
|
|
|
|
size_t pos = imgBase64.find(",");
|
|
if (std::string::npos != pos)
|
|
return SaveBase64(fileName, imgBase64.c_str() + pos + 1);
|
|
else
|
|
return SaveBase64(fileName, imgBase64.c_str());
|
|
}
|
|
|
|
bool Manager::DeleteImage(const std::string& devId, const std::string& imgName)
|
|
{
|
|
if (m_scanning)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
std::string filePath = GetFilePath(devId);
|
|
std::string fileName = filePath + imgName;
|
|
|
|
bool ret = false;
|
|
if (HGBASE_ERR_OK == HGBase_DeleteFile(fileName.c_str()))
|
|
{
|
|
std::vector<std::string> fileNameList = GetFileNameList(devId);
|
|
for (int i = 0; i < (int)fileNameList.size(); ++i)
|
|
{
|
|
if (imgName == fileNameList[i])
|
|
{
|
|
fileNameList.erase(fileNameList.begin() + i);
|
|
break;
|
|
}
|
|
}
|
|
|
|
SaveFileNameList(devId, fileNameList);
|
|
ret = true;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
bool Manager::DeleteAllImage(const std::string& devId)
|
|
{
|
|
if (m_scanning)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
std::string filePath = GetFilePath(devId);
|
|
std::vector<std::string> fileNameList = GetFileNameList(devId);
|
|
|
|
for (int i = 0; i < (int)fileNameList.size(); ++i)
|
|
{
|
|
std::string fileName = filePath + fileNameList[i];
|
|
HGBase_DeleteFile(fileName.c_str());
|
|
}
|
|
fileNameList.clear();
|
|
|
|
SaveFileNameList(devId, fileNameList);
|
|
return true;
|
|
}
|
|
|
|
bool Manager::MergeImage(const std::string& devId, bool isHorizontal, const std::vector<int>& imgIndexList,
|
|
std::string& imgName, std::string& imgBase64)
|
|
{
|
|
imgName.clear();
|
|
imgBase64.clear();
|
|
if (m_scanning)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
std::string filePath = GetFilePath(devId);
|
|
std::vector<std::string> fileNameList = GetFileNameList(devId);
|
|
|
|
std::vector<HGImage> imgList;
|
|
for (int i = 0; i < (int)imgIndexList.size(); ++i)
|
|
{
|
|
int index = imgIndexList[i];
|
|
if (index >= 0 && index < (int)fileNameList.size())
|
|
{
|
|
std::string fileName = filePath + fileNameList[index];
|
|
HGImage img = NULL;
|
|
HGImgFmt_LoadImage(fileName.c_str(), 0, NULL, HGBASE_IMGTYPE_RGB, HGBASE_IMGORIGIN_TOP, &img);
|
|
if (NULL != img)
|
|
imgList.push_back(img);
|
|
}
|
|
}
|
|
|
|
HGUInt width = 0, height = 0;
|
|
for (int i = 0; i < (int)imgList.size(); ++i)
|
|
{
|
|
HGImageInfo imgInfo;
|
|
HGBase_GetImageInfo(imgList[i], &imgInfo);
|
|
if (isHorizontal)
|
|
{
|
|
width += imgInfo.width;
|
|
if (imgInfo.height > height)
|
|
height = imgInfo.height;
|
|
}
|
|
else
|
|
{
|
|
height += imgInfo.height;
|
|
if (imgInfo.width > width)
|
|
width = imgInfo.width;
|
|
}
|
|
}
|
|
|
|
if (width > 0 && height > 0)
|
|
{
|
|
HGImage img = NULL;
|
|
HGBase_CreateImage(width, height, HGBASE_IMGTYPE_RGB, HGBASE_IMGORIGIN_TOP, &img);
|
|
if (NULL != img)
|
|
{
|
|
HGUInt x = 0, y = 0;
|
|
for (int i = 0; i < (int)imgList.size(); ++i)
|
|
{
|
|
HGImageInfo imgInfo;
|
|
HGBase_GetImageInfo(imgList[i], &imgInfo);
|
|
|
|
HGImageRoi roi = {x, y, x + imgInfo.width, y + imgInfo.height};
|
|
HGBase_SetImageROI(img, &roi);
|
|
HGBase_CopyImage(imgList[i], img);
|
|
HGBase_ResetImageROI(img);
|
|
|
|
if (isHorizontal)
|
|
x += imgInfo.width;
|
|
else
|
|
y += imgInfo.height;
|
|
}
|
|
|
|
int maxIndex = 0;
|
|
for (int i = 0; i < (int)fileNameList.size(); ++i)
|
|
{
|
|
int index = atoi(fileNameList[i].c_str());
|
|
if (index > maxIndex)
|
|
maxIndex = index;
|
|
}
|
|
|
|
HGChar name[256];
|
|
sprintf(name, "%d.%s", maxIndex + 1, m_devParam.format.c_str());
|
|
imgName = name;
|
|
|
|
HGBase_CreateDir(filePath.c_str());
|
|
std::string fileName = filePath + imgName;
|
|
HGImgFmt_SaveImage(img, 0, NULL, 0, fileName.c_str());
|
|
|
|
fileNameList.push_back(imgName);
|
|
SaveFileNameList(devId, fileNameList);
|
|
|
|
imgBase64 = "data:image/jpeg;base64,";
|
|
imgBase64 += GetBase64(img, 0);
|
|
|
|
HGBase_DestroyImage(img);
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < (int)imgList.size(); ++i)
|
|
{
|
|
HGBase_DestroyImage(imgList[i]);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool LowerSort(const std::string &str1, const std::string& str2)
|
|
{
|
|
return atoi(str1.c_str()) < atoi(str2.c_str());
|
|
}
|
|
|
|
bool Manager::BookSort(const std::string& devId, std::vector<std::string>& imgNameList,
|
|
std::vector<std::string>& imgBase64List)
|
|
{
|
|
imgNameList.clear();
|
|
imgBase64List.clear();
|
|
if (m_scanning)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
std::vector<std::string> fileNameList = GetFileNameList(devId);
|
|
std::sort(fileNameList.begin(), fileNameList.end(), LowerSort);
|
|
SaveFileNameList(devId, fileNameList);
|
|
|
|
return GetImageByDevId(devId, imgNameList, imgBase64List);
|
|
}
|
|
|
|
bool Manager::ExchangeImage(const std::string& devId, int index1, int index2)
|
|
{
|
|
if (m_scanning)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
std::string filePath = GetFilePath(devId);
|
|
std::vector<std::string> fileNameList = GetFileNameList(devId);
|
|
if (index1 < 0 || index1 >= (int)fileNameList.size() || index2 < 0 || index2 >= (int)fileNameList.size())
|
|
return false;
|
|
|
|
std::string imgName1 = fileNameList[index1];
|
|
std::string imgName2 = fileNameList[index2];
|
|
fileNameList[index1] = imgName2;
|
|
fileNameList[index2] = imgName1;
|
|
|
|
SaveFileNameList(devId, fileNameList);
|
|
return true;
|
|
}
|
|
|
|
bool Manager::GetLastBetch(std::string& devId)
|
|
{
|
|
devId.clear();
|
|
if (m_scanning)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
devId = m_devName;
|
|
return true;
|
|
}
|
|
|
|
bool Manager::ResetPatchIndex()
|
|
{
|
|
if (m_scanning)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool Manager::SplitImage(const std::string& devId, const std::string& imgName, bool isHorizontal, int x1, int y1, int x2, int y2,
|
|
std::string& imgName1, std::string& imgBase64_1, std::string& imgName2, std::string& imgBase64_2)
|
|
{
|
|
imgName1.clear();
|
|
imgBase64_1.clear();
|
|
imgName2.clear();
|
|
imgBase64_2.clear();
|
|
if (m_scanning)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
std::string filePath = GetFilePath(devId);
|
|
std::string fileName = filePath + imgName;
|
|
|
|
HGImage img = NULL;
|
|
HGImgFmt_LoadImage(fileName.c_str(), 0, NULL, HGBASE_IMGTYPE_RGB, HGBASE_IMGORIGIN_TOP, &img);
|
|
if (NULL != img)
|
|
{
|
|
HGImageInfo imgInfo;
|
|
HGBase_GetImageInfo(img, &imgInfo);
|
|
|
|
for (int i = 0; i < 2; ++i)
|
|
{
|
|
HGUInt newWidth = isHorizontal ? x1 : imgInfo.width;
|
|
if (1 == i)
|
|
newWidth = isHorizontal ? (imgInfo.width - x1) : imgInfo.width;
|
|
|
|
HGUInt newHeight = isHorizontal ? imgInfo.height : y1;
|
|
if (1 == i)
|
|
newHeight = isHorizontal ? imgInfo.height : (imgInfo.height - y1);
|
|
|
|
HGImage newImg = NULL;
|
|
HGBase_CreateImage(newWidth, newHeight, HGBASE_IMGTYPE_RGB, HGBASE_IMGORIGIN_TOP, &newImg);
|
|
if (NULL != newImg)
|
|
{
|
|
HGImageRoi roi;
|
|
|
|
if (isHorizontal)
|
|
{
|
|
roi.left = 0;
|
|
roi.top = 0;
|
|
roi.right = x1;
|
|
roi.bottom = imgInfo.height;
|
|
|
|
if (1 == i)
|
|
{
|
|
roi.left = x1;
|
|
roi.right = imgInfo.width;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
roi.left = 0;
|
|
roi.top = 0;
|
|
roi.right = imgInfo.width;
|
|
roi.bottom = y1;
|
|
|
|
if (1 == i)
|
|
{
|
|
roi.top = y1;
|
|
roi.bottom = imgInfo.height;
|
|
}
|
|
}
|
|
|
|
if (1 == i)
|
|
{
|
|
roi.left = x1;
|
|
roi.right = imgInfo.width;
|
|
}
|
|
|
|
HGBase_SetImageROI(img, &roi);
|
|
HGBase_CopyImage(img, newImg);
|
|
HGBase_ResetImageROI(img);
|
|
|
|
std::vector<std::string> fileNameList = GetFileNameList(devId);
|
|
|
|
int maxIndex = 0;
|
|
for (int i = 0; i < (int)fileNameList.size(); ++i)
|
|
{
|
|
int index = atoi(fileNameList[i].c_str());
|
|
if (index > maxIndex)
|
|
maxIndex = index;
|
|
}
|
|
|
|
HGChar name[256];
|
|
sprintf(name, "%d.%s", maxIndex + 1, m_devParam.format.c_str());
|
|
std::string imgName = name;
|
|
|
|
HGBase_CreateDir(filePath.c_str());
|
|
std::string fileName = filePath + imgName;
|
|
HGImgFmt_SaveImage(newImg, 0, NULL, 0, fileName.c_str());
|
|
|
|
fileNameList.push_back(imgName);
|
|
SaveFileNameList(devId, fileNameList);
|
|
|
|
std::string imgBase64 = "data:image/jpeg;base64,";
|
|
imgBase64 += GetBase64(newImg, 0);
|
|
|
|
if (0 == i)
|
|
{
|
|
imgName1 = imgName;
|
|
imgBase64_1 = imgBase64;
|
|
}
|
|
else
|
|
{
|
|
imgName2 = imgName;
|
|
imgBase64_2 = imgBase64;
|
|
}
|
|
|
|
HGBase_DestroyImage(newImg);
|
|
}
|
|
}
|
|
|
|
HGBase_DestroyImage(img);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool Manager::GetDevSerialNo(const std::string& devId, std::string& serialNo)
|
|
{
|
|
serialNo.clear();
|
|
if (m_scanning)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
serialNo = devId;
|
|
return true;
|
|
}
|
|
|
|
bool Manager::GetImageBase64(const std::string& devId, const std::string& imgName, std::string& imgBase64)
|
|
{
|
|
imgBase64.clear();
|
|
if (m_scanning)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
std::string filePath = GetFilePath(devId);
|
|
std::string fileName = filePath + imgName;
|
|
|
|
HGImage img = NULL;
|
|
HGImgFmt_LoadImage(fileName.c_str(), 0, NULL, HGBASE_IMGTYPE_RGB, HGBASE_IMGORIGIN_TOP, &img);
|
|
if (NULL != img)
|
|
{
|
|
imgBase64 = "data:image/jpeg;base64,";
|
|
imgBase64 += GetBase64(img, 0);
|
|
HGBase_DestroyImage(img);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
std::string Manager::GetFilePath(const std::string& devId)
|
|
{
|
|
HGChar docsPath[256];
|
|
HGBase_GetDocumentsPath(docsPath, 256);
|
|
HGChar imgPath[512];
|
|
sprintf(imgPath, "%sHuago/WebService/%s/", docsPath, Utf8ToStdString(devId.c_str()).c_str());
|
|
HGChar stdImgPath[512];
|
|
HGBase_StandardiseFileName(imgPath, stdImgPath, 512);
|
|
|
|
return stdImgPath;
|
|
}
|
|
|
|
std::vector<std::string> Manager::GetFileNameList(const std::string& devId)
|
|
{
|
|
std::vector<std::string> fileNameList;
|
|
|
|
std::string filePath = GetFilePath(devId);
|
|
std::string cfgName = filePath + "images.txt";
|
|
FILE* file = fopen(cfgName.c_str(), "r");
|
|
if (NULL != file)
|
|
{
|
|
while (feof(file) == 0)
|
|
{
|
|
char lineContent[256] = { 0 };
|
|
if (NULL == fgets(lineContent, 256, file) || '\n' == *lineContent)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (lineContent[strlen(lineContent) - 1] == '\n')
|
|
lineContent[strlen(lineContent) - 1] = 0;
|
|
|
|
fileNameList.push_back(lineContent);
|
|
}
|
|
|
|
fclose(file);
|
|
}
|
|
|
|
return fileNameList;
|
|
}
|
|
|
|
bool Manager::SaveFileNameList(const std::string& devId, const std::vector<std::string>& fileNameList)
|
|
{
|
|
bool ret = false;
|
|
|
|
std::string filePath = GetFilePath(devId);
|
|
std::string cfgName = filePath + "images.txt";
|
|
FILE* file = fopen(cfgName.c_str(), "w");
|
|
if (NULL != file)
|
|
{
|
|
for (int i = 0; i < (int)fileNameList.size(); ++i)
|
|
{
|
|
fwrite(fileNameList[i].c_str(), 1, fileNameList[i].size(), file);
|
|
fwrite("\n", 1, strlen("\n"), file);
|
|
}
|
|
|
|
fclose(file);
|
|
ret = true;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
std::string Manager::GetBase64(HGImage image, HGUInt quality)
|
|
{
|
|
std::string strBase64;
|
|
|
|
if (NULL != image)
|
|
{
|
|
HGBuffer buffer = NULL;
|
|
HGImgFmt_SaveJpegImageToBuffer(image, NULL, quality, &buffer);
|
|
if (NULL != buffer)
|
|
{
|
|
HGByte* data;
|
|
HGBase_GetBufferData(buffer, &data);
|
|
HGUSize size;
|
|
HGBase_GetBufferSize(buffer, &size);
|
|
|
|
HGSize base64Size = 0;
|
|
HGBase_Base64Encode(data, size, NULL, &base64Size);
|
|
uint8_t* base64 = new uint8_t[base64Size + 1];
|
|
HGBase_Base64Encode(data, size, base64, &base64Size);
|
|
base64[base64Size] = 0;
|
|
strBase64 = (const char*)base64;
|
|
delete[] base64;
|
|
|
|
HGBase_DestroyBuffer(buffer);
|
|
}
|
|
}
|
|
|
|
return strBase64;
|
|
}
|
|
|
|
std::string Manager::GetBase64(const HGByte* data, HGUInt size)
|
|
{
|
|
std::string strBase64;
|
|
|
|
if (NULL != data && 0 != size)
|
|
{
|
|
HGSize base64Size = 0;
|
|
HGBase_Base64Encode(data, size, NULL, &base64Size);
|
|
uint8_t* base64 = new uint8_t[base64Size + 1];
|
|
HGBase_Base64Encode(data, size, base64, &base64Size);
|
|
base64[base64Size] = 0;
|
|
strBase64 = (const char*)base64;
|
|
delete[] base64;
|
|
}
|
|
|
|
return strBase64;
|
|
}
|
|
|
|
std::string Manager::GetBase64(const std::string& fileName)
|
|
{
|
|
std::string strBase64;
|
|
|
|
FILE* file = fopen(fileName.c_str(), "rb");
|
|
if (NULL != file)
|
|
{
|
|
fseek(file, 0, SEEK_END);
|
|
long size = ftell(file);
|
|
fseek(file, 0, SEEK_SET);
|
|
|
|
if (size > 0)
|
|
{
|
|
HGByte* data = new HGByte[size];
|
|
long readLen = (long)fread(data, 1, size, file);
|
|
if (readLen == size)
|
|
{
|
|
HGSize base64Size = 0;
|
|
HGBase_Base64Encode(data, size, NULL, &base64Size);
|
|
uint8_t* base64 = new uint8_t[base64Size + 1];
|
|
HGBase_Base64Encode(data, size, base64, &base64Size);
|
|
base64[base64Size] = 0;
|
|
strBase64 = (const char*)base64;
|
|
delete[] base64;
|
|
}
|
|
|
|
delete[] data;
|
|
}
|
|
|
|
fclose(file);
|
|
}
|
|
|
|
return strBase64;
|
|
}
|
|
|
|
HGByte* Manager::GetBuffer(const std::string& fileName, HGUInt* size)
|
|
{
|
|
HGByte* data = NULL;
|
|
*size = 0;
|
|
|
|
FILE* file = fopen(fileName.c_str(), "rb");
|
|
if (NULL != file)
|
|
{
|
|
fseek(file, 0, SEEK_END);
|
|
*size = ftell(file);
|
|
fseek(file, 0, SEEK_SET);
|
|
|
|
if (*size > 0)
|
|
{
|
|
data = new HGByte[*size];
|
|
|
|
HGUInt readLen = (HGUInt)fread(data, 1, *size, file);
|
|
if (readLen != *size)
|
|
{
|
|
delete[] data;
|
|
data = NULL;
|
|
*size = 0;
|
|
}
|
|
}
|
|
|
|
fclose(file);
|
|
}
|
|
|
|
return data;
|
|
}
|
|
|
|
bool Manager::SaveBase64(const std::string& fileName, const char* base64)
|
|
{
|
|
if (NULL == base64 || 0 == *base64)
|
|
return false;
|
|
|
|
HGUInt base64Size = (HGUInt)strlen(base64);
|
|
|
|
bool ret = false;
|
|
FILE* file = fopen(fileName.c_str(), "wb");
|
|
if (NULL != file)
|
|
{
|
|
HGSize size = 0;
|
|
HGBase_Base64Decode((const HGByte*)base64, (HGSize)base64Size, NULL, &size);
|
|
uint8_t* data = new HGByte[size];
|
|
HGBase_Base64Decode((const HGByte*)base64, (HGSize)base64Size, data, &size);
|
|
|
|
size_t writeLen = fwrite(data, 1, size, file);
|
|
if (writeLen == (size_t)size)
|
|
ret = true;
|
|
|
|
delete[] data;
|
|
fclose(file);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
static std::string MakePreFileData(const char* pszBoundary, const char* pszRemoteFileName)
|
|
{
|
|
char data[512];
|
|
sprintf(data, "--%s\r\nContent-Disposition: form-data; name=\"filedata\"; filename=\"%s\"\r\n",
|
|
pszBoundary, pszRemoteFileName);
|
|
std::string ret = data;
|
|
ret += "Content-Type: application/octet-stream; charset=utf-8\r\n";
|
|
ret += "Content-Transfer-Encoding: binary\r\n";
|
|
ret += "\r\n";
|
|
return ret;
|
|
}
|
|
|
|
static std::string MakePostFileData(const char* pszBoundary)
|
|
{
|
|
char data[512];
|
|
sprintf(data, "\r\n--%s\r\nContent-Disposition: form-data; name=\"submitted\"\r\n\r\nsubmit\r\n--%s--\r\n", pszBoundary, pszBoundary);
|
|
return data;
|
|
}
|
|
|
|
static void ParseHttpURL(const std::string &url, std::string &addr, int &port, std::string &path)
|
|
{
|
|
addr.clear();
|
|
port = 0;
|
|
path.clear();
|
|
|
|
std::string url2;
|
|
std::string::size_type pos = url.find("//");
|
|
if (std::string::npos != pos)
|
|
{
|
|
std::string protocal = url.substr(0, pos);
|
|
if (protocal != "http:")
|
|
{
|
|
return;
|
|
}
|
|
|
|
url2 = url.substr(pos + 2);
|
|
}
|
|
else
|
|
{
|
|
url2 = url;
|
|
}
|
|
|
|
std::string addr_port;
|
|
pos = url2.find("/");
|
|
if (std::string::npos != pos)
|
|
{
|
|
addr_port = url2.substr(0, pos);
|
|
path = url2.substr(pos);
|
|
}
|
|
else
|
|
{
|
|
addr_port = url2;
|
|
}
|
|
|
|
pos = addr_port.find(":");
|
|
if (std::string::npos != pos)
|
|
{
|
|
addr = addr_port.substr(0, pos);
|
|
port = atoi(addr_port.substr(pos + 1).c_str());
|
|
}
|
|
else
|
|
{
|
|
addr = addr_port;
|
|
port = 80;
|
|
}
|
|
}
|
|
|
|
bool Manager::HTTPUpload(const std::string& localFileName, const std::string& httpUrl, const std::string& remoteFileName,
|
|
const std::string& httpMethod, const std::string& header, const std::string& param)
|
|
{
|
|
unsigned char* fileData = NULL;
|
|
long fileSize = 0;
|
|
FILE* file = fopen(localFileName.c_str(), "rb");
|
|
if (NULL != file)
|
|
{
|
|
fseek(file, 0, SEEK_END);
|
|
fileSize = ftell(file);
|
|
fseek(file, 0, SEEK_SET);
|
|
|
|
if (0 != fileSize)
|
|
{
|
|
fileData = new unsigned char[fileSize];
|
|
fread(fileData, 1, fileSize, file);
|
|
}
|
|
|
|
fclose(file);
|
|
}
|
|
|
|
if (NULL == fileData)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
std::string addr;
|
|
int port;
|
|
std::string path;
|
|
ParseHttpURL(httpUrl, addr, port, path);
|
|
|
|
#if defined(HG_CMP_MSC)
|
|
SOCKET sockClient = socket(AF_INET, SOCK_STREAM, 0);
|
|
assert(INVALID_SOCKET != sockClient);
|
|
#else
|
|
int sockClient = socket(AF_INET, SOCK_STREAM, 0);
|
|
assert(-1 != sockClient);
|
|
#endif
|
|
|
|
#if defined(HG_CMP_MSC)
|
|
u_long ul = 1; // 设为非阻塞
|
|
ioctlsocket(sockClient, FIONBIO, &ul);
|
|
#else
|
|
ioctl(sockClient, FIONBIO, 1);
|
|
#endif
|
|
|
|
#if defined(HG_CMP_MSC)
|
|
SOCKADDR_IN addrServer = { 0 };
|
|
addrServer.sin_addr.S_un.S_addr = inet_addr(addr.c_str());
|
|
addrServer.sin_family = AF_INET;
|
|
addrServer.sin_port = htons(port);
|
|
if (0 != connect(sockClient, (SOCKADDR*)&addrServer, sizeof(SOCKADDR_IN)))
|
|
#else
|
|
struct sockaddr_in addrServer = { 0 };
|
|
addrServer.sin_addr.s_addr = inet_addr(addr.c_str());
|
|
addrServer.sin_family = AF_INET;
|
|
addrServer.sin_port = htons(port);
|
|
if (0 != connect(sockClient, (struct sockaddr*)&addrServer, sizeof(addrServer)))
|
|
#endif
|
|
{
|
|
fd_set fds;
|
|
FD_ZERO(&fds);
|
|
FD_SET(sockClient, &fds);
|
|
timeval tm;
|
|
tm.tv_sec = 1;
|
|
tm.tv_usec = 0;
|
|
|
|
if (select((int)(sockClient + 1), NULL, &fds, NULL, &tm) <= 0)
|
|
{
|
|
#if defined(HG_CMP_MSC)
|
|
closesocket(sockClient);
|
|
#else
|
|
close(sockClient);
|
|
#endif
|
|
delete[] fileData;
|
|
return false;
|
|
}
|
|
|
|
if (!FD_ISSET(sockClient, &fds))
|
|
{
|
|
#if defined(HG_CMP_MSC)
|
|
closesocket(sockClient);
|
|
#else
|
|
close(sockClient);
|
|
#endif
|
|
delete[] fileData;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
#if defined(HG_CMP_MSC)
|
|
ul = 0; // 设为阻塞
|
|
ioctlsocket(sockClient, FIONBIO, &ul);
|
|
#else
|
|
ioctl(sockClient, FIONBIO, 0);
|
|
#endif
|
|
|
|
char remoteName[256];
|
|
HGBase_GetFileName(localFileName.c_str(), remoteName, 256);
|
|
|
|
bool ret = false;
|
|
|
|
const char* pszBoundary = "---------------------------7d33a816d302b6";
|
|
|
|
std::string strPreFileData = MakePreFileData(pszBoundary, remoteName);
|
|
std::string strPostFileData = MakePostFileData(pszBoundary);
|
|
|
|
char hostname[128];
|
|
gethostname(hostname, 128);
|
|
|
|
std::string head;
|
|
char data[512];
|
|
sprintf(data, "POST %s HTTP/1.1\r\nHost: %s\r\n", path.c_str(), hostname);
|
|
head += data;
|
|
sprintf(data, "Content-Type: multipart/form-data; boundary=%s\r\n", pszBoundary);
|
|
head += data;
|
|
sprintf(data, "Content-Length: %d\r\n\r\n", (int)strPreFileData.size() + (int)fileSize + (int)strPostFileData.size());
|
|
head += data;
|
|
|
|
send(sockClient, head.c_str(), (int)head.size(), 0);
|
|
send(sockClient, strPreFileData.c_str(), (int)strPreFileData.size(), 0);
|
|
send(sockClient, (const char *)fileData, (int)fileSize, 0);
|
|
send(sockClient, strPostFileData.c_str(), (int)strPostFileData.size(), 0);
|
|
|
|
char recvBuf[2048] = {0};
|
|
recv(sockClient, recvBuf, 2048, 0);
|
|
|
|
std::string strRecv(recvBuf);
|
|
std::string::size_type pos = strRecv.find("\r\n");
|
|
if (pos != std::string::npos)
|
|
{
|
|
std::string head = strRecv.substr(0, pos);
|
|
if (head.find("200") != std::string::npos)
|
|
{
|
|
ret = true;
|
|
}
|
|
}
|
|
|
|
#if defined(HG_CMP_MSC)
|
|
closesocket(sockClient);
|
|
#else
|
|
close(sockClient);
|
|
#endif
|
|
delete[] fileData;
|
|
return ret;
|
|
}
|
|
|
|
static size_t read_callback(char* ptr, size_t size, size_t nmemb, void* stream)
|
|
{
|
|
unsigned long nread;
|
|
/* in real-world cases, this would probably get this data differently
|
|
as this fread() stuff is exactly what the library already would do
|
|
by default internally */
|
|
size_t retcode = fread(ptr, size, nmemb, (FILE*)stream);
|
|
|
|
if (retcode > 0)
|
|
{
|
|
nread = (unsigned long)retcode;
|
|
//fprintf(stderr, "*** We read %lu bytes from file\n", nread);
|
|
}
|
|
|
|
return retcode;
|
|
}
|
|
|
|
bool Manager::FTPUpload(const std::string& localFileName, const std::string& ftpUrl, int ftpPort, const std::string& ftpPath,
|
|
const std::string& ftpUser, const std::string& ftpPassword, int ftpMode)
|
|
{
|
|
FILE* file = fopen(localFileName.c_str(), "rb");
|
|
if (NULL == file)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
bool ret = false;
|
|
fseek(file, 0, SEEK_END);
|
|
long fsize = ftell(file);
|
|
fseek(file, 0, SEEK_SET);
|
|
|
|
curl_global_init(CURL_GLOBAL_ALL);
|
|
|
|
/* get a curl handle */
|
|
CURL *curl = curl_easy_init();
|
|
if (NULL != curl)
|
|
{
|
|
char tmpName[256];
|
|
HGBase_GetUuid(tmpName, 256);
|
|
char remoteName[256];
|
|
HGBase_GetFileName(localFileName.c_str(), remoteName, 256);
|
|
|
|
char ftp_rnfr[512];
|
|
sprintf(ftp_rnfr, "RNFR %s", tmpName);
|
|
char ftp_rnto[512];
|
|
sprintf(ftp_rnto, "RNTO %s", remoteName);
|
|
|
|
struct curl_slist* headerlist = NULL;
|
|
headerlist = curl_slist_append(headerlist, ftp_rnfr);
|
|
headerlist = curl_slist_append(headerlist, ftp_rnto);
|
|
|
|
/* we want to use our own read function */
|
|
curl_easy_setopt(curl, CURLOPT_READFUNCTION, read_callback);
|
|
|
|
curl_easy_setopt(curl, CURLOPT_UPLOAD, 1L);
|
|
|
|
char url[512];
|
|
if (!ftpUser.empty() && !ftpPassword.empty())
|
|
{
|
|
sprintf(url, "ftp://%s:%s@%s:%d%s/%s", ftpUser.c_str(), ftpPassword.c_str(),
|
|
ftpUrl.c_str(), ftpPort, ftpPath.c_str(), tmpName);
|
|
}
|
|
else
|
|
{
|
|
sprintf(url, "ftp://%s:%d%s/%s", ftpUrl.c_str(), ftpPort, ftpPath.c_str(), tmpName);
|
|
}
|
|
curl_easy_setopt(curl, CURLOPT_URL, url);
|
|
|
|
curl_easy_setopt(curl, CURLOPT_FTP_CREATE_MISSING_DIRS, 1);
|
|
|
|
/* pass in that last of FTP commands to run after the transfer */
|
|
curl_easy_setopt(curl, CURLOPT_POSTQUOTE, headerlist);
|
|
|
|
/* now specify which file to upload */
|
|
curl_easy_setopt(curl, CURLOPT_READDATA, file);
|
|
|
|
/* Set the size of the file to upload (optional). If you give a *_LARGE
|
|
option you MUST make sure that the type of the passed-in argument is a
|
|
curl_off_t. If you use CURLOPT_INFILESIZE (without _LARGE) you must
|
|
make sure that to pass in a type 'long' argument. */
|
|
curl_easy_setopt(curl, CURLOPT_INFILESIZE_LARGE, (curl_off_t)fsize);
|
|
|
|
/* Now run off and do what you have been told! */
|
|
CURLcode res = curl_easy_perform(curl);
|
|
/* Check for errors */
|
|
if (res != CURLE_OK)
|
|
fprintf(stderr, "curl_easy_perform() failed: %s\n", curl_easy_strerror(res));
|
|
else
|
|
ret = true;
|
|
|
|
/* clean up the FTP commands list */
|
|
curl_slist_free_all(headerlist);
|
|
|
|
/* always cleanup */
|
|
curl_easy_cleanup(curl);
|
|
}
|
|
fclose(file); /* close the local file */
|
|
|
|
curl_global_cleanup();
|
|
return ret;
|
|
}
|
|
|
|
int Manager::sane_ex_callback(SANE_Handle hdev, int code, void* data, unsigned int* len, void* param)
|
|
{
|
|
(void)hdev;
|
|
(void)len;
|
|
|
|
Manager* p = (Manager*)param;
|
|
switch (code)
|
|
{
|
|
case SANE_EVENT_DEVICE_ARRIVED:
|
|
{
|
|
SANE_Device* sane_dev = (SANE_Device*)data;
|
|
HGBase_WriteInfo(HGBASE_INFOTYPE_DESC, "device arrive, name=%s", Utf8ToStdString(sane_dev->name).c_str());
|
|
|
|
HGBase_EnterLock(p->m_lock);
|
|
if (NULL != p->m_scanEvent)
|
|
p->m_scanEvent(SCANEVENT_ARRIVE, (void*)sane_dev->name, (void*)0, p->m_scanParam);
|
|
HGBase_LeaveLock(p->m_lock);
|
|
|
|
OpenDevParam* openDevParam = new OpenDevParam;
|
|
openDevParam->devName = sane_dev->name;
|
|
|
|
WebMsg msg;
|
|
msg.msgId = WEB_MSGID_OPENDEV;
|
|
msg.svrType = 0;
|
|
msg.usrId = 0;
|
|
msg.param = openDevParam;
|
|
bool b = p->m_loop->Send(&msg);
|
|
if (!b)
|
|
{
|
|
delete openDevParam;
|
|
}
|
|
}
|
|
break;
|
|
case SANE_EVENT_DEVICE_LEFT:
|
|
{
|
|
SANE_Device* sane_dev = (SANE_Device*)data;
|
|
HGBase_WriteInfo(HGBASE_INFOTYPE_DESC, "device remove, name=%s", Utf8ToStdString(sane_dev->name).c_str());
|
|
|
|
HGBase_EnterLock(p->m_lock);
|
|
if (NULL != p->m_scanEvent)
|
|
p->m_scanEvent(SCANEVENT_REMOVE, (void*)sane_dev->name, (void*)0, p->m_scanParam);
|
|
HGBase_LeaveLock(p->m_lock);
|
|
|
|
CloseDevParam* closeDevParam = new CloseDevParam;
|
|
closeDevParam->devName = sane_dev->name;
|
|
|
|
WebMsg msg;
|
|
msg.msgId = WEB_MSGID_CLOSEDEV;
|
|
msg.svrType = 0;
|
|
msg.usrId = 0;
|
|
msg.param = closeDevParam;
|
|
bool b = p->m_loop->Send(&msg);
|
|
if (!b)
|
|
{
|
|
delete closeDevParam;
|
|
}
|
|
}
|
|
break;
|
|
case SANE_EVENT_STATUS:
|
|
{
|
|
HGBase_WriteInfo(HGBASE_INFOTYPE_DESC, "SANE_EVENT_STATUS, msg=%s", Utf8ToStdString((char *)data).c_str());
|
|
|
|
HGBase_EnterLock(p->m_lock);
|
|
if (NULL != p->m_scanEvent)
|
|
p->m_scanEvent(SCANEVENT_STATUS, (void*)data, (void*)0, p->m_scanParam);
|
|
HGBase_LeaveLock(p->m_lock);
|
|
}
|
|
break;
|
|
case SANE_EVENT_ERROR:
|
|
{
|
|
HGBase_WriteInfo(HGBASE_INFOTYPE_DESC, "SANE_EVENT_ERROR, msg=%s", Utf8ToStdString((char*)data).c_str());
|
|
|
|
HGBase_EnterLock(p->m_lock);
|
|
if (NULL != p->m_scanEvent)
|
|
p->m_scanEvent(SCANEVENT_ERROR, (void *)data, (void*)0, p->m_scanParam);
|
|
HGBase_LeaveLock(p->m_lock);
|
|
}
|
|
break;
|
|
case SANE_EVENT_WORKING:
|
|
{
|
|
HGBase_WriteInfo(HGBASE_INFOTYPE_DESC, "SANE_EVENT_WORKING, msg=%s", Utf8ToStdString((char*)data).c_str());
|
|
|
|
HGBase_EnterLock(p->m_lock);
|
|
if (NULL != p->m_scanEvent)
|
|
p->m_scanEvent(SCANEVENT_WORKING, (void*)data, (void*)0, p->m_scanParam);
|
|
HGBase_LeaveLock(p->m_lock);
|
|
}
|
|
break;
|
|
case SANE_EVENT_IMAGE_OK:
|
|
{
|
|
HGBase_WriteInfo(HGBASE_INFOTYPE_DESC, "SANE_EVENT_IMAGE_OK");
|
|
|
|
SANE_Image* sane_img = (SANE_Image*)data;
|
|
|
|
HGUInt imgType = 0;
|
|
if (sane_img->header.format == SANE_FRAME_GRAY)
|
|
imgType = HGBASE_IMGTYPE_GRAY;
|
|
else if (sane_img->header.format == SANE_FRAME_RGB)
|
|
imgType = HGBASE_IMGTYPE_RGB;
|
|
|
|
HGByte* data = sane_img->data;
|
|
HGImageInfo imgInfo = { (HGUInt)sane_img->header.pixels_per_line, (HGUInt)sane_img->header.lines,
|
|
imgType, (HGUInt)sane_img->header.bytes_per_line, HGBASE_IMGORIGIN_TOP };
|
|
|
|
HGImage img = NULL;
|
|
HGBase_CreateImageFromData(data, &imgInfo, nullptr, HGBASE_IMGTYPE_RGB, HGBASE_IMGORIGIN_TOP, &img);
|
|
if (NULL != img)
|
|
{
|
|
std::string filePath = GetFilePath(p->m_devName);
|
|
std::vector<std::string> fileNameList = GetFileNameList(p->m_devName);
|
|
|
|
int maxIndex = 0;
|
|
for (int i = 0; i < (int)fileNameList.size(); ++i)
|
|
{
|
|
int index = atoi(fileNameList[i].c_str());
|
|
if (index > maxIndex)
|
|
maxIndex = index;
|
|
}
|
|
|
|
HGChar name[256];
|
|
sprintf(name, "%d.%s", maxIndex + 1, p->m_devParam.format.c_str());
|
|
std::string imgName = name;
|
|
|
|
HGBase_CreateDir(filePath.c_str());
|
|
std::string fileName = filePath + imgName;
|
|
HGImgFmt_SaveImage(img, 0, NULL, 0, fileName.c_str());
|
|
|
|
if (0 == p->m_devParam.uploadMode) // HTTP
|
|
{
|
|
HTTPUpload(fileName, p->m_devParam.httpUrl, p->m_devParam.fileName, p->m_devParam.httpMethod,
|
|
p->m_devParam.header, p->m_devParam.param);
|
|
}
|
|
else if (1 == p->m_devParam.uploadMode) // FTP
|
|
{
|
|
FTPUpload(fileName, p->m_devParam.ftpUrl, p->m_devParam.ftpPort, p->m_devParam.ftpPath,
|
|
p->m_devParam.ftpUser, p->m_devParam.ftpPassword, p->m_devParam.ftpMode);
|
|
}
|
|
|
|
if (p->m_scanIsInsert)
|
|
{
|
|
int index = -1;
|
|
for (int i = 0; i < (int)fileNameList.size(); ++i)
|
|
{
|
|
if (fileNameList[i] == p->m_scanInsertImgName)
|
|
{
|
|
index = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (-1 != index)
|
|
{
|
|
fileNameList.insert(fileNameList.begin() + index, imgName);
|
|
}
|
|
else
|
|
{
|
|
fileNameList.push_back(imgName);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
fileNameList.push_back(imgName);
|
|
}
|
|
|
|
SaveFileNameList(p->m_devName, fileNameList);
|
|
|
|
std::string imgBase64 = "data:image/jpeg;base64,";
|
|
imgBase64 += GetBase64(img, 0);
|
|
|
|
HGBase_EnterLock(p->m_lock);
|
|
if (NULL != p->m_scanEvent)
|
|
p->m_scanEvent(SCANEVENT_IMAGE, (void*)imgName.c_str(), (void *)imgBase64.c_str(), p->m_scanParam);
|
|
HGBase_LeaveLock(p->m_lock);
|
|
|
|
HGBase_DestroyImage(img);
|
|
}
|
|
}
|
|
break;
|
|
case SANE_EVENT_SCAN_FINISHED:
|
|
{
|
|
HGBase_WriteInfo(HGBASE_INFOTYPE_DESC, "SANE_EVENT_SCAN_FINISHED, msg=%s", Utf8ToStdString((char*)data).c_str());
|
|
|
|
HGBase_EnterLock(p->m_lock);
|
|
if (NULL != p->m_scanEvent)
|
|
p->m_scanEvent(SCANEVENT_FINISH, (void*)data, (void*)0, p->m_scanParam);
|
|
HGBase_LeaveLock(p->m_lock);
|
|
|
|
WebMsg msg;
|
|
msg.msgId = WEB_MSGID_SCANFINISH;
|
|
msg.svrType = 0;
|
|
msg.usrId = 0;
|
|
msg.param = NULL;
|
|
p->m_loop->Send(&msg);
|
|
}
|
|
break;
|
|
}
|
|
|
|
return 0;
|
|
}
|