DriverPlatform-V3.1/OemLayer/ContainerDPC/ModuleDriver.cpp

#include "ModuleDriver.h"
#include <functional>
#include "ModuleConfig.h"
#include "LocalConfig.h"
#include "PacketAnalizer.h"
#include "LogLocalHelper.h" 
#include "Log4CPP.h"

ModuleDriver::ModuleDriver()
{
	//if (gLogger == nullptr)
	//{
	//	string strLogPath = GetProcessDirectory() + R"(\Conf\Log4CPP.Config.xml)";

	//	string LogHost = ((string)getLogRootpath()).c_str();

	//	//if (LogHost.length() <= 1)
	//	//{
	//	//	char szName[256];
	//	//	sprintf(szName, "/LogicDevice_%08d", GetCurrentProcessId());

	//	//	LogHost = szName;
	//	//}


	//	Log4CPP::ThreadContext::Map::Set(ECOM::Utility::Hash("LogFileName"), "Platform");
	//	//Log4CPP::GlobalContext::Map::Set("LogHost", LogHost.c_str());
	//	Log4CPP::ThreadContext::Map::Set(ECOM::Utility::Hash("LogHost"), LogHost.c_str() + 1);

	//	auto rc = Log4CPP::LogManager::LoadConfigFile(strLogPath.c_str());
	//	gLogger = Log4CPP::LogManager::GetLogger("Platform");

	//	FINFO("Code Build datetime [{$} {$}]", __DATE__, __TIME__);

	//}
	m_config = new ModuleConfig();

}
ModuleDriver::~ModuleDriver()
{

}

bool ModuleDriver::DriverEntry(ResDataObject& PARAM_IN Configuration)
{
	LogicDriver::DriverEntry(Configuration);

	string strPath = GetModuleDevicePath(Configuration);

	FINFO("Driver Load Ccos Path : {$}", strPath);

	(*m_config).CheckAndInitConfig(strPath);
	return true;
}
//
//RET_STATUS ModuleDriver::Request(ResDataObject PARAM_IN* pRequest, ResDataObject PARAM_OUT* pResponse)
//{
//	INT ret = RET_NOSUPPORT;
//	PACKET_CMD cmd = PacketAnalizer::GetPacketCmd(pRequest);
//	PACKET_TYPE type = PacketAnalizer::GetPacketType(pRequest);
//	string keystr = PacketAnalizer::GetPacketKey(pRequest);
//	ResDataObject Context;
//	if (PacketAnalizer::GetPacketContext(pRequest, Context) == false)
//	{
//		return RET_FAILED;
//	}
//	ResDataObject resReponse;
//
//	if (type == PACKET_TYPE_NOTIFY)
//	{
//
//		//通知类，不需要答复
//		return RET_END;
//	}
//	else if (type == PACKET_TYPE_RES)
//	{
//
//		//收到了应答包。。。
//		return RET_END;
//	}
//
//	if (cmd == PACKET_CMD_EXE)
//	{
//		string req, res;
//		req = (const char*)Context.encode();
//		FINFO("Action[{$}].req:{$}", keystr.c_str(), req.c_str());
//
//		ret = LogicDriver::Request(pRequest, pResponse);
//		if(ret == RET_NOSUPPORT)
//			ret = DevAction("", keystr.c_str(), req.c_str(), resReponse);
//
//		pResponse->update("CONTEXT", resReponse);
//		FINFO("Action res packet done");
//	}
//	else if (cmd == PACKET_CMD_GET)
//	{
//		string res;
//		FINFO("get CMD_GET req:{$}", keystr.c_str());
//
//		ret = LogicDriver::Request(pRequest, pResponse);
//		if (ret == RET_NOSUPPORT)
//			ret = DevGet(m_strCCOSDevicePath.c_str(), keystr.c_str(), resReponse);
//		pResponse->update("CONTEXT", resReponse);
//	}
//	else if (cmd == PACKET_CMD_UPDATE)
//	{
//		FINFO("get CMD_UPDATE req:{$}", keystr.c_str());
//
//		ret = LogicDriver::Request(pRequest, pResponse);
//		if (ret == RET_NOSUPPORT)
//			ret = DevUpdate(m_strCCOSDevicePath.c_str(), keystr.c_str(), Context, resReponse);
//		pResponse->update("CONTEXT", resReponse);
//
//	}
//	else if (cmd == PACKET_CMD_SET)
//	{
//		FINFO("get CMD_UPDATE req:{$}", keystr.c_str());
//
//		ret = LogicDriver::Request(pRequest, pResponse);
//		if (ret == RET_NOSUPPORT)
//			ret = DevSet(m_strCCOSDevicePath.c_str(), keystr.c_str(), Context, resReponse);
//		pResponse->update("CONTEXT", resReponse);
//
//	}
//	else if (cmd == PACKET_CMD_MSG)
//	{
//		FINFO("get CMD_UPDATE req:{$}", keystr.c_str());
//
//		ret = LogicDriver::Request(pRequest, pResponse);
//		if (ret == RET_NOSUPPORT)
//			ret = DevMessage(m_strCCOSDevicePath.c_str(), keystr.c_str(), Context, resReponse);
//		pResponse->update("CONTEXT", resReponse);
//
//	}
//	else if (cmd == PACKET_CMD_ADD)
//	{
//		FINFO("get CMD_ADD req:{$}", keystr.c_str());
//
//		ret = LogicDriver::Request(pRequest, pResponse);
//		if (ret == RET_NOSUPPORT)
//			ret = DevAdd(m_strCCOSDevicePath.c_str(), keystr.c_str(), Context, resReponse);
//		pResponse->update("CONTEXT", resReponse);
//
//	}
//	else if (cmd == PACKET_CMD_DEL)
//	{
//		FINFO("get CMD_DEL req:{$}", keystr.c_str());
//
//		ret = LogicDriver::Request(pRequest, pResponse);
//		if (ret == RET_NOSUPPORT)
//			ret = DevDel(m_strCCOSDevicePath.c_str(), keystr.c_str(), Context, resReponse);
//		pResponse->update("CONTEXT", resReponse);
//
//	}
//	else
//	{
//		//wtf?? 忽略掉
//		return RET_END;
//	}
//
//
//	PacketAnalizer::MakeRetCode((RET_STATUS)ret, pResponse);
//
//	return (RET_STATUS)ret;
//
//
//}

RET_STATUS ModuleDriver::CmdToLogicDev(ResDataObject PARAM_IN* pCmd)
{
	return RET_SUCCEED;
}
bool  ModuleDriver::GetDeviceType(GUID& DevType)
{
	return true;
}

void ModuleDriver::SubscribeSelf()
{
	LogicDevice::SubscribeSelf();
}

void  ModuleDriver::OnSetClientID()
{
	//这里根据 CCOS设备 路径决定加载什么配置
	LogicDevice::OnSetClientID();

	//这里要注意是 CCOS/Driver？？，在DriverEntry的时候 初始化过了，这里不需要了
	//(*m_config).CheckAndInitConfig(m_strCCOSDevicePath);

}

RET_STATUS ModuleDriver::GetDeviceResource(ResDataObject PARAM_OUT* pDeviceResource)
{
	//父类会生成Ations

	LogicDevice::GetDeviceResource(pDeviceResource);

	//ResDataObject getPerp = m_resModuleConfig["Get"];

	(*m_config).GetDeviceResource(pDeviceResource, DPC_DriverClient);

	//msgPerp = m_resModuleConfig["Message"];

	return RET_SUCCEED;
}

/// <summary>
/// 枚举配置项，level == "Public" ，仅返回Pulic
/// level == "E-COM" ,返回 Public 和 E-COM
/// level == "Private" , 返回所有
/// </summary>
/// <param name="level">三个固定常量字符串 "Public"/"E-COM"/"Private"</param>
/// <param name="resItems"></param>
/// <returns></returns>
RET_STATUS ModuleDriver::GetUpdatableItems(string level, ResDataObject& resItems)
{
	return (*m_config).GetUpdatableItems(level, resItems);
}

RET_STATUS  ModuleDriver::UpdateItem(const char* pszProperty, const char* pszValueUpdate, ResDataObject& resRespons)
{
	//保存到配置文件
	//通知模型对象，值更新了
	string strNewValue = (*m_config).UpdateItem(pszProperty, pszValueUpdate);
	return OnUpdate(pszProperty, strNewValue.c_str(), resRespons);

}

RET_STATUS ModuleDriver::OnMessage(const char* pszTopic, const char* pszMessageValue, ResDataObject& resResponse)
{
	FINFO("Message to {$} with {$}", pszTopic, pszMessageValue);

	return RET_SUCCEED;
}

RET_STATUS ModuleDriver::DevGet(const char* pszDevUri, const char* pszProperty, ResDataObject& resRespons)
{
	string property = pszProperty;
	if (property.length() <= 0)
	{
		auto func = std::bind(&ModuleDriver::GetItem, this, placeholders::_1, placeholders::_2);
		//RET_STATUS ret = func(pszProperty, resRespons);
		(*m_config).GetAll(resRespons, func);

		return RET_SUCCEED;
	}

	if (!(*m_config).CanDo(pszProperty, PACKET_CMD_GET))
		return RET_NOSUPPORT;

	if (GetItem(pszProperty, resRespons) == RET_SUCCEED)
	{
		(*m_config).GetPropties().update(pszProperty, resRespons);
	}
	resRespons = (*m_config).GetPropties()[pszProperty];
	return RET_SUCCEED;
}

RET_STATUS ModuleDriver::DevSet(const char* pszDevUri, const char* pszProperty, const char* pszValueSet, ResDataObject& resRespons)
{
	if (!(*m_config).CanDo(pszProperty, PACKET_CMD_SET))
		return RET_NOSUPPORT;

	ResDataObject resNewValue;
	resNewValue.decode(pszValueSet);
	RET_STATUS ret = SetItem(pszProperty, resNewValue, resRespons);
	if (ret == RET_SUCCEED)
		(*m_config).GetPropties()[pszProperty].update("Value", resNewValue);
	//通知模型对象，值更新了
	return ret;
}



RET_STATUS ModuleDriver::DevUpdate(const char* pszDevUri, const char* pszProperty, const char* pszValueUpdate, ResDataObject& resRespons)
{
	string strProperty = pszProperty;

	if (strProperty.length() == 0)
	{
		//查询可以更新的属性
		string level = pszValueUpdate;
		if (level.length() <= 0)
			level = "Public";
		if (level == "Public" || level == "E-COM" || level == "Private")
		{
			//
			return GetUpdatableItems(level, resRespons);
		}
		level = "Public";
		return GetUpdatableItems(level, resRespons);
	}

	if (!(*m_config).CanDo(pszProperty, PACKET_CMD_UPDATE))
		return RET_NOSUPPORT;

	if (strProperty == "RestoreConfig")
	{
		//恢复出厂设置
	}

	RET_STATUS ret = UpdateItem(pszProperty, pszValueUpdate, resRespons);

	FINFO("UpdateItem to Device [{$}] ret [{$}]", pszProperty, (int)ret);

	//m_resModuleConfig.update("Get", m_resProperties);

	(*m_config).SaveToConfigFile();

	return RET_SUCCEED;
}

RET_STATUS ModuleDriver::DevAdd(const char* pszDevUri, const char* pszProperty, const char* pszValueAdd, ResDataObject& resRespons)
{
	if (!(*m_config).CanDo(pszProperty, PACKET_CMD_ADD))
		return RET_NOSUPPORT;

	ResDataObject resNewValue;
	resNewValue.decode(pszValueAdd);

	for (int x = 0; x < resNewValue.size(); x++)
	{
		(*m_config).GetPropties()[pszProperty].update(resNewValue.GetKey(x), resNewValue[x]);
	}
	//m_resProperties.update(pszProperty, resNewValue);
	return OnAdd(pszProperty, resNewValue, resRespons);

}

RET_STATUS ModuleDriver::DevDel(const char* pszDevUri, const char* pszProperty, const char* pszValueDel, ResDataObject& resRespons)
{
	if (!(*m_config).CanDo(pszProperty, PACKET_CMD_DEL))
		return RET_NOSUPPORT;

	ResDataObject resDelValue;
	string strDel = pszValueDel;
	if (strDel.length() < 0)
	{
		//什么参数都没有，清除所有数据
		(*m_config).GetPropties()[pszProperty].clear();

		return OnDel(pszProperty, resDelValue, resRespons);
	}
	resDelValue.decode(pszValueDel);

	string key = pszProperty;
	if (key == "ErrorList")
	{
		//如果是ErrorList，提供单独删除某类错误的能力
		int nIndex = resDelValue.GetFirstOf("ErrorIndex");
		if (nIndex >= 0)
		{
			nIndex = (int)resDelValue["ErrorIndex"];
			if (nIndex >= 0 && nIndex < ((*m_config).GetPropties()[key.c_str()]).size())
			{
				//m_resProperties[key.c_str()].eraseOneOf()
			}
		}
	}

	if (RET_SUCCEED == OnDel(pszProperty, resDelValue, resRespons))
	{
		(*m_config).GetPropties().update(pszProperty, resRespons);
		return RET_SUCCEED;
	}
	return RET_SUCCEED;
}

RET_STATUS ModuleDriver::DevAction(const char* pszDevUri, const char* pszActionName, const char* pszParams, ResDataObject& resRespons)
{
	cout << "ModuleDriver::DevAction - Entering. pszDevUri: " << (pszDevUri ? pszDevUri : "nullptr")
		<< ", pszActionName: " << (pszActionName ? pszActionName : "nullptr")
		<< ", pszParams: " << (pszParams ? pszParams : "nullptr") << endl;
	RET_STATUS ret = OnAction(pszActionName, pszParams, resRespons);
	if (ret != RET_NOSUPPORT)
		return ret;

	//ret = LogicDevice::DevAction(pszDevUri, pszActionName, pszParams, resRespons);
	//if (ret != RET_NOSUPPORT)
	//	return ret;

	//if (!(*m_config).CanDo(pszActionName, PACKET_CMD_EXE))
	//	return RET_NOSUPPORT;

	return ret;
}

RET_STATUS ModuleDriver::DevMessage(const char* pszDevUri, const char* pszTopic, const char* pszMessageValue, ResDataObject& resRespons)
{
	return OnMessage(pszTopic, pszMessageValue, resRespons);
}

RET_STATUS ModuleDriver::OnUpdate(const char* pszProperty, const char* pszValueUpdate, ResDataObject& resRespons)
{
	RET_STATUS ret = RET_NOSUPPORT;

	return ret;
}


RET_STATUS ModuleDriver::OnDel(const char* pszPropery, ResDataObject& resDelValue, ResDataObject& resResponse)
{
	RET_STATUS ret = RET_NOSUPPORT;

	return ret;
}
RET_STATUS ModuleDriver::OnAdd(const char* pszPropery, ResDataObject& reAddValue, ResDataObject& resResponse)
{
	RET_STATUS ret = RET_NOSUPPORT;

	return ret;
}
RET_STATUS ModuleDriver::SetItem(const char* pszPropery, ResDataObject& resSetValue, ResDataObject& resResponse)
{
	RET_STATUS ret = RET_NOSUPPORT;

	return ret;
}
RET_STATUS ModuleDriver::GetItem(const char* pszPropery, ResDataObject& resResponse)
{
	RET_STATUS ret = RET_NOSUPPORT;

	return ret;
}
RET_STATUS ModuleDriver::OnAction(const char* pszActionName, const char* pszParams, ResDataObject& resResponse)
{
	RET_STATUS ret = RET_NOSUPPORT;
	string strAction = pszActionName;
	if (strAction == "RestoreConfig")
	{
		//恢复出厂设置
		m_config->RestoreConfig();
		ret = RET_SUCCEED;
	}
	return ret;
}

RET_STATUS ModuleDriver::Request(ResDataObject PARAM_IN* pRequest, ResDataObject PARAM_OUT* pResponse)
{
	RET_STATUS ret = LogicDriver::Request(pRequest, pResponse);
	if (ret != RET_NOSUPPORT)
		return ret;

	PACKET_CMD cmd = PacketAnalizer::GetPacketCmd(pRequest);
	PACKET_TYPE type = PacketAnalizer::GetPacketType(pRequest);
	string keystr = PacketAnalizer::GetPacketKey(pRequest);
	ResDataObject Context;
	if (PacketAnalizer::GetPacketContext(pRequest, Context) == false)
	{
		return RET_FAILED;
	}
	ResDataObject resReponse;

	if (type == PACKET_TYPE_NOTIFY)
	{

		//通知类，不需要答复
		return RET_SUCCEED;
	}
	else if (type == PACKET_TYPE_RES)
	{

		//收到了应答包。。。
		return RET_SUCCEED;
	}

	if (cmd == PACKET_CMD_EXE)
	{
		string req, res;
		req = (const char*)Context.encode();
		FINFO("Action[{$}].req:{$}", keystr.c_str(), req.c_str());

		ret = DevAction("", keystr.c_str(), req.c_str(), resReponse);

		pResponse->update("CONTEXT", resReponse);
		FINFO("Action res packet done");
	}
	else if (cmd == PACKET_CMD_GET)
	{
		string res;
		FINFO("get CMD_GET req:{$}", keystr.c_str());

		ret = DevGet(m_strCCOSDevicePath.c_str(), keystr.c_str(), resReponse);
		pResponse->update("CONTEXT", resReponse);
	}
	else if (cmd == PACKET_CMD_UPDATE)
	{
		FINFO("get CMD_UPDATE req:{$}", keystr.c_str());

		ret = DevUpdate(m_strCCOSDevicePath.c_str(), keystr.c_str(), Context, resReponse);
		pResponse->update("CONTEXT", resReponse);

	}
	else if (cmd == PACKET_CMD_SET)
	{
		FINFO("get CMD_UPDATE req:{$}", keystr.c_str());

		ret = DevSet(m_strCCOSDevicePath.c_str(), keystr.c_str(), Context, resReponse);
		pResponse->update("CONTEXT", resReponse);

	}
	else if (cmd == PACKET_CMD_MSG)
	{
		FINFO("get CMD_UPDATE req:{$}", keystr.c_str());

		ret = DevMessage(m_strCCOSDevicePath.c_str(), keystr.c_str(), Context, resReponse);
		pResponse->update("CONTEXT", resReponse);

	}
	else if (cmd == PACKET_CMD_ADD)
	{
		FINFO("get CMD_ADD req:{$}", keystr.c_str());

		ret = DevAdd(m_strCCOSDevicePath.c_str(), keystr.c_str(), Context, resReponse);
		pResponse->update("CONTEXT", resReponse);

	}
	else if (cmd == PACKET_CMD_DEL)
	{
		FINFO("get CMD_DEL req:{$}", keystr.c_str());

		ret = DevDel(m_strCCOSDevicePath.c_str(), keystr.c_str(), Context, resReponse);
		pResponse->update("CONTEXT", resReponse);

	}
	else
	{
		//wtf?? 忽略掉
		return RET_SUCCEED;
	}


	PacketAnalizer::MakeRetCode((RET_STATUS)ret, pResponse);

	return (RET_STATUS)ret;
}