code_device/hgdriver/wrapper/huagaoxxx_warraper_ex.cpp

#include "../../sdk/hginclude/huagaoxxx_warraper_ex.h"

#include "../../../sdk/include/huagao/brand.h"
#include "../../sdk/hginclude/utils.h"
#include "../hgdev/scanner_manager.h"
#include <iostream>

#include <lang/app_language.h>
#include "../hgdev/common_setting.h"

#if defined(WIN32) || defined(_WIN64)
#include <fileapi.h>
#else
#include <sys/vfs.h>
#include <string.h>
#endif
#include <math.h>


#define MAKE_VERSION(a, b, c, d)	\
	((((unsigned long long)(a) & 0x0ffff) << 48)			\
	| (((unsigned long long)(b) & 0x0ffff) << 32)			\
	| (((unsigned long long)(c) & 0x0ffff) << 16)			\
	| (((unsigned long long)(d) & 0x0ffff) << 0))

std::string g_scanner_path = "";
static std::string g_sane_name(MODULE_NAME_SANE);
static std::string g_sane_ver = "";

namespace err_map
{
	struct
	{
		int sane;
		int scanner;
	}g_err_map[] =
	{ {SANE_STATUS_GOOD, SCANNER_ERR_OK}
		, {SANE_STATUS_UNSUPPORTED, SCANNER_ERR_DEVICE_NOT_SUPPORT}
		, {SANE_STATUS_CANCELLED, SCANNER_ERR_USER_CANCELED}
		, {SANE_STATUS_DEVICE_BUSY, SCANNER_ERR_DEVICE_BUSY}
		, {SANE_STATUS_INVAL, SCANNER_ERR_INVALID_PARAMETER}
		, {SANE_STATUS_EOF, SCANNER_ERR_NO_DATA}
		, {SANE_STATUS_JAMMED, SCANNER_ERR_DEVICE_PAPER_JAMMED}
		, {SANE_STATUS_NO_DOCS, SCANNER_ERR_DEVICE_NO_PAPER}
		, {SANE_STATUS_COVER_OPEN, SCANNER_ERR_DEVICE_COVER_OPENNED}
		, {SANE_STATUS_IO_ERROR, SCANNER_ERR_IO}
		, {SANE_STATUS_NO_MEM, SCANNER_ERR_INSUFFICIENT_MEMORY}
		, {SANE_STATUS_ACCESS_DENIED, SCANNER_ERR_ACCESS_DENIED}
	};

	static int sane_2_scanner(int sane)
	{
		for (size_t i = 0; i < _countof(g_err_map); ++i)
		{
			if (g_err_map[i].sane == sane)
				return g_err_map[i].scanner;
		}

		return sane;
	}
	static int scanner_2_sane(int scanner)
	{
		for (size_t i = 0; i < _countof(g_err_map); ++i)
		{
			if (g_err_map[i].scanner == scanner)
				return g_err_map[i].sane;
		}

		return scanner;
	}
}
extern "C"
{
	static void language_changed(int cp, void* param)
	{
		hg_scanner_mgr::instance()->on_language_changed();
	}

	scanner_err hg_scanner_initialize(sane_callback callback, void* reserve)
	{
		std::string	name(""),
					pe(utils::get_module_full_path()),
					path(PATH_SEPARATOR),
					scanner(g_scanner_path),
					sane(utils::get_module_full_path(/*(g_sane_name + "." + DLL_EXTESION).c_str()*/MODULE_NAME_SANE));
		size_t		pos = pe.rfind(path[0]);

		if(pos++ == std::string::npos)
			pos = 0;
		name = pe.substr(pos);
		pe.erase(pos);

		g_scanner_path = utils::get_module_full_path(MODULE_NAME_SCANNER);
		scanner = g_scanner_path;
		pos = g_scanner_path.rfind(path[0]);
		if (pos++ != std::string::npos)
			g_scanner_path.erase(pos);

		utils::init_log(LOG_TYPE_FILE);
		utils::to_log(LOG_LEVEL_DEBUG, "Module device: [%u.%u.%u.%u] - %s\n", VERSION_MAJOR, VERSION_MINOR, VERSION_YEAR, GET_BUILD_VER, scanner.c_str());
		utils::to_log(LOG_LEVEL_DEBUG, "Module  sane : [%s] - %s\n", g_sane_ver.c_str(), sane.c_str());
		utils::to_log(LOG_LEVEL_DEBUG, "Module  exe  : %s\n", (pe + name).c_str());
#ifdef _WIN32
		char	now[MAX_PATH] = { 0 };
		GetCurrentDirectoryA(_countof(now) - 1, now);
		path = now;
#else
		path = utils::get_command_result("pwd");
#endif
		utils::to_log(LOG_LEVEL_DEBUG, "Current Path : %s\n", path.c_str());

		//if (lang_initialize() == -1)
		//{
		//	utils::to_log(LOG_LEVEL_FATAL, "No language package found!\n");
		//	return SCANNER_ERR_LANG_PAK_LOST;
		//}
		//else
		//{
		//	std::string lang(utils::get_ini_value("language", "code-page", nullptr));
		//	if(!lang.empty())
		//	{
		//		lang_set_code_page(atoi(lang.c_str()));
		//		utils::to_log(LOG_LEVEL_DEBUG, "Found the language specified by user: %s, code-page after set = %d\n", lang.c_str(), lang_get_cur_code_page());
		//	}
		//}

		hg_scanner_mgr::set_version(VERSION_MAJOR, VERSION_MINOR, VERSION_YEAR, GET_BUILD_VER);
		hg_scanner_mgr::set_exe_name(pe.c_str(), name.c_str());
		hg_scanner_mgr::instance(callback);

		register_language_changed_notify(language_changed, true);
		std::string lang(utils::get_ini_value("language", "code-page", nullptr));
		if (lang.empty() && STRICMP(name.c_str(), "qtsane") == 0)
		{
			lang = "20127";		// qtsane can not support chinese !!! we change language to English :(
			utils::to_log(LOG_LEVEL_DEBUG, "Change the default language to English while qtsane does not support Chinese!\n");
		}
		if(!lang.empty())
		{
			lang_set_code_page(atoi(lang.c_str()));
			utils::to_log(LOG_LEVEL_DEBUG, "Found the language specified by user: %s, code-page after set = %d\n", lang.c_str(), lang_get_cur_code_page());
		}

		return SCANNER_ERR_OK;
	}
	void hg_scanner_uninitialize(void)
	{
		register_language_changed_notify(language_changed, false);
		hg_scanner_mgr::clear();
		utils::uninit();
	}

	unsigned long long hg_scanner_get_version(void)
	{
		return MAKE_VERSION(VERSION_MAJOR, VERSION_MINOR, VERSION_YEAR, GET_BUILD_VER);
	}

	scanner_err hg_scanner_enum(ScannerInfo* scanner_list, long* count, bool local_only)
	{
		return hg_scanner_mgr::instance()->hg_scanner_enum(scanner_list, count, local_only);
	}

	scanner_err hg_scanner_open(scanner_handle* h, const char* name, bool shared, const char* user, const char* pwd, const char* check, char* rsc)
	{
		return hg_scanner_mgr::instance()->hg_scanner_open(h, name, shared, user, pwd, check, rsc);
	}

	scanner_err hg_scanner_close(scanner_handle h, bool force)
	{
		return hg_scanner_mgr::instance()->hg_scanner_close(h, force);
	}

	scanner_err hg_scanner_get_option(scanner_handle h, const char* name, char* data, long* len, int type)
	{
		return hg_scanner_mgr::instance()->hg_scanner_get_parameter(h, name, data, len, type);
	}

	scanner_err hg_scanner_set_option(scanner_handle h, const char* name, void* data, bool to_default)
	{
		return hg_scanner_mgr::instance()->hg_scanner_set_parameter(h, name, data, to_default);
	}

	scanner_err hg_scanner_start(scanner_handle h, void* async_event, int num)
	{
		return hg_scanner_mgr::instance()->hg_scanner_start(h, async_event, num);
	}

	scanner_err hg_scanner_stop(scanner_handle h)
	{
		return hg_scanner_mgr::instance()->hg_scanner_stop(h);
	}

	scanner_err hg_scanner_get_img_info(scanner_handle h, SANE_Parameters* bmi, long len)
	{
		return hg_scanner_mgr::instance()->hg_scanner_get_img_info(h, bmi, len);
	}

	scanner_err hg_scanner_read_img_data(scanner_handle h, unsigned char* data, long* len)
	{
		return hg_scanner_mgr::instance()->hg_scanner_read_img_data(h, data, len);
	}


	scanner_err hg_scanner_get_status(scanner_handle h, int setstutas)
	{
		return hg_scanner_mgr::instance()->hg_scanner_get_status(h, setstutas);
	}

	scanner_err hg_scanner_reset(scanner_handle h)
	{
		return hg_scanner_mgr::instance()->hg_scanner_reset(h);
	}

	scanner_err hg_scanner_control(scanner_handle h, unsigned long code, void* data, unsigned* len)
	{
		return hg_scanner_mgr::instance()->hg_scanner_control(h, code, data, len);
	}

	void hg_scanner_set_sane_info(const char* name, const char* ver)
	{
		g_sane_name = name;
		g_sane_ver = ver;
	}
	const char* hg_scanner_err_name(int err, char* buf)
	{
		RETURN_IF(err, SANE_STATUS_GOOD);
		RETURN_IF(err, SANE_STATUS_UNSUPPORTED);
		RETURN_IF(err, SANE_STATUS_CANCELLED);
		RETURN_IF(err, SANE_STATUS_DEVICE_BUSY);
		RETURN_IF(err, SANE_STATUS_INVAL);
		RETURN_IF(err, SANE_STATUS_EOF);
		RETURN_IF(err, SANE_STATUS_JAMMED);
		RETURN_IF(err, SANE_STATUS_NO_DOCS);
		RETURN_IF(err, SANE_STATUS_COVER_OPEN);
		RETURN_IF(err, SANE_STATUS_IO_ERROR);
		RETURN_IF(err, SANE_STATUS_NO_MEM);
		RETURN_IF(err, SANE_STATUS_ACCESS_DENIED);
		RETURN_IF(err, SCANNER_ERR_INVALID_PARAMETER);
		RETURN_IF(err, SCANNER_ERR_USER_CANCELED);
		RETURN_IF(err, SCANNER_ERR_INSUFFICIENT_MEMORY);
		RETURN_IF(err, SCANNER_ERR_ACCESS_DENIED);
		RETURN_IF(err, SCANNER_ERR_IO_PENDING);
		RETURN_IF(err, SCANNER_ERR_NOT_EXACT);
		RETURN_IF(err, SCANNER_ERR_CONFIGURATION_CHANGED);
		RETURN_IF(err, SCANNER_ERR_RELOAD_IMAGE_PARAM);
		RETURN_IF(err, SCANNER_ERR_RELOAD_OPT_PARAM);
		RETURN_IF(err, SCANNER_ERR_NOT_OPEN);
		RETURN_IF(err, SCANNER_ERR_NOT_START);
		RETURN_IF(err, SCANNER_ERR_NOT_ANY_MORE);
		RETURN_IF(err, SCANNER_ERR_NO_DATA);
		RETURN_IF(err, SCANNER_ERR_HAS_DATA_YET);
		RETURN_IF(err, SCANNER_ERR_OUT_OF_RANGE);
		RETURN_IF(err, SCANNER_ERR_IO);
		RETURN_IF(err, SCANNER_ERR_TIMEOUT);
		RETURN_IF(err, SCANNER_ERR_OPEN_FILE_FAILED);
		RETURN_IF(err, SCANNER_ERR_CREATE_FILE_FAILED);
		RETURN_IF(err, SCANNER_ERR_WRITE_FILE_FAILED);
		RETURN_IF(err, SCANNER_ERR_DATA_DAMAGED);
		RETURN_IF(err, SCANNER_ERR_OPENED_BY_OTHER_PROCESS);
		RETURN_IF(err, SCANNER_ERR_USB_INIT_FAILED);
		RETURN_IF(err, SCANNER_ERR_USB_REGISTER_PNP_FAILED);
		RETURN_IF(err, SCANNER_ERR_USB_CLAIM_INTERFACE_FAILED);
		RETURN_IF(err, SCANNER_ERR_DEVICE_NOT_FOUND);
		RETURN_IF(err, SCANNER_ERR_DEVICE_NOT_SUPPORT);
		RETURN_IF(err, SCANNER_ERR_DEVICE_BUSY);
		RETURN_IF(err, SCANNER_ERR_DEVICE_SLEEPING);
		RETURN_IF(err, SCANNER_ERR_DEVICE_COUNT_MODE);
		RETURN_IF(err, SCANNER_ERR_DEVICE_STOPPED);
		RETURN_IF(err, SCANNER_ERR_DEVICE_COVER_OPENNED);
		RETURN_IF(err, SCANNER_ERR_DEVICE_NO_PAPER);
		RETURN_IF(err, SCANNER_ERR_DEVICE_FEEDING_PAPER);
		RETURN_IF(err, SCANNER_ERR_DEVICE_DOUBLE_FEEDING);
		RETURN_IF(err, SCANNER_ERR_DEVICE_PAPER_JAMMED);
		RETURN_IF(err, SCANNER_ERR_DEVICE_STAPLE_ON);
		RETURN_IF(err, SCANNER_ERR_DEVICE_PAPER_SKEW);
		RETURN_IF(err, SCANNER_ERR_DEVICE_SIZE_CHECK);
		RETURN_IF(err, SCANNER_ERR_DEVICE_DOGEAR);
		RETURN_IF(err, SCANNER_ERR_DEVICE_NO_IMAGE);
		RETURN_IF(err, SCANNER_ERR_DEVICE_SCANN_ERROR);
		RETURN_IF(err, SCANNER_ERR_DEVICE_PC_BUSY);
		RETURN_IF(err, SCANNER_ERR_DEVICE_ISLOCK);
		RETURN_IF(err, SCANNER_ERR_DEVICE_MAYBE_IS_HOLE);
		RETURN_IF(err, SCANNER_ERR_DEVICE_DEVS_BOOTING);
		RETURN_IF(err, SCANNER_ERR_DEVICE_UNKNOWN_STATUS);
		RETURN_IF(err, SCANNER_ERR_LANG_PAK_LOST);
		RETURN_IF(err, SCANNER_ERR_THROW_EXCEPTION);

		sprintf(buf, "Unknown error: 0x%X", err);

		return buf;
	}
	const char* hg_scanner_err_description(int err)
	{
		if (err < 0x100)
			err = err_map::sane_2_scanner(err);

		if (err == SCANNER_ERR_OPENED_BY_OTHER_PROCESS && *hg_scanner_mgr::instance()->last_open_message())
			return hg_scanner_mgr::instance()->last_open_message();

		RETURN_DESC_IF(err, SCANNER_ERR_OK);
		RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_NOT_SUPPORT);
		RETURN_DESC_IF(err, SCANNER_ERR_USER_CANCELED);
		RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_BUSY);
		RETURN_DESC_IF(err, SCANNER_ERR_INVALID_PARAMETER);
		RETURN_DESC_IF(err, SCANNER_ERR_NO_DATA);
		RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_PAPER_JAMMED);
		RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_NO_PAPER);
		RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_COVER_OPENNED);
		RETURN_DESC_IF(err, SCANNER_ERR_IO);
		RETURN_DESC_IF(err, SCANNER_ERR_INSUFFICIENT_MEMORY);

		RETURN_DESC_IF(err, SCANNER_ERR_ACCESS_DENIED);
		RETURN_DESC_IF(err, SCANNER_ERR_INSUFFICIENT_MEMORY);
		RETURN_DESC_IF(err, SCANNER_ERR_ACCESS_DENIED);
		RETURN_DESC_IF(err, SCANNER_ERR_IO_PENDING);
		RETURN_DESC_IF(err, SCANNER_ERR_NOT_EXACT);
		RETURN_DESC_IF(err, SCANNER_ERR_CONFIGURATION_CHANGED);
		RETURN_DESC_IF(err, SCANNER_ERR_RELOAD_IMAGE_PARAM);
		RETURN_DESC_IF(err, SCANNER_ERR_RELOAD_OPT_PARAM);
		RETURN_DESC_IF(err, SCANNER_ERR_NOT_OPEN);
		RETURN_DESC_IF(err, SCANNER_ERR_NOT_START);
		RETURN_DESC_IF(err, SCANNER_ERR_NOT_ANY_MORE);
		RETURN_DESC_IF(err, SCANNER_ERR_NO_DATA);
		RETURN_DESC_IF(err, SCANNER_ERR_HAS_DATA_YET);
		RETURN_DESC_IF(err, SCANNER_ERR_OUT_OF_RANGE);
		RETURN_DESC_IF(err, SCANNER_ERR_IO);
		RETURN_DESC_IF(err, SCANNER_ERR_TIMEOUT);
		RETURN_DESC_IF(err, SCANNER_ERR_OPEN_FILE_FAILED);
		RETURN_DESC_IF(err, SCANNER_ERR_CREATE_FILE_FAILED);
		RETURN_DESC_IF(err, SCANNER_ERR_WRITE_FILE_FAILED);
		RETURN_DESC_IF(err, SCANNER_ERR_DATA_DAMAGED);
		RETURN_DESC_IF(err, SCANNER_ERR_OPENED_BY_OTHER_PROCESS);
		RETURN_DESC_IF(err, SCANNER_ERR_USB_INIT_FAILED);
		RETURN_DESC_IF(err, SCANNER_ERR_USB_REGISTER_PNP_FAILED);
		RETURN_DESC_IF(err, SCANNER_ERR_USB_CLAIM_INTERFACE_FAILED);
		RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_NOT_FOUND);
		RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_NOT_SUPPORT);
		RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_BUSY);
		RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_SLEEPING);
		RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_COUNT_MODE);
		RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_STOPPED);
		RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_COVER_OPENNED);
		RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_NO_PAPER);
		RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_FEEDING_PAPER);
		RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_DOUBLE_FEEDING);
		RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_PAPER_JAMMED);
		RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_STAPLE_ON);
		RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_PAPER_SKEW);
		RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_SIZE_CHECK);
		RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_DOGEAR);
		RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_NO_IMAGE);
		RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_SCANN_ERROR);
		RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_PC_BUSY);
		RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_ISLOCK);
		RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_MAYBE_IS_HOLE);
		RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_DEVS_BOOTING);
		RETURN_DESC_IF(err, SCANNER_ERR_DEVICE_UNKNOWN_STATUS);
		if (err == SCANNER_ERR_LANG_PAK_LOST)
			return "SCANNER_ERR_LANG_PAK_LOST";

		// NOTE: multi-thread unsafe here
		static char	g_unk_err[128] = { 0 };
		strcpy(g_unk_err, from_default_language(STATU_DESC_SCANNER_ERR_DEVICE_UNKNOWN_ERROR));
		sprintf(g_unk_err + strlen(g_unk_err), ":0x%x", err);

		return g_unk_err;
	}
	bool hg_scanner_log_is_enable(int level)
	{
		return level >= utils::get_log_level() && utils::get_log_type() != LOG_TYPE_NONE;
	}
	void hg_scanner_log(const char* info, int level)
	{
		utils::log_info(info, level);
	}

	const char* hg_scanner_image_statu_name(int img_statu)
	{
		RETURN_IF(img_statu, IMG_STATUS_OK);
		RETURN_IF(img_statu, IMG_STATUS_BLANK);
		RETURN_IF(img_statu, IMG_STATUS_DOUBLE);
		RETURN_IF(img_statu, IMG_STATUS_JAM);
		RETURN_IF(img_statu, IMG_STATUS_STAPLE);
		RETURN_IF(img_statu, IMG_STATUS_SIZE_ERR);
		RETURN_IF(img_statu, IMG_STATUS_DOGEAR);
		RETURN_IF(img_statu, IMG_STATUS_DOGEAR_PARTIAL);

		// NOTE: multi-thread unsafe here
		static char	g_unk_statu[80] = { 0 };
		sprintf(g_unk_statu, "Unknowned image statu: 0x%X", img_statu);

		return g_unk_statu;
	}

	int hg_get_full_path_of_module(char* buf, size_t* size, const char* part_name)
	{
		if(!size)
			return EINVAL;

		std::string	fullp(utils::get_module_full_path(part_name));
		if(fullp.empty())
			return ENOENT;

		if(*size <= fullp.length())
		{
			*size = fullp.length() + 4;

			return ENOMEM;
		}

		strcpy(buf, fullp.c_str());
		*size = fullp.length();

		return 0;
	}
}


#if defined(WIN32) || defined(_WIN64)

BOOL WINAPI DllMain(HINSTANCE inst, DWORD reason, LPVOID reserved)
{
	//static _CrtMemState state;

	if (reason == DLL_PROCESS_ATTACH)
	{
		//if (g_scanner_path.empty())
		//{
		//	char	path[MAX_PATH] = { 0 };

		//	GetModuleFileNameA(inst, path, _countof(path) - 1);
		////	if (strrchr(path, '\\'))
		//	{
		////		strrchr(path, '\\')[1] = 0;
		//		g_scanner_path = path;
		//	}
		//}
#ifdef _DEBUG
		_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
#endif
	}

	return TRUE;
}
#endif