lmh188
/
code_app
mirror of http://192.168.10.5:8099/sane/code_app.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
code_app/sdk/webservice/ManagerV1.cpp

1926 lines
50 KiB
C++
Raw Blame History

#include "ManagerV1.h"
#include "base/HGBuffer.h"
#include "base/HGBase64.h"
#include "base/HGUtility.h"
#include "base/HGIni.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 "HGString.h"
extern "C"
{
#include "zip.h"
};
#include <curl/curl.h>
#include <list>
#include <algorithm>
namespace ver_1
{
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& devName)
{
HGChar cfgPath[256];
HGBase_GetConfigPath(cfgPath, 256);
strcat(cfgPath, "config1.ini");
HGInt intValue;
HGChar strValue[256];
HGBase_GetProfileString(cfgPath, Utf8ToStdString(devName).c_str(), "device", "", strValue, 256);
device = strValue;
HGBase_GetProfileInt(cfgPath, Utf8ToStdString(devName).c_str(), "autofeeder", 1, &intValue);
autofeeder = (bool)intValue;
HGBase_GetProfileInt(cfgPath, Utf8ToStdString(devName).c_str(), "pixel", 1, &intValue);
pixel = intValue;
HGBase_GetProfileInt(cfgPath, Utf8ToStdString(devName).c_str(), "white", 0, &intValue);
white = (bool)intValue;
HGBase_GetProfileInt(cfgPath, Utf8ToStdString(devName).c_str(), "discardBlankThre", 5, &intValue);
discardBlankThre = intValue;
HGBase_GetProfileInt(cfgPath, Utf8ToStdString(devName).c_str(), "single", 0, &intValue);
single = (bool)intValue;
HGBase_GetProfileString(cfgPath, Utf8ToStdString(devName).c_str(), "format", "jpg", strValue, 256);
format = strValue;
HGBase_GetProfileInt(cfgPath, Utf8ToStdString(devName).c_str(), "resolution", 200, &intValue);
resolution = intValue;
HGBase_GetProfileInt(cfgPath, Utf8ToStdString(devName).c_str(), "orentation", 0, &intValue);
orentation = intValue;
HGBase_GetProfileString(cfgPath, Utf8ToStdString(devName).c_str(), "paperType", "Auto", strValue, 256);
paperType = strValue;
HGBase_GetProfileInt(cfgPath, Utf8ToStdString(devName).c_str(), "splitImage", 0, &intValue);
splitImage = intValue;
HGBase_GetProfileInt(cfgPath, Utf8ToStdString(devName).c_str(), "noiseDetachEnable”", 1, &intValue);
noiseDetachEnable = (bool)intValue;
HGBase_GetProfileInt(cfgPath, Utf8ToStdString(devName).c_str(), "noiseDetach", 15, &intValue);
noiseDetach = intValue;
HGBase_GetProfileInt(cfgPath, Utf8ToStdString(devName).c_str(), "uploadMode", 2, &intValue);
uploadMode = intValue;
HGBase_GetProfileString(cfgPath, Utf8ToStdString(devName).c_str(), "httpUrl", "", strValue, 256);
httpUrl = strValue;
HGBase_GetProfileString(cfgPath, Utf8ToStdString(devName).c_str(), "fileName", "", strValue, 256);
fileName = strValue;
HGBase_GetProfileString(cfgPath, Utf8ToStdString(devName).c_str(), "httpMethod", "", strValue, 256);
httpMethod = strValue;
HGBase_GetProfileString(cfgPath, Utf8ToStdString(devName).c_str(), "header", "", strValue, 256);
header = strValue;
HGBase_GetProfileString(cfgPath, Utf8ToStdString(devName).c_str(), "param", "", strValue, 256);
param = strValue;
HGBase_GetProfileString(cfgPath, Utf8ToStdString(devName).c_str(), "ftpUrl", "", strValue, 256);
ftpUrl = strValue;
HGBase_GetProfileString(cfgPath, Utf8ToStdString(devName).c_str(), "ftpPath", "", strValue, 256);
ftpPath = strValue;
HGBase_GetProfileString(cfgPath, Utf8ToStdString(devName).c_str(), "ftpUser", "", strValue, 256);
ftpUser = strValue;
HGBase_GetProfileString(cfgPath, Utf8ToStdString(devName).c_str(), "ftpPassword", "", strValue, 256);
ftpPassword = strValue;
HGBase_GetProfileInt(cfgPath, Utf8ToStdString(devName).c_str(), "ftpPort", 21, &intValue);
ftpPort = intValue;
HGBase_GetProfileInt(cfgPath, Utf8ToStdString(devName).c_str(), "ftpMode", 2, &intValue);
ftpMode = intValue;
}
void DevParam::Save(const std::string& devName)
{
HGChar cfgPath[256];
HGBase_GetConfigPath(cfgPath, 256);
HGBase_CreateDir(cfgPath);
strcat(cfgPath, "config1.ini");
HGBase_SetProfileString(cfgPath, devName.c_str(), "device", device.c_str());
HGBase_SetProfileInt(cfgPath, devName.c_str(), "autofeeder", autofeeder);
HGBase_SetProfileInt(cfgPath, devName.c_str(), "pixel", pixel);
HGBase_SetProfileInt(cfgPath, devName.c_str(), "white", white);
HGBase_SetProfileInt(cfgPath, devName.c_str(), "discardBlankThre", discardBlankThre);
HGBase_SetProfileInt(cfgPath, devName.c_str(), "single", single);
HGBase_SetProfileString(cfgPath, devName.c_str(), "format", format.c_str());
HGBase_SetProfileInt(cfgPath, devName.c_str(), "resolution", resolution);
HGBase_SetProfileInt(cfgPath, devName.c_str(), "orentation", orentation);
HGBase_SetProfileString(cfgPath, devName.c_str(), "paperType", paperType.c_str());
HGBase_SetProfileInt(cfgPath, devName.c_str(), "splitImage", splitImage);
HGBase_SetProfileInt(cfgPath, devName.c_str(), "noiseDetachEnable", noiseDetachEnable);
HGBase_SetProfileInt(cfgPath, devName.c_str(), "noiseDetach", noiseDetach);
HGBase_SetProfileInt(cfgPath, devName.c_str(), "uploadMode", uploadMode);
HGBase_SetProfileString(cfgPath, devName.c_str(), "httpUrl", httpUrl.c_str());
HGBase_SetProfileString(cfgPath, devName.c_str(), "fileName", fileName.c_str());
HGBase_SetProfileString(cfgPath, devName.c_str(), "httpMethod", httpMethod.c_str());
HGBase_SetProfileString(cfgPath, devName.c_str(), "header", header.c_str());
HGBase_SetProfileString(cfgPath, devName.c_str(), "param", param.c_str());
HGBase_SetProfileString(cfgPath, devName.c_str(), "ftpUrl", ftpUrl.c_str());
HGBase_SetProfileString(cfgPath, devName.c_str(), "ftpPath", ftpPath.c_str());
HGBase_SetProfileString(cfgPath, devName.c_str(), "ftpUser", ftpUser.c_str());
HGBase_SetProfileString(cfgPath, devName.c_str(), "ftpPassword", ftpPassword.c_str());
HGBase_SetProfileInt(cfgPath, devName.c_str(), "ftpPort", ftpPort);
HGBase_SetProfileInt(cfgPath, devName.c_str(), "ftpMode", ftpMode);
}
ManagerV1::ManagerV1(HGMsgPump msgPump)
: Manager(msgPump)
{
HGBase_CreateLock(&m_lock);
m_devName.clear();
m_devHandle = NULL;
m_saneEvent = NULL;
m_saneParam = NULL;
m_saneImageCallback = NULL;
m_saneImageParam = NULL;
m_scanInsertImgName.clear();
m_scanIsInsert = false;
m_scanning = false;
m_scanEvent = NULL;
SANE_Int version_code = 0;
SANE_Status status = sane_init_ex(&version_code, sane_ex_callback, this);
assert(SANE_STATUS_GOOD == status);
}
ManagerV1::~ManagerV1()
{
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 ManagerV1::OpenDev(const OpenDevParam* param)
{
assert(NULL != param && this == param->mgr);
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;
m_devParam.Load(m_devName);
SetDevParam(m_devName, m_devParam);
}
}
void ManagerV1::CloseDev(const CloseDevParam* param)
{
assert(NULL != param && this == param->mgr);
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 ManagerV1::ScanFinish(const ScanFinishParam* param)
{
assert(NULL != param && this == param->mgr);
StopScan();
}
void ManagerV1::SetSaneEvent(SaneEvent event, void* param)
{
assert(NULL != event && NULL != param);
HGBase_EnterLock(m_lock);
m_saneEvent = event;
m_saneParam = param;
HGBase_LeaveLock(m_lock);
}
void ManagerV1::SetSaneImageCallback(SaneImageCallback func, void* param)
{
assert(NULL != func && NULL != param);
HGBase_EnterLock(m_lock);
m_saneImageCallback = func;
m_saneImageParam = param;
HGBase_LeaveLock(m_lock);
}
void ManagerV1::ResetSaneEvent()
{
HGBase_EnterLock(m_lock);
m_saneEvent = NULL;
m_saneParam = NULL;
HGBase_LeaveLock(m_lock);
}
void ManagerV1::ResetSaneImageCallback()
{
HGBase_EnterLock(m_lock);
m_saneImageCallback = NULL;
m_saneImageParam = NULL;
HGBase_LeaveLock(m_lock);
}
bool ManagerV1::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;
HGBase_CreateEvent(HGFALSE, HGFALSE, &m_scanEvent);
assert(NULL != m_scanEvent);
if (SANE_STATUS_GOOD == sane_start(m_devHandle))
{
m_scanning = true;
ret = true;
}
else
{
HGBase_DestroyEvent(m_scanEvent);
m_scanEvent = NULL;
m_scanInsertImgName.clear();
m_scanIsInsert = false;
}
}
return ret;
}
bool ManagerV1::StopScan()
{
if (m_scanning)
{
assert(NULL != m_devHandle);
sane_cancel(m_devHandle);
assert(NULL != m_scanEvent);
HGBase_WaitEvent(m_scanEvent);
HGBase_DestroyEvent(m_scanEvent);
m_scanEvent = NULL;
m_scanInsertImgName.clear();
m_scanIsInsert = false;
m_scanning = false;
}
return true;
}
bool ManagerV1::GetCurDevId(std::string& devId)
{
devId.clear();
if (m_scanning)
{
return false;
}
devId = m_devName;
return true;
}
bool ManagerV1::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 ManagerV1::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);
imgNameList.push_back(fileNameList[i]);
imgBase64List.push_back(imgBase64);
HGBase_DestroyImage(img);
}
}
SaveFileNameList(devId, imgNameList);
return true;
}
bool ManagerV1::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");
}
}
m_devParam.Save(m_devName);
ret = true;
}
devParam = m_devParam;
return ret;
}
bool ManagerV1::SetDevParam(const std::string& devId, const DevParam& devParam)
{
if (m_scanning)
{
return false;
}
m_devParam = devParam;
m_devParam.Save(m_devName);
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 ManagerV1::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 ManagerV1::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))
ret = true;
HGBase_DestroyImage(img);
}
}
HGImgFmt_CloseOfdImageWriter(writer);
if (!ret)
{
HGBase_DeleteFile(fileName.c_str());
return false;
}
return true;
}
bool ManagerV1::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(NULL, tmpFileName, 512);
ExportOfdFile(devId, isAuto, tmpFileName);
*data = GetBuffer(tmpFileName, size);
HGBase_DeleteFile(tmpFileName);
return (NULL != *data);
}
bool ManagerV1::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 ManagerV1::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))
ret = true;
HGBase_DestroyImage(img);
}
}
HGImgFmt_ClosePdfImageWriter(writer);
if (!ret)
{
HGBase_DeleteFile(fileName.c_str());
return false;
}
return true;
}
bool ManagerV1::ExportPdfFile(const std::string& devId, HGByte** data, HGUInt* size)
{
*data = NULL;
*size = 0;
if (m_scanning)
{
return false;
}
HGChar tmpFileName[512];
HGBase_GetTmpFileName(NULL, tmpFileName, 512);
ExportPdfFile(devId, tmpFileName);
*data = GetBuffer(tmpFileName, size);
HGBase_DeleteFile(tmpFileName);
return (NULL != *data);
}
bool ManagerV1::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 ManagerV1::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 ManagerV1::ExportTiffFile(const std::string& devId, HGByte** data, HGUInt* size)
{
*data = NULL;
*size = 0;
if (m_scanning)
{
return false;
}
HGChar tmpFileName[512];
HGBase_GetTmpFileName(NULL, tmpFileName, 512);
ExportTiff(devId, tmpFileName);
*data = GetBuffer(tmpFileName, size);
HGBase_DeleteFile(tmpFileName);
return (NULL != *data);
}
bool ManagerV1::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 ManagerV1::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(), 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(), 0, 0);
if (NULL != s)
{
if (zip_file_add(z, StdStringToUtf8(fileNameList[i]).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 ManagerV1::ExportZipFile(const std::string& devId, HGByte** data, HGUInt* size)
{
*data = NULL;
*size = 0;
if (m_scanning)
{
return false;
}
HGChar tmpFileName[512];
HGBase_GetTmpFileName(NULL, tmpFileName, 512);
ExportZipFile(devId, tmpFileName);
*data = GetBuffer(tmpFileName, size);
HGBase_DeleteFile(tmpFileName);
return (NULL != *data);
}
bool ManagerV1::UploadImage(const UploadParam& uploadParam)
{
if (m_scanning)
{
return false;
}
std::string devId;
GetCurDevId(devId);
HGChar tmpFileName[512];
HGBase_GetTmpFileName(NULL, 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 ManagerV1::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 ManagerV1::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 ManagerV1::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 ManagerV1::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, fileName.c_str());
fileNameList.push_back(imgName);
SaveFileNameList(devId, fileNameList);
imgBase64 = "data:image/jpeg;base64,";
imgBase64 += GetBase64(img);
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 ManagerV1::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 ManagerV1::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 ManagerV1::GetLastBetch(std::string& devId)
{
devId.clear();
if (m_scanning)
{
return false;
}
devId = m_devName;
return true;
}
bool ManagerV1::ResetPatchIndex()
{
if (m_scanning)
{
return false;
}
return true;
}
bool ManagerV1::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, fileName.c_str());
fileNameList.push_back(imgName);
SaveFileNameList(devId, fileNameList);
std::string imgBase64 = "data:image/jpeg;base64,";
imgBase64 += GetBase64(newImg);
if (0 == i)
{
imgName1 = imgName;
imgBase64_1 = imgBase64;
}
else
{
imgName2 = imgName;
imgBase64_2 = imgBase64;
}
HGBase_DestroyImage(newImg);
}
}
HGBase_DestroyImage(img);
}
return true;
}
bool ManagerV1::GetDevSerialNo(const std::string& devId, std::string& serialNo)
{
serialNo.clear();
if (m_scanning)
{
return false;
}
serialNo = devId;
return true;
}
bool ManagerV1::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);
HGBase_DestroyImage(img);
}
return true;
}
std::string ManagerV1::GetFilePath(const std::string& devId)
{
HGChar docsPath[256];
HGBase_GetDocumentsPath(docsPath, 256);
HGChar procName[256];
HGBase_GetProcessName(procName, 256);
HGChar imgPath[512];
sprintf(imgPath, "%s%s/%s/", docsPath, procName, Utf8ToStdString(devId).c_str());
HGChar stdImgPath[512];
HGBase_StandardiseFileName(imgPath, stdImgPath, 512);
return stdImgPath;
}
std::vector<std::string> ManagerV1::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 ManagerV1::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 ManagerV1::GetBase64(HGImage image)
{
std::string strBase64;
if (NULL != image)
{
HGBuffer buffer = NULL;
HGImgFmt_SaveJpegImageToBuffer(image, NULL, &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 ManagerV1::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 ManagerV1::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* ManagerV1::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 ManagerV1::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;
}
bool ManagerV1::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)
{
bool ret = false;
CURL* curl = curl_easy_init();
if (NULL != curl)
{
struct curl_httppost* formpost = NULL;
struct curl_httppost* lastptr = NULL;
curl_formadd(&formpost, &lastptr, CURLFORM_COPYNAME, "filename", CURLFORM_FILE, localFileName.c_str(), CURLFORM_END);
curl_formadd(&formpost, &lastptr, CURLFORM_COPYNAME, "remote_filename", CURLFORM_COPYCONTENTS, remoteFileName.c_str(), CURLFORM_END);
curl_formadd(&formpost, &lastptr, CURLFORM_COPYNAME, "submit", CURLFORM_COPYCONTENTS, "Submit", CURLFORM_END);
curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 2);
curl_easy_setopt(curl, CURLOPT_URL, httpUrl.c_str());
curl_easy_setopt(curl, CURLOPT_HTTPPOST, formpost);
/* Perform the request, res will get the return code */
CURLcode res = curl_easy_perform(curl);
/* Check for errors */
if (res != CURLE_OK)
fprintf(stderr, "curl_easy_perform() failed: %s", curl_easy_strerror(res));
else
ret = true;
/* then cleanup the formpost chain */
curl_formfree(formpost);
/* always cleanup */
curl_easy_cleanup(curl);
}
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 ManagerV1::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);
/* get a curl handle */
CURL* curl = curl_easy_init();
if (NULL != curl)
{
char remoteName[256];
HGBase_GetFileName(localFileName.c_str(), remoteName, 256);
/* 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(), remoteName);
}
else
{
sprintf(url, "ftp://%s:%d%s/%s", ftpUrl.c_str(), ftpPort, ftpPath.c_str(), remoteName);
}
curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 2);
curl_easy_setopt(curl, CURLOPT_URL, url);
curl_easy_setopt(curl, CURLOPT_FTP_CREATE_MISSING_DIRS, 1);
/* 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;
/* always cleanup */
curl_easy_cleanup(curl);
}
fclose(file); /* close the local file */
return ret;
}
int ManagerV1::sane_ex_callback(SANE_Handle hdev, int code, void* data, unsigned int* len, void* param)
{
(void)hdev;
(void)len;
ManagerV1* p = (ManagerV1*)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());
OpenDevParam* openDevParam = new OpenDevParam;
openDevParam->mgr = p;
openDevParam->devName = sane_dev->name;
HGMsg msg;
msg.id = MSGID_OPEN_DEVICE;
msg.data = openDevParam;
if (HGBASE_ERR_OK != HGBase_PostPumpMessage(p->m_msgPump, &msg))
{
delete openDevParam;
}
HGBase_EnterLock(p->m_lock);
if (NULL != p->m_saneEvent)
p->m_saneEvent(SANEEVENT_ARRIVE, sane_dev->name, false, p->m_saneParam);
HGBase_LeaveLock(p->m_lock);
}
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());
CloseDevParam* closeDevParam = new CloseDevParam;
closeDevParam->mgr = p;
closeDevParam->devName = sane_dev->name;
HGMsg msg;
msg.id = MSGID_CLOSE_DEVICE;
msg.data = closeDevParam;
if (HGBASE_ERR_OK != HGBase_PostPumpMessage(p->m_msgPump, &msg))
{
delete closeDevParam;
}
HGBase_EnterLock(p->m_lock);
if (NULL != p->m_saneEvent)
p->m_saneEvent(SANEEVENT_REMOVE, sane_dev->name, false, p->m_saneParam);
HGBase_LeaveLock(p->m_lock);
}
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_saneEvent)
p->m_saneEvent(SANEEVENT_STATUS, (const char*)data, false, p->m_saneParam);
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_saneEvent)
p->m_saneEvent(SANEEVENT_ERROR, (const char*)data, (0 != *len), p->m_saneParam);
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_saneEvent)
p->m_saneEvent(SANEEVENT_WORKING, (const char*)data, false, p->m_saneParam);
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, NULL, 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, 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);
HGBase_EnterLock(p->m_lock);
if (NULL != p->m_saneImageCallback)
p->m_saneImageCallback(imgName.c_str(), imgBase64.c_str(), p->m_saneImageParam);
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_SetEvent(p->m_scanEvent);
ScanFinishParam* scanFinishParam = new ScanFinishParam;
scanFinishParam->mgr = p;
HGMsg msg;
msg.id = MSGID_SCAN_FINISH;
msg.data = scanFinishParam;
if (HGBASE_ERR_OK != HGBase_PostPumpMessage(p->m_msgPump, &msg))
{
delete scanFinishParam;
}
HGBase_EnterLock(p->m_lock);
if (NULL != p->m_saneEvent)
p->m_saneEvent(SANEEVENT_FINISH, (const char*)data, (0 != *len), p->m_saneParam);
HGBase_LeaveLock(p->m_lock);
}
break;
}
return 0;
}
}
Reference in New Issue View Git Blame Copy Permalink