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

2122 lines
54 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& 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);
}
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;
std::string filePath = GetFilePath(m_devName);
std::string cfgPath = filePath + "config.ini";
m_devParam.Load(cfgPath);
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");
}
}
std::string filePath = GetFilePath(m_devName);
std::string cfgPath = filePath + "config.ini";
m_devParam.Save(cfgPath);
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;
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 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;
}
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 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)
{
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 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);
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 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