code_scanner/scanner/main/scanner.cpp

#include "scanner.h"


#include "../../common/log_util.h"
#include "../../common/ipc_wrapper.h"
#include "../img_collector/img_collector.h"
#include "../img_process/img_process.h"
#include "../res_monitor/res_monitor.h"


/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// scanner
scanner::scanner(const char* ipc_id) : img_proc_(nullptr), img_src_(nullptr), res_(nullptr), ipc_(nullptr)
									 , exit_(nullptr), run_(true), status_(SCANNER_STATUS_READY), ipc_id_(ipc_id)
									 , partial_msg_("")
{
	exit_ = new linux_event("exit-scanner");
}
scanner::~scanner()
{
	uninit();
	exit_->release();
}

int32_t scanner::init(void)
{
	run_ = true;
	img_proc_ = new img_processor(dynamic_cast<paremeter_get*>(this), dynamic_cast<event_handler*>(this));
	img_src_ = image_collector::create_image_collector(dynamic_cast<event_handler*>(this));
	res_ = new res_mon(dynamic_cast<event_handler*>(this));
	ipc_ = ipc_wrapper::create_ipc(dynamic_cast<event_handler*>(this), ipc_wrapper::IPC_SHARED_MEM, ipc_id_.c_str());
	
	return ipc_->is_ok() ? 0 : ENOTCONN;
}
int32_t scanner::uninit(void)
{
	run_ = false;
	if (ipc_)
	{
		ipc_->stop();
		ipc_->release();
	}
	if (res_)
	{
		res_->stop();
		res_->release();
	}
	if (img_src_)
	{
		img_src_->stop();
		img_src_->release();
	}
	if (img_proc_)
	{
		img_proc_->stop();
		img_proc_->release();
	}

	img_proc_ = nullptr;
	img_src_ = nullptr;
	res_ = nullptr;
	ipc_ = nullptr;

	return 0;
}

int32_t scanner::add_ref(void)
{
	return event_handler::add_ref();
}
int32_t scanner::release(void)
{
	return event_handler::release();
}

int32_t scanner::from_thunk_data(std::string& pack)
{
	LPPACK_BASE pk = (LPPACK_BASE)&pack[0];

	if (pk->thunk)
	{
		std::string	d("");
		LPTHUNKD	pthk = (LPTHUNKD)pk->payload;
		while (pthk->bytes)
		{
			d += std::string(pthk->data, pthk->bytes);
			pthk = (LPTHUNKD)((char*)pthk + sizeof(THUNKD) + pthk->bytes);
		}
		pack.erase(sizeof(PACK_BASE));
		pack += d;
	}

	return pack.length();
}
int32_t scanner::dispatch_ipc_message(LPPACK_BASE pack)
{
	if (pack->cmd == PACK_CMD_ATTR_HISTORY_COUNT_GET)
	{

	}
	else if (pack->cmd == PACK_CMD_ATTR_ROLLER_COUNT_GET)
	{

	}
	else if (pack->cmd == PACK_CMD_ATTR_ROLLER_COUNT_SET)
	{

	}
	else if (pack->cmd == PACK_CMD_SETTING_GET)
	{

	}
	else if (pack->cmd == PACK_CMD_SETTING_GET_CUR)
	{

	}
	else if (pack->cmd == PACK_CMD_SETTING_SET)
	{

	}
	else if (pack->cmd == PACK_CMD_SETTING_RESTORE)
	{

	}
	else if (pack->cmd == PACK_CMD_STATUS_RESTORE)
	{

	}
	else if (pack->cmd == PACK_CMD_SCAN_START)
	{

	}
	else if (pack->cmd == PACK_CMD_SCAN_STOP)
	{

	}
	else if (pack->cmd == PACK_CMD_SCAN_IMG_SIZE_GET)
	{

	}
	else if (pack->cmd == PACK_CMD_SCAN_IMG_READ)
	{

	}
	else if (pack->cmd == PACK_CMD_SCAN_IMG_POP)
	{

	}

	return 0;
}
int32_t scanner::ipc_message_handler(void)
{
	while (run_)
	{
		std::string	msg("");

		if (!msg_que_.take(msg, true))
			continue;

		from_thunk_data(msg);
		dispatch_ipc_message((LPPACK_BASE)&msg[0]);
	}

	return 0;
}
int32_t scanner::on_ipc(void* data, size_t data_len, bool in)
{
	int32_t	ret = 0;

	if (in)
	{
		partial_msg_ += std::string((char*)data, data_len);

		if (partial_msg_.length() >= sizeof(PACK_BASE))
		{
			LPPACK_BASE	pack = (LPPACK_BASE)&partial_msg_[0];
			size_t		len = sizeof(PACK_BASE) + pack->total_bytes;
			if (pack->thunk)
			{
				LPTHUNKD	pthk = (LPTHUNKD)pack->payload;

				len = partial_msg_.length() - sizeof(PACK_BASE);
				while (len >= sizeof(THUNKD))
				{
					if (pthk->bytes == 0)
					{
						pthk++;
						len = (char*)pthk - (char*)pack;

						std::string	msg(&partial_msg_[0], len);

						partial_msg_.erase(0, len);
						msg_que_.save(msg, true);
						break;
					}
					if (len < pthk->bytes + sizeof(THUNKD))
						break;

					len -= pthk->bytes + sizeof(THUNKD);
					pthk = (LPTHUNKD)(pthk->data + pthk->bytes);
				}
			}
			else
			{
				if (partial_msg_.length() >= len)
				{
					msg_que_.save(partial_msg_.substr(0, len), true);
					partial_msg_.erase(0, len);
				}
			}
		}
	}
	else
	{
		// several parts sent ...
	}

	return ret;
}

int32_t scanner::on_event(int32_t ev, void* data, size_t data_len)
{
	// image-process, image-collector, resource-mgr, ipc_wrapper
	int32_t	ret = 0;

	if (!run_)
		return ESHUTDOWN;

	switch (ev)
	{
	case SCANNER_EVENT_COLLECTOR_WORKING:
		status_ = SCANNER_STATUS_WORKING;
		break;
	case SCANNER_EVENT_IPC_DATA_RECEIVED:
		on_ipc(data, data_len, true);
		break;
	case SCANNER_EVENT_IPC_DATA_SENT:
		on_ipc(data, data_len, false);
		break;
	case SCANNER_EVENT_COLLECTOR_COVER_OPENNED:
		status_ = SCANNER_STATUS_COVER_OPENNED;
		break;
	case SCANNER_EVENT_COLLECTOR_PAPER_ON:
		break;
	case SCANNER_EVENT_COLLECOTR_GET_BUF:
		break;
	default:
		ret = EINVAL;
		break;
	}

	return ret;
}
int32_t scanner::get_fd(void)
{
	return -1;
}

parameter* scanner::get_parameter(img_proc_param ipp)
{
	return nullptr;
}

int32_t scanner::run(void)
{
	int32_t	ret = init();

	if (ret == 0)
		exit_->wait();

	uninit();

	return ret;
}
int32_t scanner::stop(void)
{
	run_ = false;
	exit_->trigger();

	return 0;
}