myvtm/Framework/Common/SpBase.h

#ifndef _RVC_SPBASE_H_
#define _RVC_SPBASE_H_

#pragma once

#include "PlatformDef.h"

#if defined(__cplusplus)

#ifdef SPABASE_LINKED_AS_STATIC_LIBRARY
	#define SPBASE_API
	#define EXPORT_DECLARE(retType) retType
#else //SPABASE_LINKED_AS_STATIC_LIBRARY
	#ifdef RVC_OS_WIN
		#ifdef SPBASE_EXPORTS
			#ifndef SPBASE_API
				#define SPBASE_API __declspec(dllexport)
			#endif
		#else
			#ifndef SPBASE_API
				#define SPBASE_API __declspec(dllimport)
			#endif
		#endif
		#define EXPORT_DECLARE(retType) __declspec(dllexport) retType
	# elif ( defined(__GNUC__) &&  __GNUC__ >= 4 )
		#define SPBASE_API __attribute__((visibility("default")))
		#define EXPORT_DECLARE(retType) __attribute__((visibility("default"))) retType
	#else // RVC_OS_WIN
		#define SPBASE_API
		#define EXPORT_DECLARE(retType) retType
	#endif // RVC_OS_WIN
#endif //SPABASE_LINKED_AS_STATIC_LIBRARY

#endif // __cplusplus


#ifdef RVC_OS_WIN
#ifndef u__int64_t
#define u__int64_t unsigned __int64
#endif //u__int64_t
#endif

#include <time.h> // for time_t
#ifdef RVC_OS_WIN
#include<wtypes.h>
#else
#include <winpr/library.h>
#include <winpr/synch.h>
#endif // RVC_OS_WIN

#if defined(__cplusplus)

#include "SmartPointer.h"
#include "SimpleString.h"
#include "AutoArray.h"

#endif // __cplusplus

#include "ErrorCode.h"

#ifndef MODULE_VERSION_FULL
	#define MODULE_VERSION_FULL  "0.0.0"
#endif


/** define the log message type */
enum LogTypeEnum
{
	Log_Ignore=0,						// ignore
	Log_Event=1,						// Run time event
	Log_Warning=2,					// Warning
	Log_Error=3,						// Error notify
	Log_Debug=4,						// debug alert ec.Assert
	Log_Fatal = 5,                     // Fatal notify
	Log_Notify = 6                     //User notify
};

/** define the framework internal behavior log */
enum DebugLevelEnum
{
	Debug_None = 0, // ignore
	Debug_Low,
	Debug_Middle,
	Debug_High,
};

/** The log message level */
enum SeverityLevelEnum
{
	Severity_None=0, // ignore
	Severity_Low,
	Severity_Middle,
	Severity_High
};

enum NotifyLevelEnum
{
	Notify_None = 0, // ignore
	Notify_Info,
	Notify_Warn,
	Notify_Error
};

enum InstallStateEnum
{
	Install_Active,				// A
	Install_Pending,			// I
	Install_SetToStart,			// S
	Install_FailRun,			// F
	Install_RollBack,			// R
	Install_Upgraded,			// U
	Install_Cancelled,			// C
	Install_WaitConfirm,		// W
	Install_Installed,			// D, only used to LightPack
};

/** framework state*/
enum FrameworkStateEnum
{
	FrameworkState_NotInit = 0,   /** the begin state*/
    FrameworkState_NotConfig,   /** the factory mode, not config*/
	FrameworkState_Booting,        /** the entity is starting*/
	FrameworkState_Running,       /** the machine has enter business page*/
	FrameworkState_Serving,        /** the machine is providing business service*/
	FrameworkState_Breakdown,   /** the machine is sick*/
	FrameworkState_Repairing,     /** the machine is being maintained*/
	FrameworkState_Upgrading,   /** the software is upgrading*/
	FrameworkState_Rollbacking, /** the software is rollback for some reason*/
	FrameworkState_Recoving,     /** the machine is reaching running state from other state*/
	FrameworkState_NotDisturb  /**/
};

/** entity state */
enum EntityStateEnum
{
	EntityState_NoStart=0,		  //no start before
	EntityState_Starting,			  //Entity is doing initial
	EntityState_Idle,				     //after started succeed,and have no work
	EntityState_Busy,				     //Doing Request-Answer,timing,and Pausing or coninuing work 
											     // have no see assignment anywhere [4/21/2020 17:38 Gifur]
	EntityState_Pause,			     //Pause state
	EntityState_UnLoading,		 //doing cleanning after trigger close
	EntityState_Lost,				     //Entity block not respond or exception
	EntityState_Close,				 //After close,start before
	EntityState_Killed,				 //The entity terminated as block state
	EntityState_Passed,              //The entity pass all test case
	EntityState_Failed                // The entity fail to pass the test case.
};

enum EntityCloseCauseEnum
{
	CloseCause_Self=0,			     //Trigger close byte self
	CloseCause_Other,			     //another entity terminate the entity
	CloseCause_Lost,			        //The entity is Lost state, has to be released
	CloseCause_Dragged,			//The same sp entity enter lost state,and has to be dragged to close
	CloseCause_ShellQuit,		    //shell end it as shell quit
	CloseCause_Crash,
};

/** session state */
enum SessionStateEnum
{
	SessionState_NotInit=0,
	SessionState_Live,
	SessionState_Pause,
	SessionState_Close,
};

/** reboot trigger reason code */
enum RebootTriggerEnum
{
	RebootTrigger_Unknown=0,	     //not alloc in api call.only not log for unknown reason so far
	RebootTrigger_Period,		         //daily or weekly
	RebootTrigger_FrameUpgrade,	 //reboot by update module，not reboot os
	RebootTrigger_OSUpgrade,	     //relate to outside the framework update, reboot os
	RebootTrigger_RollBack,		         //roll back to history version
	RebootTrigger_FailLoad,		         //load fail when framework start 
	RebootTrigger_Resource,		     //reboot by health manager
	RebootTrigger_RunExcepition,    //Exception lead to restart
	RebootTrigger_RunDead,		     //System is out of control in running ec watch dog reset or system dead
	RebootTrigger_Attacked,		    //framework is changed or invaded
	RebootTrigger_Powerdown,	    //Out side power is interrupt
	RebootTrigger_Repaired,		    //Framework has did some repair job in SafeLoad|Fault state and restart try to recover running
	RebootTrigger_ManualLocal,	     //reboot by local maintain
	RebootTrigger_ManualRemove,	//reboot by remote maintain
	RebootTrigger_Unsubscribe,	    //The life of machine is over,and will not connect to backstage again
	RebootTrigger_DeadForever,     //As some reason such as test failed, we want Framework dead and not reboot. TODO: let the Gardian know.
};

enum RebootWayEnum
{
	RebootWay_Unknown=0,		//If not log,only mark unknown
	RebootWay_Framework,		    //restart framework not os
	RebootWay_OS,				        //restart os not power
	RebootWay_Power,			        //restart os and power
};

enum EntityTestEnum
{
	Test_ShakeHand=0,
	Test_Examine, //no use at current time, even in selfcheck entity, they defined it but never call it.
	Test_Reset,
};

enum ConfigTypeEnum
{
	Config_Hardware,			//Read only, for read entity hardware file
	Config_Software,			    //Read and write
	Config_Run,					    //Read and write. create in run time can't be upgrade or conver
	Config_Shell,					//Read only, for read shell.ini file
	Config_Root,					//Read only, for read root.ini file
	Config_CenterSetting,   	//Read only
	Config_Cache					//Read and write, store at runcfg/Global.ini
};

enum ScreenEnum
{
	Screen_Operation=0,			              //just has a single Operation Screen
	Screen_OpAndInfo=1,			              //has double screen Operation screen and information screen
	Screen_OpAndMaintain=8,		          //has Operation screen and Maintain screen
	Screen_OpAndInfoAndMaintain=9, //has 3 screen Operation screen and information screen and Maintain screen
};

enum EntityPriorityEnum
{
	Priority_Low,
	Priority_Below_Normal,
	Priority_Normal,
	Priority_Above_Normal,
	Priority_High,
	Priority_Highest,
	Priority_Unknown
};

#if defined(__cplusplus)
/** for sp-software and acm machine version type */
class CVersion
{
private:
	union
	{
		u__int64_t m_nVersion64;
		struct//Intel CPU byte order,otherwise ,need to redefine
		{
			WORD m_nBuild;
			WORD m_nRevision;
			union
			{
				DWORD m_nVersion32;
				struct
				{
					WORD m_nMinor;
					WORD m_nMajor;
				};
			};
		};
	};
public:
	inline WORD GetMajor(){return m_nMajor;}
	inline WORD GetMinor(){return m_nMinor;}
	inline WORD GetRevision(){return m_nRevision;}
	inline WORD GetBuild(){return m_nBuild;}
	inline u__int64_t GetVersion64(){return m_nVersion64;}
	inline DWORD GetVersion32(){return m_nVersion32;}
	inline CSimpleStringA ToString(){return CSimpleStringA::Format("%d.%d.%d.%d",m_nMajor,m_nMinor,m_nRevision,m_nBuild);}
	inline bool operator ==(CVersion &Version){return m_nVersion64==Version.m_nVersion64;}
	inline bool operator !=(CVersion &Version){return m_nVersion64!=Version.m_nVersion64;}
	inline bool operator <(CVersion &Version){return m_nVersion64<Version.m_nVersion64;}
	inline bool operator >(CVersion &Version){return m_nVersion64>Version.m_nVersion64;}
	inline bool operator <=(CVersion &Version){return m_nVersion64<=Version.m_nVersion64;}
	inline bool operator >=(CVersion &Version){return m_nVersion64>=Version.m_nVersion64;}
	inline bool IsCompatible(CVersion &Version){return m_nVersion32==Version.m_nVersion32;}
	inline bool IsUpgrade(CVersion &Version){return m_nVersion32>Version.m_nVersion32;}
	inline CVersion &operator=(const CVersion &Version){m_nVersion64=Version.m_nVersion64;return *this;}
	inline CVersion(WORD nMajor,WORD nMinor):m_nMajor(nMajor),m_nMinor(nMinor),m_nRevision(0),m_nBuild(0){}
	inline CVersion(WORD nMajor,WORD nMinor,WORD nRevision,WORD nBulid):m_nMajor(nMajor),m_nMinor(nMinor),m_nRevision(nRevision),m_nBuild(nBulid){}
	inline CVersion(const CVersion &Version):m_nVersion64(Version.m_nVersion64){}
	inline CVersion() : m_nVersion64(0) {}
	inline CVersion(__int64 nVersion) : m_nVersion64(nVersion){}
	inline bool IsValid(){return m_nVersion64 >0;}
};

SPBASE_API void GetLibVersion(CVersion& version);

SPBASE_API LPCSTR GetLibBuildDate();

class SPBASE_API CSmallDateTime
{
	/** 单位是秒 [Gifur@2022324]*/
	DWORD m_nTimeTicks;
public:
	static CSmallDateTime BeginTime; 
	static CSmallDateTime EndTime;
	static CSmallDateTime GetNow();
	inline CSmallDateTime(DWORD nTimeTicks = 0):m_nTimeTicks(nTimeTicks){}
	inline CSmallDateTime(const CSmallDateTime &DateTime):m_nTimeTicks(DateTime.m_nTimeTicks){}
	inline operator DWORD () const{return m_nTimeTicks;}
	inline const CSmallDateTime & operator =(const CSmallDateTime &DateTime){m_nTimeTicks=DateTime.m_nTimeTicks;return *this;}
	inline bool operator ==(const CSmallDateTime &DateTime){return m_nTimeTicks==DateTime.m_nTimeTicks;}
	inline bool operator !=(const CSmallDateTime &DateTime){return m_nTimeTicks!=DateTime.m_nTimeTicks;}
	inline bool operator <(const CSmallDateTime &DateTime){return m_nTimeTicks<DateTime.m_nTimeTicks;}
	inline bool operator >(const CSmallDateTime &DateTime){return m_nTimeTicks>DateTime.m_nTimeTicks;}
	inline bool operator <=(const CSmallDateTime &DateTime){return m_nTimeTicks<=DateTime.m_nTimeTicks;}
	inline bool operator >=(const CSmallDateTime &DateTime){return m_nTimeTicks>=DateTime.m_nTimeTicks;}

	__time64_t GetTime64();
	/** format string: YYYY-MM-DD hh:mm:ss*/
	CSimpleStringA ToTimeString();
	SYSTEMTIME ToSystemTime();
	void FromSystemTime(const SYSTEMTIME &st);
};

class SPBASE_API CUUID
{

#ifdef RVC_OS_WIN
#if (!defined(SPABASE_LINKED_AS_STATIC_LIBRARY) && !defined(SPBASE_EXPORTS))
protected:
#else
public:
#endif
#else
public:
#endif //RVC_OS_WIN

	union//Intel CPU byte order,otherwise the need to redefine
	{
		u__int64_t m_nUUID64;
		struct
		{
			WORD m_nAppID;			//the id of the server
			WORD m_nDsn;				//inner a Second serial
			DWORD m_nTimeTicks;
		};
	};
	static WORD m_gAppID;
public:
	inline CUUID(const CUUID &UUID):m_nUUID64(UUID.m_nUUID64){}
	inline CUUID(u__int64_t nUUID64 = 0):m_nUUID64(nUUID64){}
	inline CSmallDateTime GetTime(){return m_nTimeTicks;}
	inline operator u__int64_t () const{return m_nUUID64;}
	inline const CUUID & operator =(const CUUID &UUID){m_nUUID64=UUID.m_nUUID64;return *this;}
	inline bool operator ==(const CUUID &UUID){return m_nUUID64==UUID.m_nUUID64;}
	inline bool operator !=(const CUUID &UUID){return m_nUUID64!=UUID.m_nUUID64;}
	inline bool operator <(const CUUID &UUID){return m_nUUID64<UUID.m_nUUID64;}
	inline bool operator >(const CUUID &UUID){return m_nUUID64>UUID.m_nUUID64;}
	inline bool operator <=(const CUUID &UUID){return m_nUUID64<=UUID.m_nUUID64;}
	inline bool operator >=(const CUUID &UUID){return m_nUUID64>=UUID.m_nUUID64;}
	inline DWORD GetAppID() const {return m_nAppID;}
	inline CSimpleStringA ToString() const { return CSimpleStringA::Format("%016llX", m_nUUID64); }
	static CUUID Create(const CUUID &LastUUID);
	static CUUID Create(const CUUID& LastUUID, const CSmallDateTime& DateTime);
};

/** for GPS, for longitude, east is +, west is -, for latitude, north is +, south is - */
/*   e.g. N22:33:09 convert to float is 22.5525 */
class SPBASE_API CSphereVector
{
private:
	float m_fLongitude;
	float m_fLatitude;
public:
	inline float GetLongitude(){return m_fLongitude;}
	inline float GetLatitude(){return m_fLatitude;}
	inline CSphereVector(float fLongitude,float fLatitude):m_fLongitude(fLongitude),m_fLatitude(fLatitude){}
	inline CSphereVector() : m_fLatitude(0), m_fLongitude(0) {}
	/*将浮点型的经度转成度分秒表示法，第4个字节表示经度方向，负浮点数表示西部，返回'W'，正浮点数表示东部，返回 'E'*/
	void GetBinaryLongitude(BYTE longitude[4]);
	/*将浮点型的纬度转成度分秒表示法，第4个字节表示纬度方向，负浮点数表示南部，返回'S'，正浮点数表示北部，返回 'N'*/
	void GetBinaryLatitude(BYTE latitude[4]);
};

struct CInstallInfo
{
	CVersion PreviousInstallVersion;
	CVersion InstallVersion;
	CSmallDateTime tmSwithOverDate;
	CSimpleStringA InstallPack;
	InstallStateEnum InstallState;
};
struct CLightPackInfo
{
	CSimpleStringA  strPackName;
	CSmallDateTime tmInstalledDate;
	InstallStateEnum State;
};

#define LINKINFO_BUSSID_LEN			32
#define LINKINFO_TRACEID_LEN		32
#define LINKINFO_SPANID_LEN			16
#define LINKINFO_PARENTSPANID_LEN	16

SPBASE_API CSimpleStringA uuid4_generateStr(int len);

struct linkContext
{
	CSimpleStringA bussinessId;
	CSimpleStringA traceId;
	CSimpleStringA spanId;
	CSimpleStringA parentSpanId;

	linkContext():bussinessId(true), traceId(true), spanId(true), parentSpanId(true){}
	linkContext(CSimpleStringA t_bussinessId, CSimpleStringA t_traceId, CSimpleStringA t_spanId, CSimpleStringA t_parentSpanId) {
		bussinessId = t_bussinessId;
		traceId = t_traceId;
		spanId = t_spanId;
		parentSpanId = t_parentSpanId;
	}

	void Init(const char* t_bussId, const char* t_traceId, const char* t_spanId, const char* t_parentSpanId)
	{
		if (t_bussId && t_traceId && t_spanId && t_parentSpanId)
		{
			char copy_bussId[LINKINFO_BUSSID_LEN + 1], copy_traceId[LINKINFO_TRACEID_LEN + 1];
			char copy_spanId[LINKINFO_SPANID_LEN + 1], copy_parentSpanId[LINKINFO_PARENTSPANID_LEN + 1];
			memset(copy_bussId, 0, sizeof(copy_bussId));
			memset(copy_traceId, 0, sizeof(copy_traceId));
			memset(copy_spanId, 0, sizeof(copy_spanId));
			memset(copy_parentSpanId, 0, sizeof(copy_parentSpanId));
			memcpy(copy_bussId, t_bussId, LINKINFO_BUSSID_LEN);
			memcpy(copy_traceId, t_traceId, LINKINFO_TRACEID_LEN);
			memcpy(copy_spanId, t_spanId, LINKINFO_SPANID_LEN);
			memcpy(copy_parentSpanId, t_parentSpanId, LINKINFO_PARENTSPANID_LEN);
			bussinessId = copy_bussId;
			traceId = copy_traceId;
			spanId = copy_spanId;
			parentSpanId = copy_parentSpanId;
		}
	}

	linkContext& operator=(const linkContext& tmp) {
		bussinessId = tmp.bussinessId;
		traceId = tmp.traceId;
		spanId = tmp.spanId;
		parentSpanId = tmp.parentSpanId;
		return *this;
	}
	void clear() {
		bussinessId = "";
		traceId = "";
		spanId = "";
		parentSpanId = "";
	}

	linkContext upgradeLink() const {
		if (bussinessId.GetLength() == 0 || traceId.GetLength() == 0)
			return *this;
		else
			return linkContext(bussinessId, traceId, uuid4_generateStr(LINKINFO_SPANID_LEN), spanId);
	}

	linkContext upgradeLinkAndSave() {
		if (bussinessId.GetLength() == 0 || traceId.GetLength() == 0)
			return *this;
		else {
			spanId = uuid4_generateStr(LINKINFO_SPANID_LEN);
			parentSpanId = spanId;
			return *this;
		}
	}

	bool checkEmpty() const {
		return (bussinessId.GetLength() == 0 || traceId.GetLength() == 0);
	}

	void AutoGenerate() {
		bussinessId = "VTMAutoGen";
		traceId = uuid4_generateStr(LINKINFO_TRACEID_LEN);
		spanId = uuid4_generateStr(LINKINFO_SPANID_LEN);
		parentSpanId = "0";
	}
};

/** acm machine info, information filled at installation, at root.ini */
struct CSystemStaticInfo : public CInstallInfo
{
	CSystemStaticInfo() :
		strTerminalID(""),
		strMachineType(""),
		eScreen(ScreenEnum::Screen_Operation),  // 设置一个默认值
		nTotalRunCount(0),  // 初始化为 0 或其他适当的默认值
		nTodayRunCount(0),  // 初始化为 0 或其他适当的默认值
		tmCreateDate(),     // 使用默认构造函数初始化 SmallDateTime
		tmCurrentTime(),    // 使用默认构造函数初始化 SmallDateTime
		strSite(""),
		EnrolGPS(),
		strEnrolAddr(""),
		strManufacturer(""),
		strMachineModel(""),
		strMachineSN("")
	{
		// 在构造函数中进行额外的初始化工作，如果需要的话
	}
	CSimpleStringA strTerminalID;
	CSimpleStringA strMachineType;
	CVersion MachineVersion;
	ScreenEnum eScreen;
	CVersion LatterInstallVersion;				// 0 version for none
	CAutoArray<CLightPackInfo> LightPackInfos;
	WORD nTotalRunCount;
	WORD nTodayRunCount;
	CSmallDateTime tmCreateDate;
	CSmallDateTime tmCurrentTime;
	CSimpleStringA strSite;
	CSphereVector EnrolGPS;
	CSimpleStringA strEnrolAddr;
	CSimpleStringA strManufacturer;
    CSimpleStringA strMachineModel;
    CSimpleStringA strMachineSN;
};

/** map to spshell launch options.*/
enum SystemBootOptionEnum
{
	BootOption_Default = 0,
	BootOption_Test      = 1,                  /** mapping to sp_cfg::sp_cfg_start_args_t::test_mode & 1 */
	BootOption_Entity   = (1 << 1),       /** mapping to sp_cfg::sp_cfg_start_args_t::start_entities flag */
	BootOption_Debug = (1 << 2),       /** mapping to sp_cfg::sp_cfg_start_args_t::debug_mode */
	BootOption_Benchmark = (1 << 3), /** mapping to sp_cfg::sp_cfg_start_args_t::test_mode & 2*/
	BootOption_RootPrivilege = (1 << 4), /** run as root privilege*/
	BootOption_ST = (1 << 5), /** run as st mode, mapping to sp_cfg::sp_cfg_start_args_t::test_mode & 4*/
	BootOption_UAT = (1 << 6) /** run as uat mode,mapping to sp_cfg::sp_cfg_start_args_t::test_mode & 8*/
};

/** acm system startup info */
struct CSystemRunInfo
{
	CSmallDateTime tmStart;
	DebugLevelEnum eDebugLevel;
	FrameworkStateEnum eState;
	DWORD dwBootOption;
	CAutoArray<CSimpleStringA> strRunningEntityNames;
	bool bBasicCfgWork;
	bool bErrCfgWork;
};

/** boot info */
struct CBootInfo
{
	CVersion InstallVersion;
	CSmallDateTime tmStart;					//the system start run time
	CSmallDateTime tmReboot;					//The trigger reboot time and It is end of run from StartTime
	RebootTriggerEnum eTriggerReason;
	RebootWayEnum eWay;
	WORD wSameReasonTime;
	WORD wSameWayTime;
};

/** sp module info */
struct CSpInfo
{
	CSimpleStringA strAuthor;
	CSimpleStringA strCompany;
	CVersion SoftwareVersion;
	CAutoArray<CSimpleStringA> strEntitys;
};

/** entity configuration data */
struct CEntityStaticInfo
{
	WORD wEntityDevelopID;
	bool bStartedByShell;				//config start by shell or not(other Entity)
	bool bHasPrivilege;					//can support IEntityFunctionPrivilege interface
	bool bIndispensable;				//must be start and work correct else framework will fall into "Fault" state
	CSimpleStringA strSpFileName;
	CVersion version;
};

/** entity session info */
struct CEntitySessionInfo
{
	CSimpleStringA strCallerEntity;
	CSimpleStringA strServiceEntity;
	CSmallDateTime tmStart;
	SessionStateEnum eState;
	CSmallDateTime tmBeginState;
};

struct CEntityStartInfo
{
	/** 应用当前实体的启动次数*/
    int startTimes;
	/** 收到启动实体的时间戳，第一次有效*/
    SYSTEMTIME startTime;
	/** 完成加载实体模块的时间戳，第一次有效，不判断是否加载失败*/
    SYSTEMTIME InitEndTime;
	/** 完成启动实体模块时间戳，第一次有效，不判断是否启动失败*/
    SYSTEMTIME startEndTime;
};

struct CEntityLastErrorInfo
{
    ErrorCodeEnum eSysCode;
    DWORD dwUserCode;
    CSimpleStringA strErrMsg;
};

/** entity running info */
struct CEntityRunInfo
{
	DWORD dwEntityInstanceID;
	CSmallDateTime tmFirstStart;		//The Entity first started after framework start
	CSmallDateTime tmLastStart;			//The nearest started of this entity instance
	bool bService;
	EntityStateEnum eState;
	CSmallDateTime tmBeginCurrentState;
	DebugLevelEnum eDebugLevel;
	DWORD dwUserState;					//Self define state
	DWORD dwProcessID;					//Process ID of os
};

/** entity log info */
struct CEntityLogInfo
{
	CSimpleStringA strLogPath;
};

struct BroadcastSubscribeInfo
{
	CUUID SubID;
	CSimpleStringA strListener; // from entity's name
	CSimpleStringA strParam;
};

struct IReleasable
{
	virtual ~IReleasable(){};
};

/** 
 * entity timer for user, the timer will initialize when user call IEntityFunction::SetTimer,
 * until user call KillTimer
 * note: nTimerID is application defined value in Entity Scope !!!
 */
struct ITimerListener
{
	virtual void OnTimeout(DWORD dwTimerID) = 0;
};

/** subcribe-public pattern, sys variable used for tracking system-level events  */
struct ISysVarListener
{
	virtual void OnSysVarEvent(const char *pszKey,
		const char *pszValue,const char *pszOldValue,const char *pszEntityName)=0;
};
struct ITerminalStateChangedListener
{
	virtual void OnStateChanged(FrameworkStateEnum oldState, FrameworkStateEnum curState, const char* triggerEntity) = 0;
};

struct IBroadcastListener
{
	virtual void OnBroadcastEvent(CUUID SubID, const char* pszEntityName, DWORD dwMessageId, DWORD dwMessageSignature, CAutoBuffer Buffer) = 0;
};

struct IEntityLifeListener
{
	/* if pszTriggerEntity=null mean created by shell*/
	virtual void OnCreated(const char* pszEntityName, ErrorCodeEnum eOnStartErrorCode, const char* pszCallerEntity) = 0;
	/*Call after the entity has close or killed, eOnCloseErrorCode notic if the entity do OnClose normally and resource has beed release*/
	virtual void OnClosed(const char* pszEntityName, EntityCloseCauseEnum eCloseCause, ErrorCodeEnum eOnCloseErrorCode, const char* pszCallerEntity) = 0;
	/*1 case is entity raise exception and catch by framework,but not mean the entity will close,2 case is the entity is enter lost state*/
	virtual void OnException(const char* pszEntityName, const char* pszFunctionName, EntityStateEnum eState, EntityStateEnum eLastState, ErrorCodeEnum eErrorCode) = 0;
};

struct IEntityStateListener
{
	virtual void OnEntityStateHook(const char* pszEntityName, const char* pszTriggerEntity, EntityStateEnum eState, EntityStateEnum eLastState) = 0;
	virtual void OnUserStateHook(const char* pszEntityName, DWORD dwState, DWORD dwLastState) = 0;
	virtual void OnCeateConnection(const char* pszCallerEntity, const char* pszServiceEntity) = 0;
	virtual void OnCloseConnection(const char* pszCallerEntity, const char* pszServiceEntity) = 0;
};

/** log hooker */
struct ILogListener
{
	virtual void OnLog(const CAutoArray<CUUID>& SubIDs, const CUUID nLogID, const LogTypeEnum eLogType, const SeverityLevelEnum eLevel,
		const DWORD dwSysError, const DWORD dwUserCode, const DWORD dwEntityInstanceID, const WORD wEntityDevelID,
		const CAutoArray<DWORD>& Param, const char* pszEntityName, const char* pszModuleName, const char* pszMessage, const linkContext& pLinkInfo) = 0;
};


struct IConfigInfo
{
	virtual ConfigTypeEnum GetConfigType() = 0;
	virtual bool storageInMem() = 0;

	/** read/write config via shell */
	virtual ErrorCodeEnum ReadConfigValue(const char* pszSection, const char* pszKey, CSimpleStringA& strValue) = 0;
	virtual ErrorCodeEnum ReadConfigValueInt(const char* pszSection, const char* pszKey, int& iValue) = 0;

	/** only can write self's section, pValue=NULL for delete */
	virtual ErrorCodeEnum WriteConfigValue(const char* pszSection, const char* pszKey, const char* pszValue) = 0;
	virtual ErrorCodeEnum WriteConfigValueInt(const char* pszSection, const char* pszKey, int iValue) = 0;

	/** read all key-value pairs */
	virtual ErrorCodeEnum ReadAllKeys(const char* pszSection, CAutoArray<CSimpleStringA>& strKeys) = 0;

	/** get all section values */
	virtual ErrorCodeEnum ReadAllSections(CAutoArray<CSimpleStringA>& strSections) = 0;

	/** write hex int values, ig: "keyName=0x4F3D012A" */
	virtual ErrorCodeEnum WriteConfigValueHexInt(const char* pszSection, const char* pszKey, UINT64 nValue) = 0;
	virtual ErrorCodeEnum ReadConfigValueHexInt(const char* pszSection, const char* pszKey, UINT64& nValue) = 0;
};

struct IAsynWaitSp;

/** invoked when receive answer from remote */
struct ICallbackListener
{
	virtual void OnAnswer(CSmartPointer<IAsynWaitSp> pAsynWaitSp) = 0;
};

struct IEntityPersistObject;

/** object serialize mechanism, reader interface  */
struct IEntityPersistStreamRead
{
	virtual ErrorCodeEnum Get(const char* pszKey, CSimpleStringA& strValue) = 0;
	virtual ErrorCodeEnum Get(const char* pszKey, ULONGLONG& qwValue) = 0;
	virtual ErrorCodeEnum Get(const char* pszKey, DWORD& dwValue) = 0;
	virtual ErrorCodeEnum Get(const char* pszKey, WORD& wValue) = 0;
	virtual ErrorCodeEnum Get(const char* pszKey, BYTE& cValue) = 0;
	virtual ErrorCodeEnum Get(const char* pszKey, FLOAT& fValue) = 0;
	virtual ErrorCodeEnum Get(const char* pszKey, DOUBLE& fValue) = 0;
	virtual ErrorCodeEnum Get(const char* pszKey, IEntityPersistObject* pValue) = 0;
	virtual ErrorCodeEnum GetArray(const char* pszKey, CAutoArray<CSimpleStringA>& strValues) = 0;
	virtual ErrorCodeEnum GetArray(const char* pszKey, CAutoArray<ULONGLONG>& qwValues) = 0;
	virtual ErrorCodeEnum GetArray(const char* pszKey, CAutoArray<DWORD>& dwValues) = 0;
	virtual ErrorCodeEnum GetArray(const char* pszKey, CAutoArray<WORD>& wValues) = 0;
	virtual ErrorCodeEnum GetArray(const char* pszKey, CAutoArray<BYTE>& cValues) = 0;
	virtual ErrorCodeEnum GetArray(const char* pszKey, CAutoArray<FLOAT>& fValues) = 0;
	virtual ErrorCodeEnum GetArray(const char* pszKey, CAutoArray<DOUBLE>& fValues) = 0;
};

/** object serialize mechanism, writer interface  */
struct IEntityPersistStreamWrite
{
	virtual ErrorCodeEnum Set(const char* pszKey, const char* pszValue) = 0;
	virtual ErrorCodeEnum Set(const char* pszKey, const ULONGLONG qwValue) = 0;
	virtual ErrorCodeEnum Set(const char* pszKey, const DWORD dwValue) = 0;
	virtual ErrorCodeEnum Set(const char* pszKey, const WORD wValue) = 0;
	virtual ErrorCodeEnum Set(const char* pszKey, const BYTE cValue) = 0;
	virtual ErrorCodeEnum Set(const char* pszKey, const FLOAT fValue) = 0;
	virtual ErrorCodeEnum Set(const char* pszKey, const DOUBLE fValue) = 0;
	virtual ErrorCodeEnum Set(const char* pszKey, const IEntityPersistObject* pValue) = 0;
	virtual ErrorCodeEnum SetArray(const char* pszKey, const CAutoArray<CSimpleStringA>& strValues) = 0;
	virtual ErrorCodeEnum SetArray(const char* pszKey, const CAutoArray<ULONGLONG>& qwValues) = 0;
	virtual ErrorCodeEnum SetArray(const char* pszKey, const CAutoArray<DWORD>& dwValues) = 0;
	virtual ErrorCodeEnum SetArray(const char* pszKey, const CAutoArray<WORD>& wValues) = 0;
	virtual ErrorCodeEnum SetArray(const char* pszKey, const CAutoArray<BYTE>& cValues) = 0;
	virtual ErrorCodeEnum SetArray(const char* pszKey, const CAutoArray<FLOAT>& fValues) = 0;
	virtual ErrorCodeEnum SetArray(const char* pszKey, const CAutoArray<DOUBLE>& fValues) = 0;
};

/** object serialize mechanism, user-defined object need to inherits from this */
struct IEntityPersistObject
{
	virtual ErrorCodeEnum OnRead(CSmartPointer<IEntityPersistStreamRead> pStream) = 0;
	virtual ErrorCodeEnum OnWrite(CSmartPointer<IEntityPersistStreamWrite> pStream) const = 0;
};

/** task interface */
struct ITaskSp
{
	ITaskSp() : m_ref_cnt(1) {}
	virtual ~ITaskSp() {}
	virtual void IncRef() { InterlockedIncrement(&m_ref_cnt); }
	virtual void DecRef() { if (0 == InterlockedDecrement(&m_ref_cnt)) { delete this; } }
	virtual void Process() = 0;
private:
	LONG m_ref_cnt;
};

class CClientSessionBase;
class CServerSessionBase;

struct IEntityFunctionPrivilege;

//typedef int (*postLink)(const char *bussinessId, const char *traceId, const char *spanId, const char *parentSpanId);
/** normal entity service */
struct IEntityFunction
{
	virtual ~IEntityFunction() {}

	/** get CSystemStaticInfo information */
	virtual ErrorCodeEnum GetSystemStaticInfo(CSystemStaticInfo& Info) = 0;
	virtual ErrorCodeEnum GetInstallInfo(CVersion Version, CInstallInfo& Info) = 0;	//include latter/current/history version
	virtual bool IsPackInstalled(const char* pPackName) = 0;

	/**
	 * get path define in Root.ini,
	 * pszKey : "Data", "Rec", "Temp", "SysLog", "InterLog","UploadVideo","UploadPhoto","Downloads","Upgraded","LatterInstall","Run","SysRoot","CenterSetting"
	 */
	virtual ErrorCodeEnum GetPath(const char* pszKey, CSimpleStringA& strPath) = 0;

	/** get system running info */
	virtual ErrorCodeEnum GetSystemRunInfo(CSystemRunInfo& Info) = 0;
	/** get busy entity number and startup entity number */
	virtual ErrorCodeEnum GetEntityBusyRate(WORD& nBusyEntity, WORD& nAllEntity) = 0;

	/** get reboot info,if BeforeThisTime=CSmallDateTime::BeginTime,then return last time boot info,else return the start time before BeforeThisTime record*/
	virtual ErrorCodeEnum GetRebootInfo(CSmallDateTime BeforeThisTime, CBootInfo& Info) = 0;

	/** get all sp entity module file name without full path */
	virtual ErrorCodeEnum GetAllRegistSpFile(CAutoArray<CSimpleStringA>& strSpNames) = 0;

	/** get sp file info */
	virtual ErrorCodeEnum GetSpFileInfo(const char* pszSpName, CSpInfo& Info) = 0;

	/** get all registered entity name */
	virtual ErrorCodeEnum GetAllRegistedEntity(CAutoArray<CSimpleStringA>& strEntityNames, CAutoArray<WORD>& wEntityDevelopIDs) = 0;
	virtual ErrorCodeEnum GetAllStartedEntity(CAutoArray<CSimpleStringA>& strEntityNames, CAutoArray<DWORD>& dwEntityInstanceIDs) = 0;

	/** get the entity of the current process running info */
	virtual ErrorCodeEnum GetSelfEntityRunInfo(CEntityRunInfo& Info) = 0;

	/** get entity config info */
	virtual ErrorCodeEnum GetEntityStaticInfo(const char* pszEntityName, CEntityStaticInfo& Info) = 0;
	//virtual ErrorCodeEnum GetEntityStaticInfo(WORD wEntityDevelopID,CEntityStaticInfo &Info)=0;

	/** get entity state via shell 	 */
	virtual ErrorCodeEnum GetEntityRunInfo(const char* pszEntityName, CEntityRunInfo& Info) = 0;

	/** get entity all session info */
	virtual ErrorCodeEnum GetEntitySessionInfo(const char* pszEntityName, CAutoArray<CEntitySessionInfo>& Infos) = 0;

	/** get entity name from instance entity ID */
	virtual ErrorCodeEnum GetEntityName(DWORD dwEntityInstanceID, CSimpleStringA& strName) = 0;
	/** get entity name from develop entity ID */
	virtual ErrorCodeEnum GetEntityName(WORD wEntityDevelopID, CSimpleStringA& strName) = 0;

	/** ini file reader/writer utility */
	virtual ErrorCodeEnum OpenConfig(ConfigTypeEnum eConfigType, CSmartPointer<IConfigInfo>& pConfigInfo, bool forceFile = false) = 0;

	/** Set self define state enum for out side notice */
	virtual ErrorCodeEnum SetUserDefineState(DWORD dwState) = 0;
	virtual DWORD GetUserDefineState() = 0;

	/** only the entity has been set in shell.ini can change the value*/
	virtual ErrorCodeEnum SetSysVar(const char* pszKey, const char* pszValue, bool bPersist = false) = 0;

	/** get sys variable value */
	virtual ErrorCodeEnum GetSysVar(const char* pszKey, CSimpleStringA& strValue) = 0;


	virtual ErrorCodeEnum GetAllEntityStartInfo(CAutoArray<CSimpleStringA>& strEntityNames, CAutoArray<int>& strEntityIdx, CAutoArray<CEntityStartInfo>& Infos) = 0;

	/** get entity log path via shell 	 */
	virtual ErrorCodeEnum GetEntityLogPath(const char* pszEntityName, CEntityLogInfo& Info) = 0;


	virtual WORD GetDevID() = 0;
	/**
	 * install sys variable
	 * @param pszKey the sys var key you want subscribe
	 * @param pListener user callback interface
	 * @param dwSysEventID user defined ID, must be unique in entity scope
	 */
	virtual ErrorCodeEnum RegistSysVarEvent(const char* pszKey, ISysVarListener* pListener) = 0;
	/*if pszKey=NULL mean unregist all keys event*/
	virtual ErrorCodeEnum UnregistSysVarEvent(const char *pszKey)=0;

	/*!
	 * @brief 
	 * @param pListener the sub class boject pointer inherit ITerminalStateChangedListener and implement 
	 *                OnStateChanged interface.
	 * @return : Error_Succeed if regist successfully, other means failure.
	 */
	virtual ErrorCodeEnum RegistTerminalStateChangeEvent(ITerminalStateChangedListener* pListener) = 0;

	/*!
	 * @brief 
	 * @return : Error_Succeed if unregist successfully
	 */
	virtual ErrorCodeEnum UnregistTerminalStateChangeEvent() = 0;

	/**
	 * every entity can broadcast messages, user entity can subscribe an entity's broadcast messages
	 */
	virtual ErrorCodeEnum SendBroadcast(DWORD dwMessageId, DWORD dwMessageSignature, CAutoBuffer Buffer) = 0;
	virtual ErrorCodeEnum GetBroadcastReceivers(CAutoArray<BroadcastSubscribeInfo>& Subscribers) = 0;
	virtual ErrorCodeEnum SubscribeBroadcast(const char* pszRemoteEntity, const char* pszParam, IBroadcastListener* pListener, CUUID& SubscribeID) = 0;
	virtual ErrorCodeEnum UnsubscribeBroadcast(CUUID SubscribeID) = 0;
	virtual ErrorCodeEnum UnsubscribeBroadcast(const char* pszRemoteEntity) = 0;

	/**
	 * subscribe log via shell
	 * @param listener user's specific callback, null to cancel
	 * @param eLevel will get log more(or equal) importance than eLevel,
	 * @param pszEntityName if not null will get log only for that "pszEntityName" appoint one
	 * @param eSysError Error_IgnoreAll means accept any sys error
	 * @param dwUserCode -2 means accept any user code, -1 means accept log which has user code(nonzero)
	 * @param bIgnoreMessage if true then pszMessage will not be send to save bandwidth
	 */
	virtual ErrorCodeEnum SubscribeLog(CUUID& SubscribeID, ILogListener* pListener, LogTypeEnum eLogType = Log_Ignore, SeverityLevelEnum eLevel = Severity_None,
		ErrorCodeEnum eSysError = Error_IgnoreAll, DWORD dwUserCode = 0, const char* pszEntityName = NULL, bool bIgnoreMessage = true) = 0;
	virtual ErrorCodeEnum UnsubscribeLog(CUUID SubscribeID) = 0;

	/** force shell to dump a log file */
	virtual ErrorCodeEnum FlushLogFile() = 0;

	/**
	 * read persist object from framework's serialize directory
	 * @param pszClass which class the object belongs
	 * @param pszKey the object key, key is case-sensitive!!!
	 * note: actually this object stores at dir %syspath%/Objects/<EntityName>/pszClass/pszKey
	 * so pszClass and pszKey cannot contains chars which os file path specification forbidden, such as *, ?
	 */
	virtual ErrorCodeEnum ReadPersistObject(const char* pszClass, const char* pszKey, IEntityPersistObject* pInstance) = 0;

	/** write persist object to framework's serialize directory */
	virtual ErrorCodeEnum WritePersistObject(const char* pszClass, const char* pszKey, const IEntityPersistObject* pInstance) = 0;

	/** get the number of persist object */
	virtual ErrorCodeEnum ReadNumOfPersistObject(const char* pClassName, DWORD& dwNum) = 0;

	/** get class all objects keys */
	virtual ErrorCodeEnum GetPersistClassObjectKeys(const char* pClassName, CAutoArray<CSimpleStringA>& strKeys) = 0;

	/** delete persist object */
	virtual ErrorCodeEnum DeleteKeyOfPersistObject(const char* pClassName, const char* pszKey) = 0;

	/** walk through class objects of pClassName, Handle=0 find from beginning */
	virtual ErrorCodeEnum EnumKeyOfPersistObject(const char* pClassName, CSimpleStringA& strKey, DWORD& dwHandle) = 0;

	/** delete all persist object of class pClassName */
	virtual ErrorCodeEnum CleanAllOfPersistObject(const char* pClassName) = 0;

	/**
	 * do async connect to remote entity service, after connected, then pClientSession->Onconnected will call
	 * note: if return succeed, pClientSession will delete by system via OnDestroy
	 *		 if return failed, pCilentSession need delete by user
	 */
	virtual ErrorCodeEnum ConnectRemoteEntity(CClientSessionBase* pClientSession,
		const char* pszRemoteEntity,
		const char* pszParam,
		CSmartPointer<IAsynWaitSp>& pAsynWaitSp) = 0;

	/**redirect as bridged mode*/
	virtual ErrorCodeEnum RedirectSession(CClientSessionBase* pClientSession) = 0;

	/**redirect when accepted*/
	virtual ErrorCodeEnum RedirectSession(const char* pszSuggestEntity) = 0;

	/** redirect subscribe broadcast */
	virtual ErrorCodeEnum RedirectSubscribBroadcast(CUUID SubID, const char* pszSugguestEntity) = 0;

	/**
	 * if entity want to close self, call this function to notify shell service,
	 * then shell service will issue close command
	 */
	virtual ErrorCodeEnum PostQuit() = 0;

	/**
	 * Reload itself entity
	 */
	virtual ErrorCodeEnum PostReload() = 0;

	virtual ErrorCodeEnum SetSelfPriority(EntityPriorityEnum nPriority) = 0;
	virtual ErrorCodeEnum GetSelfPriority(EntityPriorityEnum& nPriority) = 0;

	/** 
	 * timer functions, setup an periodic timer 
	 * @param nTimerID user defined ID, must unique in entity scope
	 * @param pListener user override callback
	 * @param dwInterval timer interval
	 */
	virtual ErrorCodeEnum SetTimer(DWORD dwTimerID, ITimerListener* pListener, DWORD dwInterval) = 0;
	virtual ErrorCodeEnum SetTimerData(DWORD dwTimerID, IReleasable* pData) = 0;
	virtual ErrorCodeEnum GetTimerData(DWORD dwTimerID, CSmartPointer<IReleasable>& pData) = 0;
	/*if dwTimerID=0 mean kill all Timer*/
	virtual ErrorCodeEnum KillTimer(DWORD dwTimerID) = 0;
	virtual ErrorCodeEnum ResetTimer(DWORD dwTimerID, DWORD dwInterval) = 0;
	virtual ErrorCodeEnum GetTimerInterval(DWORD dwTimerID, DWORD& dwInterval) = 0;

	/** query whether this entity has privilege ? */
	virtual bool HasPrivilege() = 0;

	/** get privilege pointer */
	virtual CSmartPointer<IEntityFunctionPrivilege> GetPrivilegeFunction() = 0;

	/** setup log for current thread(for user created thread) */
	virtual ErrorCodeEnum InitLogCurrentThread() = 0;

	/**
	 * start tcp bridge server at ip:port
	 * note: mainly for silverlight usage
	 * currently: silverlight only can use port range (4502-4506)
	 * we provide silverlight policy server(tcp 943) at spshell.exe
	 */
	virtual ErrorCodeEnum StartTcpBridgeServer(unsigned short port) = 0;
	virtual ErrorCodeEnum StopTcpBridgeServer() = 0;
	//virtual void SetPostLinkFun(postLink cur) = 0;

	/**
	 * post Task to entity's thread
	 * FIFO(first in first out) queue tail,  LIFO(last in first out)
	 * queue head
	 */
	virtual ErrorCodeEnum PostEntityTaskFIFO(ITaskSp* pTask) = 0;
	virtual ErrorCodeEnum PostEntityTaskLIFO(ITaskSp* pTask) = 0;

	/**
	 * post task to thread pool
	 */
	virtual ErrorCodeEnum PostThreadPoolTask(ITaskSp* pTask) = 0;

	/** request framework to delay closing */
	virtual ErrorCodeEnum RequestCloseDelay(WORD nSecond) = 0;

	/** log along with params */
	virtual void SendLog(const LogTypeEnum eLogType, const SeverityLevelEnum eLevel, DWORD dwUserEventCode, CAutoArray<DWORD> Param, const char* pszMessage = NULL) = 0;

	/*verify file code signature, if pass, strErrInfo is sign cert hash, else verify error info*/
	virtual ErrorCodeEnum VerifySignature(const char* pszSignedFile, CSimpleStringA& strErrInfo) = 0;

	/*show fatal error info when framework startup*/
	virtual ErrorCodeEnum ShowFatalError(const char *pszMsg, SeverityLevelEnum eLevel = Severity_None) = 0;

	/*show important startup info when framework startup*/
	virtual ErrorCodeEnum ShowStartupInfo(const char *pszMsg) = 0;

    virtual ErrorCodeEnum GetEntityLastError(const char* pszEntityName, CEntityLastErrorInfo& errInfo) = 0;
	virtual void ResetEntityLastError() = 0;
	virtual ErrorCodeEnum GetToken(CSimpleString& channelId, CSimpleString& token) = 0;
	/* GetRunningVersion
	currently return version in active.txt, may be it will return the version from micro sever latter.
	*/
	virtual ErrorCodeEnum GetRunningVersion(CSimpleString& ver) = 0;

	virtual ErrorCodeEnum GetVTMErrMsg(DWORD dwUserCode, CSimpleStringA& strDescription, CSimpleStringA& strVTMCode) = 0;
};

class VTMInitParam{
public:
	CSimpleString terminalNo;
	CSimpleString channelId;
	CSimpleString tokenSecret;
	CSimpleString CommonLaunchUrl;
	CSimpleString CenterConfigTotal;
	VTMInitParam(const char *terminal, const char* channel, const char* token,
		const char* launchUrl, const char* configTotal)
		: terminalNo(terminal), channelId(channel), tokenSecret(token),
		CommonLaunchUrl(launchUrl), CenterConfigTotal(configTotal) {}

};

class MemCfgParam {
public:
	CSimpleString configType; //"centersetting", "root", "shell"
	CSimpleString module;
	CSimpleString name;
	CSimpleString value;
	MemCfgParam(const char* type, const char* mod, const char* n, const char* val)
		: configType(type), module(mod), name(n), value(val) {}
};

/** normal entity no need to use this interface, use for update, health management, etc. */
struct IEntityFunctionPrivilege
{
	virtual ~IEntityFunctionPrivilege() {}

	/*upate terminal current state*/
	virtual ErrorCodeEnum RefreshFrameworkState(FrameworkStateEnum eState) = 0;

	/** get %SysRoot%\Ver\<version> 's config info */
	virtual ErrorCodeEnum GetSystemStaticInfoForVersion(CVersion verSoftware, CSystemStaticInfo& StaticInfo) = 0;

	/** start a remote entity,if restart itself only been call in OnClose event,will ignore pAsynWaitSp,and will not wait*/
	virtual ErrorCodeEnum StartEntity(const char* pszEntityName, const char* pszCmdLine, CSmartPointer<IAsynWaitSp>& pAsynWaitSp) = 0;

	/** close entity ,not use consultative mechanism */
	virtual ErrorCodeEnum StopEntity(const char* pszEntityName, CSmartPointer<IAsynWaitSp>& pAsynWaitSp) = 0;

	/** require entity close and can use the consultative mechanisms */
	virtual ErrorCodeEnum CloseEntity(const char* pszEntityName, CSmartPointer<IAsynWaitSp>& pAsynWaitSp) = 0;

	/** terminate entity forcefully */
	virtual ErrorCodeEnum TerminateEntity(const char* pszEntityName, CSmartPointer<IAsynWaitSp>& pAsynWaitSp) = 0;

	/** pause entity */
	virtual ErrorCodeEnum PauseEntity(const char* pszEntityName, CSmartPointer<IAsynWaitSp>& pAsynWaitSp) = 0;

	/** continue entity from paused state */
	virtual ErrorCodeEnum ContinueEntity(const char* pszEntityName, CSmartPointer<IAsynWaitSp>& pAsynWaitSp) = 0;

	/** test whether entity state ok, a simple health-checking mechanism */
	virtual ErrorCodeEnum TestEntity(const char* pszEntityName, EntityTestEnum eTestType, CSmartPointer<IAsynWaitSp>& pAsynWaitSp) = 0;

	/** register entity life event */
	virtual ErrorCodeEnum RegistEntityLifeEvent(IEntityLifeListener* pListener) = 0;
	virtual ErrorCodeEnum UnregistLiftEvent() = 0;

	/** register entity state event, when entity state changes, callback will be invoked */
	virtual ErrorCodeEnum RegistEntityStateEvent(const char* pszEntityName, IEntityStateListener* pListener) = 0;
	/*If pszEntityName=NULL mean unregist all entity event*/
	virtual ErrorCodeEnum UnregistEntityStateEvent(const char *pszEntityName)=0;
	virtual ErrorCodeEnum GetSpecifiedEntityState(const char* pszEntityName, EntityStateEnum &eEntityState, DWORD& dwUserState) = 0;
	
	/** trigger reboot framework/machine */
	virtual ErrorCodeEnum Reboot(RebootTriggerEnum eTriggerReason, RebootWayEnum eWay) = 0;

	/** show blue full-screen title, for example for system error, privilege */
	virtual ErrorCodeEnum DisplayBlueScreen(const char* pszTitle) = 0;

	/** hide blue screen */
	virtual ErrorCodeEnum UndisplayBlueScreen() = 0;

	/** Install in current version and path*/
	virtual ErrorCodeEnum BeginLightInstall(const char* pszPackageName) = 0;

	virtual ErrorCodeEnum GenerateNewInstallCfg() = 0;

	//virtual ErrorCodeEnum SetUpdateSourcePath(const char *pszSourcePath)=0;

	/** Copy from [Temp]\[pszPackageName]\[pszRelativeFile] to install path,
	1(copy only exisit); 2(copy only not exist); 3(copy always); 4(no copy if exist)*/
	virtual ErrorCodeEnum CopyFileToNewVersion(const char* pszRelativeFile, int nCopyMode) = 0;

	/** pszRelativeName is in run  path*/
	virtual ErrorCodeEnum DeleteFileInNewVersion(const char* pszRelativeName) = 0;

	/** Set startup shell to last version shell,but not trigger to restart.next restart will run in last version path.*/
	virtual ErrorCodeEnum RollBackToPreviousVersion() = 0;
	virtual ErrorCodeEnum RollBackToHistoryVersion(CVersion HistoryVersion) = 0;

	/** Set startup shell to new version shell,next restart will run in new version path
	if bToSysInstall=true the SpShell.exe will not startup first,waiting Guardian.exe running install over,and started up by Guardian.exe*/
	virtual ErrorCodeEnum UpgradeToNewVersion(bool bToSysInstall) = 0;

	/**If the update or rollback version succeed run, info the framework this version is ok*/
	virtual ErrorCodeEnum SetRunSucceed() = 0;

	/**check if the pack has been installed*/
	virtual ErrorCodeEnum IsPackInstalled(const char* pszPackName, bool& bInstalled) = 0;

	/** os pack upgrade, run.ini has ToRun define */
	virtual ErrorCodeEnum BeginSysPackInstall(const char* pszPackageName, CSimpleStringA& strErrMsg) = 0;

	/**check if the syspack has been installed*/
	virtual ErrorCodeEnum IsInstalledSysPack(const char* pszPackageName) = 0;

	/** show system running output console, including all  entity's syslog */
	virtual ErrorCodeEnum ShowOuputConsole() = 0;

	/**close output console */
	virtual ErrorCodeEnum CloseOuputConsole() = 0;

	/*Sets the scheduling priority of the process specified by entity name*/
	virtual ErrorCodeEnum SetEntityPriority(const char* pszEntityName, EntityPriorityEnum nPriority) = 0;

    virtual ErrorCodeEnum GetEntityPriority(const char* pszEntityName, EntityPriorityEnum& nPriority) = 0;
	
		/*begin log sender*/
	virtual ErrorCodeEnum BeginLogSend(const char* endpoint, const char* topicSys, const char* topicUser, const char* topicBeidou, const char* bussSys, const char* bussUser) = 0;
	/*update token*/
	virtual ErrorCodeEnum SetHttpToken(const char* channelId, const char* token) = 0;

	virtual void GetSendLogInfo(unsigned long* t_upload_TerminalSys_Suc, unsigned long* t_upload_TerminalUser_Suc,
		unsigned long* t_upload_BussinessSys_Suc, unsigned long* t_upload_BussinessUser_Suc, unsigned long* t_upload_beidou_Suc,
		unsigned long* t_upload_TerminalSys_Err, unsigned long* t_upload_TerminalUser_Err,
		unsigned long* t_upload_BussinessSys_Err, unsigned long* t_upload_BussinessUser_Err, unsigned long* t_upload_beidou_Err) = 0;

	
	//replace params with VTMInitParam; if one param in VTMInitParam equals to "", it will not replace to old value
	virtual ErrorCodeEnum InitCfgUrl(VTMInitParam &info) = 0;
	virtual ErrorCodeEnum TryUpdateCfg() = 0;
	virtual ErrorCodeEnum TryUpdateCenterCfg(bool& isUpdate, bool& isReset, CSimpleString& version) = 0;
	virtual ErrorCodeEnum TryUpdateToken(CSimpleString& oldToken, CSimpleString& newToken) = 0;
	virtual ErrorCodeEnum GetToken(CSimpleString& curToken) = 0;
	virtual ErrorCodeEnum WriteTerminalNoToRootIni(CSimpleString terminalNo) = 0;
	virtual ErrorCodeEnum ModifyMemCfgParam(MemCfgParam& info) = 0;
	virtual ErrorCodeEnum TryUpdateVTMERRMSG() = 0;
	virtual ErrorCodeEnum GetVTMErrMsgArr(CAutoArray<CSimpleStringA>& strErrorCodeArr,
		CAutoArray<CSimpleStringA>& strDescriptionArr, CAutoArray<CSimpleStringA>& strRemarkArr) = 0;
};

/**
 * service entity side transaction, we define call in two types:
 * 1) one way call, client send one way call packet, need no reply from server side
 * 2) two way call, client send request and server response
 * A transaction is a call context hosted by server entity, when one client
 * issues a call, at server entity side, compose a Transaction context object.
 */
struct ITransactionContext
{
	virtual ~ITransactionContext() {};

	/** decide whether client call is one way call */
	virtual bool IsOneWayCall() = 0;

	/** get request sequence id */
	virtual DWORD GetRequestID() = 0;

	/** get client buffer */
	virtual ErrorCodeEnum GetReceiveBuffer(DWORD& dwMessageID, DWORD& dwMessageSignature, CAutoBuffer& Buffer) = 0;

	/** send out response to client, only use in two way call scenario */
	virtual ErrorCodeEnum SendAnswer(CAutoBuffer Buffer, bool bEnd = true) = 0;

	/** send out response to client without buffer, this is the simplist case for the above one
	* 20160914: support return custom error: @dwUserError
	*/
	virtual ErrorCodeEnum SendAnswer(ErrorCodeEnum eErrorCode, DWORD dwUserError = 0, CSimpleString str = "") = 0;

	/** set response expired timeout value, in milliseconds */
	virtual ErrorCodeEnum SetExpireTime(DWORD dwMS) = 0;

	/** get this run process expire time left value, in milliseconds */
	virtual ErrorCodeEnum GetExpireTime(DWORD& dwWholeTime, DWORD& dwLeftTime) = 0;

	virtual ErrorCodeEnum GetLinkContext(linkContext& curLink) = 0;
};

/** The Module entity must implement the interface */
class CEntityBase
{
public:
	CEntityBase():m_pEntityFunction(nullptr) {}
	virtual ~CEntityBase() { if(m_pEntityFunction != nullptr) delete m_pEntityFunction; }

	/** get entity service function */
	virtual CSmartPointer<IEntityFunction> GetFunction() { return m_pEntityFunction; }

#ifdef RVC_OS_WIN
#if (!defined(SPABASE_LINKED_AS_STATIC_LIBRARY) && !defined(SPBASE_EXPORTS))
protected:
#endif
#endif //RVC_OS_WIN

	/**
	 * invoked when entity is being start, when starting operation finished user must call FinishStart
	 * so the starting operation has prepared, then spbase.dll invokes OnStart
	 */
	virtual void OnPreStart(CAutoArray<CSimpleStringA> strArgs, CSmartPointer<ITransactionContext> pTransactionContext) { pTransactionContext->SendAnswer(Error_Succeed); }
	virtual void OnStarted() {}

	/** invoked when entity pause */
	virtual void OnPrePause(CSmartPointer<ITransactionContext> pTransactionContext) { pTransactionContext->SendAnswer(Error_Succeed); }
	virtual void OnPaused() {}

	/** invoked when entity continue */
	virtual void OnPreContinue(CSmartPointer<ITransactionContext> pTransactionContext) { pTransactionContext->SendAnswer(Error_Succeed); }
	virtual void OnContinued() {}

	/** invoked when entity will be closed*/
	virtual void OnPreClose(EntityCloseCauseEnum eCloseCause, CSmartPointer<ITransactionContext> pTransactionContext) { pTransactionContext->SendAnswer(Error_Succeed); }

	/** user override this, so it is able to extend some complicated health-checking method */
	virtual void OnSelfTest(EntityTestEnum eTestType, CSmartPointer<ITransactionContext> pTransactionContext) { pTransactionContext->SendAnswer(Error_Succeed); }

	/*!
	 * [Gifur@2020519]
	 * override OnSelfTest with speicified EntityTestEnum::Test_Examine
	 */
	virtual void OnExam(CSmartPointer<ITransactionContext> pTransactionContext) { pTransactionContext->SendAnswer(Error_NotImpl); }

	/** invoked when incoming new connection user can RedirectSession in OnNewSession*/
	virtual CServerSessionBase *OnNewSession(const char* /*pszRemoteEntityName*/, const char * /*pszParam*/){return NULL;}

	/**
	 * if you want to redirection please override this function
	 * and invoke IEntityFunciton::RedirectSubscribeBroadcast
	 */
	virtual void OnBroadcastSubscribe(CUUID /*SubID*/, const char* /*pszFromEntityName*/, const char* /*pszParam*/) { }

public:

	/** get this entity name */
	virtual const char* GetEntityName()const = 0;

	/** get this entity version*/
	virtual const char* GetEntityVersion() const { return MODULE_VERSION_FULL; }

	/** is this entity hosts service ? */
	virtual bool IsService()const{return false;}

#ifdef RVC_OS_WIN
#if (!defined(SPABASE_LINKED_AS_STATIC_LIBRARY) && !defined(SPBASE_EXPORTS))
private:
#endif
#endif //RVC_OS_WIN

	/** dont access directly because of inner usage */
	IEntityFunction* m_pEntityFunction;
};

/** server session service */
struct IServerSessionFunction
{
	virtual ~IServerSessionFunction() {}

	/** get client entity name */
	virtual const char* GetRemoteEntityName() = 0;

	/** get current state of this session */
	virtual SessionStateEnum GetCurrentState() = 0;

	/** close session */
	virtual ErrorCodeEnum CloseSession() = 0;
};

/** server service stub, service entity must inherits and implements from here */
class CServerSessionBase
{
public:
	CServerSessionBase() {}
	virtual ~CServerSessionBase() { delete m_pSessionFunction; }

	/** get function pointer */
	CSmartPointer<IServerSessionFunction> GetFunction() { return m_pSessionFunction; }

#ifdef RVC_OS_WIN
#if (!defined(SPABASE_LINKED_AS_STATIC_LIBRARY) && !defined(SPBASE_EXPORTS))
protected:
#endif
#endif //RVC_OS_WIN

	/** invoked when receives request from client */
	virtual void OnRequest(CSmartPointer<ITransactionContext> pTransactionContext) = 0;

	/** invoked when peer closed or network failed */
	virtual void OnClose(ErrorCodeEnum eErrorCode) {}

	/** The same client entity can recall a function before the last call return */
	virtual bool IsSessionOverlap() { return true; }

	/** server message id is overlapped ? */
	virtual ErrorCodeEnum GetMessageAttr(DWORD dwMessageID, DWORD dwSignature, bool& bOverlap) = 0;

	/** is exclusive ? */
	virtual bool IsExclusive() { return false; }

#ifdef RVC_OS_WIN
#if (!defined(SPABASE_LINKED_AS_STATIC_LIBRARY) && !defined(SPBASE_EXPORTS))
private:
#endif
#endif //RVC_OS_WIN

	/** dont access directly because of inner usage */
	IServerSessionFunction* m_pSessionFunction;
};

/**
 * design for supporting async request, each request in client side is named a async wait sp
 * note: for two way call only
 */
struct IAsynWaitSp :public IReleasable
{
	/**Get Caller function name string */
	virtual const char* GetFuctionName() = 0;

	virtual ErrorCodeEnum GetExpireTime(DWORD& dwWholeTime, DWORD& dwLeftTime) = 0;

	/** wait for remote to answer */
	virtual ErrorCodeEnum WaitAnswer(DWORD dwTimeout = INFINITE) = 0;

	/** cancel the pending call */
	virtual ErrorCodeEnum CancelWait() = 0;

	/** decide whether operation is doing */
	virtual bool IsPending() = 0;

	/** get request message id */
	virtual DWORD GetMessageID() = 0;

	/**
	 * when request has finished, call this method to fetch remote buffer
	 * @param ReceivedBuffer get service side sent out buffer, can be zero length
	 * @param bEnd the last response message received, this indicator support multiple return responses
	 */
	virtual ErrorCodeEnum AsyncGetAnswer(CAutoBuffer& ReceiveBuffer, bool& bEnd) = 0;

	/**just get the result code */
	virtual ErrorCodeEnum AsyncGetAnswer()=0;

	virtual ErrorCodeEnum AsyncGetAnswer(DWORD& dwUserError) = 0;
	/**get the result code and user code*/
	virtual ErrorCodeEnum AsyncGetAnswer(DWORD& dwUserError, CSimpleString& str) = 0;

	virtual CSmartPointer<IReleasable> GetCallContext() = 0;
	virtual bool GetCallback(CSmartPointer<ICallbackListener>& pCallback, CSmartPointer<IReleasable>& pContext) = 0;

	/** set callback on, default is off(blocking). The context object inherit IReleasable and must rewrite deconstruction to release temp object*/
	virtual void SetCallback(ICallbackListener* pCallback, IReleasable* pContext = NULL) = 0;

	/** wait for remote to answer
	* @param dwUserError entity custom error code
	*/
	virtual ErrorCodeEnum WaitAnswer(DWORD& dwUserError, CSimpleString& str, DWORD dwTimeout) = 0;

	/**
	* when request has finished, call this method to fetch remote buffer
	* @param ReceivedBuffer get service side sent out buffer, can be zero length
	* @param bEnd the last response message received, this indicator support multiple return responses
	* @param dwUserError entity custom error code
	*/
	virtual ErrorCodeEnum AsyncGetAnswer(CAutoBuffer& ReceiveBuffer, bool& bEnd, DWORD& dwUserError, CSimpleString& str) = 0;
};

/** wait for multi IAsynWaitSp */
SPBASE_API ErrorCodeEnum WaitMultiAnswers(CAutoArray<IAsynWaitSp*> arrAsynWaits, DWORD& dwRetIndex, bool bWaitAll = false, DWORD dwTimeOut = 0);

/** client session */
struct IClientSessionFunction :public IReleasable
{
	/** one way call with buffer */
	virtual ErrorCodeEnum OnewayCall(DWORD dwMessageID, DWORD dwMessageSignature, CAutoBuffer Buffer) = 0;

	/** one way call */
	virtual ErrorCodeEnum OnewayCall(DWORD dwMessageID, DWORD dwMessageSignature) = 0;

	//one way withContext
	virtual ErrorCodeEnum OnewayCall(DWORD dwMessageID, DWORD dwMessageSignature, CAutoBuffer Buffer, linkContext& pContext) = 0;
	virtual ErrorCodeEnum OnewayCall(DWORD dwMessageID, DWORD dwMessageSignature, linkContext& pContext) = 0;

	/**
	 * two way call with buffer
	 * @param nMessageID [in] application defined message id
	 * @param Buffer [in] application defined buffer data
	 * @param pAsynWaitSp [out], required
	 * @param dwTimeOut [in],option,default used system 's timeout constant
	 */
	virtual ErrorCodeEnum AsyncRequest(DWORD dwMessageID, DWORD dwMessageSignature, CAutoBuffer Buffer, CSmartPointer<IAsynWaitSp>& pAsynWaitSp, DWORD dwTimeOut = 0, DWORD dwReqId = -1) = 0;

	//with linkContext
	virtual ErrorCodeEnum AsyncRequest(DWORD dwMessageID, DWORD dwMessageSignature, CAutoBuffer Buffer, CSmartPointer<IAsynWaitSp>& pAsynWaitSp, linkContext& pContext, DWORD dwTimeOut = 0, DWORD dwReqId = -1) = 0;
	virtual ErrorCodeEnum AsyncRequest(DWORD dwMessageID, DWORD dwMessageSignature, CSmartPointer<IAsynWaitSp>& pAsynWaitSp, linkContext& pContext, DWORD dwTimeOut = 0, DWORD dwReqId = -1) = 0;

	/** call without buffer */
	virtual ErrorCodeEnum AsyncRequest(DWORD dwMessageID, DWORD dwMessageSignature, CSmartPointer<IAsynWaitSp>& pAsynWaitSp, DWORD dwTimeOut = 0, DWORD dwReqId = -1) = 0;

	/** get peer entity name */
	virtual const char* GetRemoteEntityName() = 0;

	/** get current state */
	virtual SessionStateEnum GetCurrentState() = 0;

	/** close session */
	virtual ErrorCodeEnum CloseSession() = 0;
};

/** client must implement this */
class SPBASE_API CClientSessionBase
{
public:
	CClientSessionBase() : m_pSessionFunction(NULL) {}
	virtual ~CClientSessionBase();

	CSmartPointer<IClientSessionFunction> GetFunction() { return m_pSessionFunction; }

	/** invoked when connected ok, in async mode */
	virtual void OnConnectSucceed() {}

	/** invoked when peer closed or network failed */
	virtual void OnClose(ErrorCodeEnum /*eErrorCode*/) {}

	/** invoke when delete the object */
	virtual void OnDestroy() { delete this; }

#ifdef RVC_OS_WIN
#if (!defined(SPABASE_LINKED_AS_STATIC_LIBRARY) && !defined(SPBASE_EXPORTS))
private:
#else
public:
#endif
#else
public:
#endif //RVC_OS_WIN

	IClientSessionFunction* m_pSessionFunction;
};

/** user module must inherit from ModuleBase */
class SPBASE_API ModuleBase
{
public:
	ModuleBase();
	virtual ~ModuleBase();

	virtual ErrorCodeEnum Init();
	virtual ErrorCodeEnum Exit();

	virtual BOOL DllMain(HINSTANCE hInstance, DWORD dwReason, LPVOID lpReserved);
	HINSTANCE GetInstance() { return m_hInstance; }
	static ModuleBase* GetModuleBase();

protected:
	/** register your entity via this method to framework */
	ErrorCodeEnum RegistEntity(CEntityBase *pEntity);
	ErrorCodeEnum UnregistEntity(CEntityBase *pEntity);
	ErrorCodeEnum GetRegistEntity(const char *pszEntityName,CSmartPointer<CEntityBase> &pEntity);

#ifdef RVC_OS_WIN
#if (!defined(SPABASE_LINKED_AS_STATIC_LIBRARY) && !defined(SPBASE_EXPORTS))
protected:
#else
public:
#endif
#else
public:
#endif //RVC_OS_WIN

	int m_nEntityCount;
	CEntityBase* m_pEntityArray[32];
	static ModuleBase* s_pModuleInst;
	HINSTANCE m_hInstance;
};

#define SP_BEGIN_ENTITY_MAP() \
class SpEntityModuleStub : public ModuleBase  \
{ \
public: \
	SpEntityModuleStub() \
	{ 

#define SP_ENTITY(cls) \
	m_pEntityArray[m_nEntityCount++] = dynamic_cast<CEntityBase*>(new cls());

#ifdef RVC_OS_WIN

#define SP_END_ENTITY_MAP()	\
	} \
}; \
SpEntityModuleStub g_ModuleInst; \
extern "C" BOOL WINAPI DllMain(HINSTANCE hInstance, DWORD dwReason, LPVOID lpReserved) \
{ \
	return g_ModuleInst.DllMain(hInstance, dwReason, lpReserved); \
}

#else // RVC_OS_WIN

#define SP_END_ENTITY_MAP()	\
	} \
}; \
SpEntityModuleStub g_ModuleInst; \
extern "C" void __attribute__((constructor)) SoMain() {\
	g_ModuleInst.DllMain(NULL, DLL_PROCESS_ATTACH, NULL); \
}

/*
extern "C" void __attribute__((constructor)) SoEnd() {
	DllMain(NULL, DLL_PROCESS_DETACH, NULL);
}
*/

#endif // RVC_OS_WIN


#include "log_define.h"



class SPBASE_API DbgToBeidou {
public:
	DbgToBeidou(const linkContext& t_context, CSimpleStringA t_Api);//link, //当前调用的API
	~DbgToBeidou();
	DbgToBeidou& setHost(CSimpleStringA t_host);//请求链接地址
	DbgToBeidou& setReturnCode(CSimpleStringA t_returncode);
	DbgToBeidou& setResponseTime(CSimpleStringA t_responseTime);
	DbgToBeidou& setCallStack(CSimpleStringA t_callStack);//调用堆栈，格式("callStack":[{“xxx”:"xx","xxxx":sdfs}]）
	DbgToBeidou& setDbStack(CSimpleStringA t_dbStack);//格式("dbStack":[{“xxxxx”:"xxdfsdfs","xxddddxx":sdsddsdfs}]）
	DbgToBeidou& setTags(CSimpleStringA t_Tags);
	DbgToBeidou& withLogProducer(void* t_logProducer);
	void operator () ()  const;
private:
	class Beidou_private;
	Beidou_private* const m_priPtr;
	char CharZero[2];
private:
	DbgToBeidou(const DbgToBeidou&) : m_priPtr(NULL) {};
	const DbgToBeidou& operator=(const DbgToBeidou&) { return *this; };
};


class SPBASE_API DbgWithLink {
public:
	DbgWithLink(LOG_LEVEL_E t_level, LOG_TYPE_E t_type);
	~DbgWithLink();
	//用户、系统日志均必填，交易处理结果代码，0表示处理成功，其他表示失败，可为系统本身的错误码，也可为后台系统返回的错误码
	DbgWithLink& setResultCode(CSimpleStringA t_ResultCode);
	//用户、系统日志均必填，业务跟踪ID, 32字节长度的字符串，唯一识别每笔请求
	DbgWithLink& setTraceID(CSimpleStringA t_TraceID);
	//用户、系统日志LOG_LEVEL_WARN以上必填
	//交易处理结果信息，包括成功与失败信息，可为系统本身的成功/失败信息，也可为后台系统返回的成功/失败信息.
	DbgWithLink& setResultMsg(CSimpleStringA t_ResultMsg);
	//用户日志必填，日志码
	//终端中标识各个交易如读卡、读取身份证等。如果终端由于客观原因无法识别交易场景，则可字段由上游传入。
	DbgWithLink& setLogCode(CSimpleStringA t_LogCode);
	DbgWithLink& setAPI(CSimpleStringA t_API);//用户日志必填，请求路径/接口名称.
	DbgWithLink& setBussID(CSimpleStringA t_BussID);//用户日志必填，请求业务ID
	DbgWithLink& setTipMsg(CSimpleStringA t_TipMsg);//用户日志LOG_LEVEL_WARN以上必填，直接向客户展示的报错信息.
	DbgWithLink& setSourceType(CSimpleStringA t_SourceType);//系统日志LOG_LEVEL_FATAL必填，异常来源类型
	DbgWithLink& setBeginTime(long t_BeginTime);//用户日志必填， 请求发送/接收时间
	DbgWithLink& setEndTime(long t_EndTime);//用户日志必填， 响应接收 / 应答时间
	DbgWithLink& setCostTime(long t_costTime);//消耗时间，自定义字段,单位ms
	DbgWithLink& setVtmCode(CSimpleStringA t_VtmCode);//VtmCode,记录原告警
	DbgWithLink& withLogProducer(void* t_logProducer);
	DbgWithLink& withExtendLog(bool t_doLog);//是否log到文件中，并行阶段需要log到文件
	void operator () (const char* str, ...) const;
	void operator () ()  const;
private:
	class Link_private;
	Link_private* const m_priPtr;
private:
	DbgWithLink(const DbgWithLink&) : m_priPtr(NULL) {};
	const DbgWithLink& operator=(const DbgWithLink&) { return *this; };
};

class SPBASE_API EntityResource {
public:
	static void setLink(const linkContext& cur);
	static const linkContext& getLink();
	static void clearLink();
	static void setSaveFile(int t_saveFile) { m_saveFile = t_saveFile; };
	static int getSaveFile() { return m_saveFile; };

private:
	static linkContext m_link;
	static int m_saveFile;
};

//创建日志存储模块，通常由sphost自动创建，不需要实体创建
SPBASE_API void* create_log_producer_storage(CSimpleStringA entityName, CSimpleStringA item, CSimpleStringA filePath);
SPBASE_API void destroy_log_producer_storage(void* obj);
//创建日志上传模块，通常由spshell自动创建，然后上传
SPBASE_API void* create_log_producer_send(CSimpleStringA endpoint, CSimpleStringA topicSys, CSimpleStringA topicUser, CSimpleStringA topicBeidou, CSimpleStringA bussinessSys, CSimpleStringA bussinessUser,
	CSimpleStringA terminalNo, CSimpleStringA sn, CSimpleStringA filePath, int sendWaitTime);
SPBASE_API void destroy_log_producer_send();
//创建实体日志默认上传模块， SpShell 和 SpRun 中调用，内部调用 create_log_producer_storage
SPBASE_API bool create_log_producer_default(CSimpleStringA entityName, int idx);
SPBASE_API void destroy_log_producer_default();
SPBASE_API void load_debugLevelInCentersetting(const char* fileName);
SPBASE_API bool refreshLogLevel();
SPBASE_API int getCurLogLevel();
SPBASE_API ErrorCodeEnum GetAllEntityIdx(CAutoArray<CSimpleStringA>& strEntityNames, CAutoArray<WORD>& wEntityDevelopIDs);




/** log via shell */
SPBASE_API void LogEvent(const SeverityLevelEnum eLevel,DWORD dwUserEventCode,const char *pszMessage);
SPBASE_API void LogError(const SeverityLevelEnum eLevel, ErrorCodeEnum dwSysErrorCode,DWORD dwUserErrorCode,const char *pszMessage);
SPBASE_API void LogWarn(const SeverityLevelEnum eLevel, ErrorCodeEnum dwSysErrorCode,DWORD dwUserErrorCode, const char *pszMessage);
SPBASE_API void LogFatal(const SeverityLevelEnum eLevel, ErrorCodeEnum dwSysErrorCode, DWORD dwUserErrorCode, const char* pszMessage);
SPBASE_API void LogAssert(const char *pszMessage,const char *pszSourceFile,const int nLine);
SPBASE_API void LogTrace(const char *pszMessage,const char *pszSourceFile,const int nLine);

SPBASE_API void LogNotify(const NotifyLevelEnum eLevel, ErrorCodeEnum dwSysErrorCode, DWORD dwUserErrorCode, const char* pszMessage);
SPBASE_API void LogEvent(const SeverityLevelEnum eLevel, DWORD dwUserEventCode, const char* pszMessage, const linkContext& t_context);
SPBASE_API void LogError(const SeverityLevelEnum eLevel, ErrorCodeEnum dwSysErrorCode, DWORD dwUserErrorCode, const char* pszMessage, const linkContext& t_context);
SPBASE_API void LogWarn(const SeverityLevelEnum eLevel, ErrorCodeEnum dwSysErrorCode, DWORD dwUserErrorCode, const char* pszMessage, const linkContext& t_context);
SPBASE_API void LogFatal(const SeverityLevelEnum eLevel, ErrorCodeEnum dwSysErrorCode, DWORD dwUserErrorCode, const char* pszMessage, const linkContext& t_context);
SPBASE_API void LogAssert(const char* pszMessage, const char* pszSourceFile, const int nLine, const linkContext& t_context);
SPBASE_API void LogTrace(const char* pszMessage, const char* pszSourceFile, const int nLine, const linkContext& t_context);


SPBASE_API CSimpleStringA GetSysErrMsg(int nErrCode);
SPBASE_API const char *_GetFileName(const char *pszFilePath);

#ifdef RVC_OS_LINUX
/*
基于当前mod中包含有restful模块，需要把数据从framework中传递到librestful，会比较困难
（1）实际上大部分实体都没有加载restful模块，所以难以进行显示调用进行初始化。
（2）初始化的时机难以把握，因为使用restful的位置各不相同
（3）目前有大致5个实体有用到librestfulSDK，采用回调函数传参的方式，把token功能传入到mod的librestfulSDK中。
（4）此方式为临时方案，使用策略模式，封装了算法SpGetToken()，通过函数传递的方式将该策略注入到类HttpClientRequestConfig中
*/
#define MAX_TOKEN_LEN 256
SPBASE_API void SpGetToken(char* channelId, char* token);
#endif

#ifdef RVC_OS_WIN //TODO: duplicate ?
#define LOG_TRACE(pMsg, ...) \
	LogTrace(CSimpleStringA::Format(pMsg, __VA_ARGS__), _GetFileName(__FILE__), __LINE__)
#else
#define LOG_TRACE(pMsg, ...) \
	LogTrace(CSimpleStringA::Format(pMsg, ##__VA_ARGS__), _GetFileName(__FILE__), __LINE__)
#endif //RVC_OS_WIN

extern "C" SPBASE_API void Dbg(const char *str, ...);
extern "C" SPBASE_API void vDbg(const char *str, va_list list);

extern "C" SPBASE_API const char* SpStrError(ErrorCodeEnum errorCode);

struct CScopeLog
{
    CScopeLog(const char* pszMsg, const char* pszFile, int nFileLine)
        : m_pszMsg(pszMsg), m_pszFile(pszFile), m_nFileLine(nFileLine)
    {
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Enter %s, file: {%s}, line: {%d}", m_pszMsg, m_pszFile, m_nFileLine);
    }
    ~CScopeLog() { DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Leave %s, file: {%s} ,line: {%d}", m_pszMsg, m_pszFile, m_nFileLine); }

    const char* m_pszMsg;
    const char* m_pszFile;
    int m_nFileLine;
};
#define LOG_FUNCTION() CScopeLog __FunctionScopeLog(__FUNCTION__, _GetFileName(__FILE__), __LINE__)

//TODO:
/** It is used out of the Entity class members */
#if ( (defined(_DEBUG) && defined(_MSC_VER)) )
#define LOG_ASSERT(f) do{if(!(f) && (1 == _CrtDbgReport(_CRT_ASSERT, _GetFileName(__FILE__), __LINE__, NULL, #f))) {_CrtDbgBreak(); LogAssert(#f,_GetFileName(__FILE__), __LINE__);}} while (0)
#define LOG_ASSERT_MSG(f,pMsg, ...) do{if(!(f) && (1 == _CrtDbgReport(_CRT_ASSERT, _GetFileName(__FILE__), __LINE__, NULL, CSimpleStringA::Format(pMsg, __VA_ARGS__)))) _CrtDbgBreak(); LogAssert(pMsg,_GetFileName(__FILE__), __LINE__);} while (0)

#else//( (defined(_DEBUG) && defined(_MSC_VER)))
#define LOG_ASSERT(f) if(!(f)) LogAssert(#f,_GetFileName(__FILE__), __LINE__)
#define LOG_ASSERT_MSG(f,pMsg, ...) do{ if(!(f)) LogAssert(CSimpleStringA::Format(pMsg, ##__VA_ARGS__),_GetFileName(__FILE__), __LINE__);} while (0)

#endif// ( (defined(_DEBUG) && defined(_MSC_VER)) )
#endif // __cplusplus

#endif //_RVC_SPBASE_H_