myvtm/Module/mod_ScannerSet/CameraOccupySysVar.hpp

 /***********************************//**
 * @file CameraOccupySysVar.hpp
 * @author Gifur
 * @email guifaliao@gmail.com
 * @version 1.0.0.0
 * @date 2021-06-21
 * @copyright China Merchants Bank Co.,Ltd All rights reserved
 *
 * @brief 
 * @details 
 **************************************/

#include "SpBase.h"

#define CMAERA_OCCUPY_SPLIT_MASK '$'
#define CMAERA_OCCUPY_SPLIT_MASK_STR "$"

struct OccpyCameraStruct 
{
	CSimpleStringA strCameraName;
	CSimpleStringA strOccupier;

	OccpyCameraStruct():strCameraName(true),strOccupier(true) {
	}

	OccpyCameraStruct(const char* camera, const char* occpuier)
		:strCameraName(camera),strOccupier(occpuier) {
	}

	OccpyCameraStruct(const OccpyCameraStruct& rhs)
		:strCameraName(rhs.strCameraName),strOccupier(rhs.strOccupier) {
	}

	OccpyCameraStruct(const char* value):strCameraName(true),strOccupier(true) {
		CSimpleStringA strValue(value);
		if(!strValue.IsNullOrEmpty()) {
			FromSysVarString(strValue);
		}
	}

	bool operator==(const OccpyCameraStruct& rhs)
	{
		return (strCameraName == rhs.strCameraName && strOccupier == rhs.strOccupier);
	}

	bool Match(const OccpyCameraStruct& rhs) {
		if(strCameraName == rhs.strCameraName && strOccupier == rhs.strOccupier)
			return true;
		if(rhs.strCameraName.Compare("*") == 0 && rhs.strOccupier.Compare("*") == 0)
			return true;
		if(rhs.strCameraName.Compare("*") == 0 && strOccupier == rhs.strOccupier)
			return true;
		if(rhs.strOccupier.Compare("*") == 0 && strCameraName == rhs.strCameraName)
			return true;

		return false;
	}

	bool IsValid() {
		return (!strCameraName.IsNullOrEmpty() && !strOccupier.IsNullOrEmpty());
	}

	bool IsValid() const {
		return (!strCameraName.IsNullOrEmpty() && !strOccupier.IsNullOrEmpty());
	}

	CSimpleStringA toSysVarString() const {
		CSimpleStringA result(strCameraName);
		result.Append("=");
		result.Append(strOccupier);
		return result;
	}

	bool FromSysVarString(CSimpleStringA& value) {
		CAutoArray<CSimpleStringA> infos = value.Split('=');
		if(infos.GetCount() != 2) {return false;}
		strCameraName = infos[0];
		strOccupier = infos[1];
		return true;
	}
};

 /*!
 * @brief 实时获取当前被占用的摄像头的名称和对应的实体
 * @param[in]  pFunc 框架接口，inFilter 过滤器，通过实体名称或者摄像头名称对要获取的内容进行过滤
 * @param[out] outOccupiedCamres 数组类型
 * @return : 
 */
static inline ErrorCodeEnum GetOccupiedCameres(CAutoArray<OccpyCameraStruct>& outOccupiedCamres,
	CSmartPointer<IEntityFunction> pFunc,
	const OccpyCameraStruct* inFilter = NULL)
{
	CSimpleStringA devicList;
	ErrorCodeEnum result = pFunc->GetSysVar("CameraOccupyingStatus", devicList);

	outOccupiedCamres.Clear();

	if(result == Error_Succeed && !devicList.IsNullOrEmpty()) {
		CSimpleStringA newValue;
		bool needToReplace = false;
		CAutoArray<CSimpleStringA> devItems = devicList.Split(CMAERA_OCCUPY_SPLIT_MASK);
		if(devItems.GetCount() > 0) {
			int counts = devItems.GetCount();
			if(inFilter != NULL) {
				counts = 0;
				for(int i=0; i<devItems.GetCount(); ++i) {
					OccpyCameraStruct item(devItems[i]);
					if(item.Match(*inFilter)) {
						counts++;
					}
				}
			}

			if(counts > 0) {
				outOccupiedCamres.Init(counts);
				int j=0;
				for(int i=0; i<devItems.GetCount(); ++i) {
					/*{deviceName1}={EntityName1}${deviceName2}={EntityName2}*/
					OccpyCameraStruct item(devItems[i]);
					if(inFilter == NULL || item.Match(*inFilter)) {
						outOccupiedCamres[j++] = item;
					}
				}
			}
		}
	}

	return result;
}

 /*!
 * @brief 添加到指定摄像头信息到系统变量
 * @param[in]  newItem，新插入的摄像头名称和实体名称，见 OccpyCameraStruct
 * @return : 
 * 如果摄像头和所占用的实体名称完全吻合，返回 Error_AlreadyExist
 * 如果摄像头已在但实体名称是其他实体，则返回 Error_Duplication
 * 成功添加返回 Error_Succeed
 */
static inline ErrorCodeEnum AppendOccpuiedCamera(
	const OccpyCameraStruct& newItem, CSmartPointer<IEntityFunction> pFunc)
{
	CAutoArray<OccpyCameraStruct> existedList;
	ErrorCodeEnum result = GetOccupiedCameres(existedList, pFunc);
	CSimpleStringA newValue;
	if(existedList.GetCount() > 0) {
		for (int i=0; i<existedList.GetCount(); ++i)
		{
			OccpyCameraStruct& item = existedList[i];
			if(item == newItem) {
				result = Error_AlreadyExist;
				break;
			} else if(newItem.strCameraName == item.strCameraName) {
				result = Error_Duplication;
				break;
			}

			if(!newValue.IsNullOrEmpty()) newValue.Append(CMAERA_OCCUPY_SPLIT_MASK_STR);
			newValue.Append(item.toSysVarString());
		}
	}

	if(result == Error_Succeed) {

		if(!newValue.IsNullOrEmpty()) newValue.Append(CMAERA_OCCUPY_SPLIT_MASK_STR);
		newValue.Append(newItem.toSysVarString());
		result = pFunc->SetSysVar("CameraOccupyingStatus", newValue);
	}

	return result;
}

 /*!
 * @brief 从系统变量中移除占用摄像头信息
 * @param[in]  existedItem 需要移除的摄像头和实体信息，支持将存储值为*，意为忽略此项的比较
 */
static inline void RemoveOccpuiedCamera(const OccpyCameraStruct& existedItem, CSmartPointer<IEntityFunction> pFunc)
{
	if(!existedItem.IsValid() || pFunc == NULL)
		return;

	CAutoArray<OccpyCameraStruct> existedList;
	ErrorCodeEnum result = GetOccupiedCameres(existedList, pFunc);
	bool needToUpdate = false;
	CSimpleStringA newValue(true);
	if(existedList.GetCount() > 0) {
		for (int i=0; i<existedList.GetCount(); ++i)
		{
			OccpyCameraStruct& item = existedList[i];
			if(item.Match(existedItem)) {
				needToUpdate = true;
				continue;
			}

			if(!newValue.IsNullOrEmpty()) newValue.Append(CMAERA_OCCUPY_SPLIT_MASK_STR);
			newValue.Append(item.toSysVarString());
		}
	}

	if(needToUpdate) {
		result = pFunc->SetSysVar("CameraOccupyingStatus", newValue);
	}
	return;
}

static inline ErrorCodeEnum GetCameraOccpuiedStatus(CEntityBase *pEntity,
	const char* lpsczDevName, CSimpleStringA& owner)
{
	OccpyCameraStruct filter(lpsczDevName, "*");
	CAutoArray<OccpyCameraStruct> existedList;
	owner.Clear();
	ErrorCodeEnum result = GetOccupiedCameres(existedList, pEntity->GetFunction(), &filter);
	if(existedList.GetCount() == 0) {
		result = Error_NotExist;
	}
	else if(existedList.GetCount() == 1) {
		owner = existedList[0].strOccupier;
	} else if(existedList.GetCount() > 0){
		result = Error_Duplication;
	}
	return result;
}


/*实体启动时调用一次，防止上次异常退出没有处理残留信息，导致出现摄像头被占用的假象*/
static void ResetOwnCameraOccupiedStatus(CEntityBase* pEntity)
{
	OccpyCameraStruct item("*", pEntity->GetEntityName());
	RemoveOccpuiedCamera(item, pEntity->GetFunction());
}

/*标明摄像头lpcszDevName被当前实体占用*/
static inline ErrorCodeEnum SetCameraOccpuied(const char* lpcszDevName, CEntityBase* pEntity)
{
	CSimpleStringA strTest(lpcszDevName);
	if(lpcszDevName == NULL || strTest.IsNullOrEmpty()
		|| strTest[0] == '*' 
		|| -1 != strTest.IndexOf(CMAERA_OCCUPY_SPLIT_MASK_STR) ||  -1 != strTest.IndexOf("=")) {
			return Error_Param;
	}

	OccpyCameraStruct item(lpcszDevName, pEntity->GetEntityName());
	ErrorCodeEnum result = AppendOccpuiedCamera(item, pEntity->GetFunction());
	if(result == Error_AlreadyExist)
		result = Error_Succeed;

	return result;
}

/*取消摄像头lpcszDevName被当前实体占用的标识*/
static inline void SetCameraUnoccpuied(const char* lpcszDevName, CEntityBase* pEntity)
{
	if(lpcszDevName == NULL || strlen(lpcszDevName) == 0) {
		return;
	}

	OccpyCameraStruct item(lpcszDevName, pEntity->GetEntityName());
	RemoveOccpuiedCamera(item, pEntity->GetFunction());
}

 /*!
 * @brief 通过系统变量判断摄像头是否在被其他实体占用
 * @param[in]  inOutCameraInfo.strCameraName 摄像头名称
 * @param[out] inOutCameraInfo.strOccupier 占用该摄像头的实体名称
 * @return : true: 被其他实体占用且该实体处于正常状态，不包括被当前实体占用
 */
static bool IsCameraOccupiedByOther(const char* lpcszDevName, CEntityBase* pEntity)
{
	OccpyCameraStruct filter(lpcszDevName, "*");
	CAutoArray<OccpyCameraStruct> existedList;
	ErrorCodeEnum result = GetOccupiedCameres(existedList, pEntity->GetFunction(), &filter);
	if(existedList.GetCount() > 0) {
		for(int i=0; i<existedList.GetCount(); ++i) {
			if(existedList[i].strOccupier.Compare(pEntity->GetEntityName()) != 0) {
				CEntityRunInfo info;
				result = pEntity->GetFunction()->GetEntityRunInfo(existedList[i].strOccupier, info);
				if(result == Error_Succeed
					&& (info.eState == EntityState_Idle || info.eState == EntityState_Busy 
					|| info.eState == EntityState_Pause
					 || info.eState == EntityState_UnLoading)) {
						 return true;
				}
			}
		}
	}
	return false;
}


#ifdef TWINKLE_LOCAL_DEBUG

/*测试案例*/
static int UniTest(CEntityBase* pEntity)
{
	OccpyCameraStruct camera0("*", "*");
	OccpyCameraStruct camera("FirstCamera", pEntity->GetEntityName());
	OccpyCameraStruct camera2("SecondCamera", "GUIConsole");
	OccpyCameraStruct camera3("SecondCamera", pEntity->GetEntityName());
	OccpyCameraStruct camera4("ThirdCamera", pEntity->GetEntityName());
	OccpyCameraStruct camera5("*", pEntity->GetEntityName());

	ResetOwnCameraOccupiedStatus(pEntity);
	//RemoveOccpuiedCamera(camera0, pEntity->GetFunction());

	CAutoArray<OccpyCameraStruct> existedList;
	ErrorCodeEnum result = GetOccupiedCameres(existedList, pEntity->GetFunction());
	if(result != Error_Succeed) {
		return __LINE__;
	}
	if(existedList.GetCount() != 0) {
		return __LINE__;
	}

	result = AppendOccpuiedCamera(camera, pEntity->GetFunction());
	if(result != Error_Succeed) {
		return __LINE__; 
	}

	if(IsCameraOccupiedByOther("FirstCamera", pEntity)) {
		return __LINE__; 
	}
	if(IsCameraOccupiedByOther("SecondCamera", pEntity)) {
		return __LINE__; 
	}

	result = AppendOccpuiedCamera(camera, pEntity->GetFunction());
	if(result != Error_AlreadyExist) {
		return __LINE__; 
	}

	result = AppendOccpuiedCamera(camera2, pEntity->GetFunction());
	if(result != Error_Succeed) {
		return __LINE__; 
	}
	if(!IsCameraOccupiedByOther("SecondCamera", pEntity)) {
		return __LINE__; 
	}

	result = AppendOccpuiedCamera(camera3, pEntity->GetFunction());
	if(result != Error_Duplication) {
		return __LINE__; 
	}

	result = GetOccupiedCameres(existedList, pEntity->GetFunction());
	if(result != Error_Succeed) {
		return __LINE__;
	}
	if(existedList.GetCount() != 2) {
		return __LINE__;
	}

	result = GetOccupiedCameres(existedList, pEntity->GetFunction(), &camera);
	if(existedList.GetCount() != 1) {
		return __LINE__;
	}

	if(!(existedList[0] == camera)) {
		return __LINE__;
	}

	result = AppendOccpuiedCamera(camera4, pEntity->GetFunction());
	if(result != Error_Succeed) {
		return __LINE__; 
	}
	result = GetOccupiedCameres(existedList, pEntity->GetFunction(), &camera5);
	if(existedList.GetCount() != 2) {
		return __LINE__;
	}

	result = GetOccupiedCameres(existedList, pEntity->GetFunction());
	if(result != Error_Succeed) {
		return __LINE__;
	}
	if(existedList.GetCount() != 3) {
		return __LINE__;
	}

	RemoveOccpuiedCamera(camera5, pEntity->GetFunction());
	result = GetOccupiedCameres(existedList, pEntity->GetFunction());
	if(result != Error_Succeed) {
		return __LINE__;
	}
	if(existedList.GetCount() != 1) {
		return __LINE__;
	}

	if(!(existedList[0] == camera2)) {
		return __LINE__;
	}

	RemoveOccpuiedCamera(camera2, pEntity->GetFunction());
	if(result != Error_Succeed) {
		return __LINE__;
	}

	//RemoveOccpuiedCamera(camera0, pEntity->GetFunction());

	AppendOccpuiedCamera(camera, pEntity->GetFunction());
	AppendOccpuiedCamera(camera3, pEntity->GetFunction());

	return 0;
}

#endif //TWINKLE_LOCAL_DEBUG