myvtm/Module/mod_FreeRDPWrap/FreeRDPWrapFSM.h

#ifndef _FREERDPWRAP_FSM_H__
#define	_FREERDPWRAP_FSM_H__

#pragma once

#include "SpFSM.h"
#include "FreeRDPWrap_server_g.h"
#include "FreeRDPWrap_msg_g.h"
#include "RvcDevMnt.h"
#include "SpWare.h"
#include "RDPPipe.h"
#include "RDPWInst.h"
#include "FreeRDPErrorCode.h"

#include "..\\mod_interactivecontrol\\interactivecontrol_client_g.h"
using namespace InteractiveControl;

using namespace FreeRDPWrap;

#ifdef TWINKLE_LOCAL_DEBUG

static void TwDbg(const char* format, ...) 
{
	va_list args;
	va_start(args, format);
	vDbg(format, args);
}

#define Dbg(fmt, ...) \
	TwDbg(fmt, ##__VA_ARGS__); \
	printf(fmt "\n", ##__VA_ARGS__)

#endif

#define ISSUCCEEDED(hr) ((hr) == Error_Succeed)
#define FAILURED(hr) (!(ISSUCCEEDED(hr)))
#define IFCALLFAILED_LEAD_END(_cb, _uc) \
do { \
ec = (_cb); \
if ( Error_Succeed !=  ec) {\
dwUserCode = _uc;\
goto Error; } } while (0)

#define SAFE_CLOSE_HANDLE(hr)	\
	do	\
	{	\
		if(hr != NULL && hr != INVALID_HANDLE_VALUE) {	\
			CloseHandle(hr);	\
		}	\
		hr = NULL;	\
	} while (false)

#define CLIENET_USER "ClientUser"
#define FREERDP_SVC_NAME "wFreeWrapSvc.exe"

#define RVC_DRIV_INSTALL_DRI   TEXT("\\RvcHIDFilter\\x32\\")
#define RVC_DRIV_INSTALL_DRI64 TEXT("\\RvcHIDFilter\\x64\\")

#define RVC_DRIV_INSTALL_EXE  TEXT("\\RvcHIDFilter\\RvcDrvMgr.exe")
#define RVC_DRIV_INSTALL_EXE64 TEXT("\\RvcHIDFilter\\RvcDrvMgr64.exe")


//系统变量名称
#define SYSVAR_FREERDPSTATUS          "FreeRDPStatus"

//实体其他异常导致启动失败，框架启动卡死
#define FREERDPSTATUS_ERROR           "E"
//实体检测正常
#define FREERDPSTATUS_SUCC			  "S"
//实体启动中
#define FREERDPSTATUS_BUSY            "B"
//单屏启动
#define FREERDPSTATUS_INVALID_MONITOR "M"
//暂未使用
#define FREERDPSTATUS_UNKOWN          "U"

static const int fs_error = -1;
static const int fs_succ = 0;
static const int fs_busy = 1;
static const int fs_invalid_monitor = 2;
static const int fs_unknown = 3;
static const int fs_single_user = 4;


typedef enum _ShareMode {

	ClientIdle = 1,
	// 本地模式，客户经理屏共享会话
	AM2Client,   
	// 本地模式，客户屏共享会话
	Client2AM,      
	// 远程模式，客户屏共享会话
	Client2Seat,    
	// 远程模式，坐席屏共享会话
	Seal2Client     

} ShareMode;

struct MonitorInfo
{
	BOOL bSet;
	BOOL bPrimary;
	CSimpleStringA deviceName;
	CSimpleStringA deviceID;
	CSimpleStringA deviceKey;

	MonitorInfo()
		:bSet(FALSE),bPrimary(FALSE)
		,deviceName(true)
		,deviceID(true)
		,deviceKey(true){}
};


enum EvtType
{
	USER_EVT_START = (EVT_USER + 1),
	USER_EVT_INVITE,
	USER_EVT_BE_INVITED,
	USER_EVT_CLOSE_SHARE,
	USER_EVT_CREATE_PROCESS,
	USER_EVT_CREATE_PROCESS_FINISHED,
	USER_EVT_ATTENDEE_DISCONNECT,
	USER_EVT_ATTENDEE_CONNECTED,
	USER_EVT_SHARE_HOST_DISCONNECT,
	USER_EVT_ATTENDEE_CONNECT_FAILED,
	USER_EVT_CONNECT_TO_HOST_FAILED,
	USER_EVT_CONNECT_TO_HOST_SUCC,
	USER_EVT_ON_VIEWER_DISCONNECTED,
	USER_EVT_INSTALL_DRIVE,
	USER_EVT_INSTALL_DRIVE_DONE,
	USER_EVT_INSTALL_KBD,
	USER_EVT_INSTALL_KBD_DONE,	
	USER_EVT_INSTALL_MOU,
	USER_EVT_INSTALL_MOU_DONE,
	USER_EVT_AGENT_ASSIST,
	USER_EVT_AGENT_ASSIST_DONE,
	USER_EVT_QUIT,
	USER_EVT_DEPECRATED,
};

enum CopyDataEvent
{
	CDEVENT_INVALIDE = 0,
	CDEVENT_HIDE_CURSOR,
	CDEVENT_SHOW_CURSOR,
	CDEVENT_MAX
};


#define SERVICE_SPECIFICED_NAME "Rvc2wFreeWrap"
#define SERVICE_CONTROL_CREATEPROCESS 0x000000F0

#define SVC_CREATE_PROCESS_VERSION_1 1

typedef struct _SP_CREATE_PROCESS_INFO {
	USHORT usVersion;
	USHORT usValiSize;
	DWORD dwLastError;
	// 扩展 szCmdline 从 MAX_PATH 到 MAX_PATH*2 [6/17/2020 11:30 @Gifur]
	char szCmdline[MAX_PATH*2];
	// 裁剪 szUserName 从 MAX_PATH 到 32 [6/17/2020 11:30 @Gifur]
	char szUserName[32];
	PROCESS_INFORMATION pi;
}SP_CREATE_PROCESS_INFO, *PSP_CREATE_PROCESS_INFO;

//!!Start RDPWrap Install secion

class CloseShareEvent : public FSMEvent
{
public:
	CloseShareEvent() : FSMEvent(USER_EVT_CLOSE_SHARE){}
	~CloseShareEvent(){}
	SpReqAnsContext<FreeRDPWrapSrv_CloseRdpShare_Req, FreeRDPWrapSrv_CloseRdpShare_Ans>::Pointer m_ctx;
	virtual void OnUnhandled()
	{
		Dbg("USER_EVT_CLOSE_SHARE unhandled!");
		if(m_ctx != NULL)
		{
			m_ctx->Answer(Error_InvalidState);
		}
	}
};

class DriveInstallEvent : public FSMEvent
{
public:
	DriveInstallEvent() 
		: FSMEvent(USER_EVT_INSTALL_DRIVE)
		, kbdRequired(FALSE)
		, mouRequired(FALSE)
		{}
	DriveInstallEvent(BOOL kbdReq, BOOL mouReq)
		: FSMEvent(USER_EVT_INSTALL_DRIVE)
		, kbdRequired(kbdReq)
		, mouRequired(mouReq)
		{}
	~DriveInstallEvent(){}

	BOOL kbdRequired;
	BOOL mouRequired;

	virtual void OnUnhandled()
	{
		Dbg("USER_EVT_INSTALL_DRIVE unhandled!");
	}
};

class InviteEvent : public FSMEvent
{
public:
	InviteEvent() : FSMEvent(USER_EVT_INVITE){}
	~InviteEvent(){}
	SpReqAnsContext<FreeRDPWrapSrv_InviteRdpShare_Req, FreeRDPWrapSrv_InviteRdpShare_Ans>::Pointer m_ctx;
	virtual void OnUnhandled()
	{
		Dbg("USER_EVT_INVITE unhandled!");
		if(m_ctx != NULL)
		{
			m_ctx->Answer(Error_InvalidState);
		}
	}
};

class AgentAssistantEvent : public FSMEvent
{
public:
	AgentAssistantEvent() : FSMEvent(USER_EVT_AGENT_ASSIST){}
	~AgentAssistantEvent(){}
	SpReqAnsContext<FreeRDPWrapSrv_AgentAssistant_Req, FreeRDPWrapSrv_AgentAssistant_Ans>::Pointer m_ctx;
	virtual void OnUnhandled()
	{
		Dbg("USER_EVT_AGENT_ASSIST unhandled!");
		if(m_ctx != NULL)
		{
			m_ctx->Answer(Error_InvalidState);
		}
	}
};

class CreateProcessEvent : public FSMEvent
{
public:
	CreateProcessEvent() : FSMEvent(USER_EVT_CREATE_PROCESS){}
	~CreateProcessEvent(){}
	SpReqAnsContext<FreeRDPWrapSrv_CreateProcessRunAs_Req, FreeRDPWrapSrv_CreateProcessRunAs_Ans>::Pointer m_ctx;
	virtual void OnUnhandled()
	{
		Dbg("USER_EVT_CREATE_PROCESS unhandled!");
		if(m_ctx != NULL)
		{
			m_ctx->Answer(Error_InvalidState);
		}
	}
};

//!!End RDPWrap Install secion

class CFreeRDPWrapFSM : public FSMImpl<CFreeRDPWrapFSM>, public IFSMStateHooker
{

public:

	CFreeRDPWrapFSM(void);
	~CFreeRDPWrapFSM(void);

	virtual ErrorCodeEnum OnInit();
	virtual ErrorCodeEnum OnExit();

	void SelfTest(EntityTestEnum eTestType,CSmartPointer<ITransactionContext> pTransactionContext);
	virtual void OnStateTrans(int iSrcState, int iDstState);

	enum {s0, s1, s2, s3, s4, s5};
	BEGIN_FSM_STATE(CFreeRDPWrapFSM)
		FSM_STATE_ENTRY(s0, "Idle", s0_on_entry, s0_on_exit, s0_on_event)
		FSM_STATE_ENTRY(s1, "Sharing", s1_on_entry, s1_on_exit, s1_on_event)
		FSM_STATE_ENTRY(s2, "Viewing", s2_on_entry, s2_on_exit, s2_on_event)
		FSM_STATE_ENTRY(s3, "Failed", s3_on_entry, s3_on_exit, s3_on_event)
		FSM_STATE_ENTRY(s4, "Install", s4_on_entry, s4_on_exit, s4_on_event)
		FSM_STATE_ENTRY(s5, "Depecrate", s5_on_entry, s5_on_exit, s5_on_event)
	END_FSM_STATE()

	BEGIN_FSM_RULE(CFreeRDPWrapFSM, s0)
		FSM_RULE_ENTRY(s0, s1, USER_EVT_START, 0)
		FSM_RULE_ENTRY(s0, s1, USER_EVT_INVITE, 1)
		FSM_RULE_ENTRY(s0, s2, USER_EVT_INVITE, 2)
		FSM_RULE_ENTRY(s1, s0, USER_EVT_CLOSE_SHARE, 1)
		FSM_RULE_ENTRY(s2, s0, USER_EVT_CLOSE_SHARE, 1)
		FSM_RULE_ENTRY_ANY(s2, s3, USER_EVT_CONNECT_TO_HOST_FAILED)
		FSM_RULE_ENTRY_ANY(s0, s2, USER_EVT_CONNECT_TO_HOST_SUCC)
		FSM_RULE_ENTRY_ANY(s1, s3, USER_EVT_ATTENDEE_CONNECT_FAILED)
		FSM_RULE_ENTRY_ANY(s1, s0, USER_EVT_ATTENDEE_DISCONNECT)
		FSM_RULE_ENTRY_ANY(s0, s1, USER_EVT_ATTENDEE_CONNECTED)

		FSM_RULE_ENTRY(s1, s3, USER_EVT_CLOSE_SHARE, 2)
		FSM_RULE_ENTRY(s2, s3, USER_EVT_CLOSE_SHARE, 2)

		FSM_RULE_ENTRY_ANY(s2, s0, USER_EVT_ON_VIEWER_DISCONNECTED)

		FSM_RULE_ENTRY(s0, s4, USER_EVT_INSTALL_DRIVE, 1)
		FSM_RULE_ENTRY(s4, s0, USER_EVT_INSTALL_DRIVE_DONE, 1)

		FSM_RULE_ENTRY(s0, s1, USER_EVT_AGENT_ASSIST, 1)
		FSM_RULE_ENTRY(s1, s0, USER_EVT_AGENT_ASSIST_DONE, 0)
		FSM_RULE_ENTRY_ANY(s0, s5, USER_EVT_DEPECRATED)

	END_FSM_RULE()

	virtual void s0_on_entry();
	virtual void s0_on_exit();
	virtual unsigned int s0_on_event(FSMEvent* e);

	virtual void s1_on_entry();
	virtual void s1_on_exit();
	virtual unsigned int s1_on_event(FSMEvent* e);

	virtual void s2_on_entry();
	virtual void s2_on_exit();
	virtual unsigned int s2_on_event(FSMEvent* e);

	virtual void s3_on_entry();
	virtual void s3_on_exit();
	virtual unsigned int s3_on_event(FSMEvent* e);

	virtual void s4_on_entry();
	virtual void s4_on_exit();
	virtual unsigned int s4_on_event(FSMEvent* e);

	virtual void s5_on_entry() {LOG_FUNCTION();}
	virtual void s5_on_exit() {}
	virtual unsigned int s5_on_event(FSMEvent* e);

	static UINT WINAPI MaintainFreeRDPRoutine(LPVOID param);

	//If returned INVALID_HANDLE_VALUE, dwProcessID = GetLastError();
	HANDLE CreateFreeRDPProc(DWORD &dwProcessID);

	void AttendeeDisconnect() {
		Dbg("USER_EVT_ATTENDEE_DISCONNECT happen!");
		this->PostEventFIFO(new FSMEvent(USER_EVT_ATTENDEE_DISCONNECT));
	}
	void AttendeeConnected() {
		Dbg("USER_EVT_ATTENDEE_CONNECTED happen!");
		this->PostEventFIFO(new FSMEvent(USER_EVT_ATTENDEE_CONNECTED));
	}
	void AttendConnectFailed() {
		Dbg("USER_EVT_ATTENDEE_CONNECT_FAILED happen!");
		this->PostEventFIFO(new FSMEvent(USER_EVT_ATTENDEE_CONNECT_FAILED));
	}
	void ConnectToHostFailed() {
		Dbg("USER_EVT_CONNECT_TO_HOST_FAILED happen!");
		this->PostEventFIFO(new FSMEvent(USER_EVT_CONNECT_TO_HOST_FAILED));
	}
	void ConnectToHostSucc() {
		Dbg("USER_EVT_CONNECT_TO_HOST_SUCC happen!");
		this->PostEventFIFO(new FSMEvent(USER_EVT_CONNECT_TO_HOST_SUCC));
	}

	void ViewerDisconnected() {
		Dbg("USER_EVT_ON_VIEWER_DISCONNECTED happen!");
		this->PostEventFIFO(new FSMEvent(USER_EVT_ON_VIEWER_DISCONNECTED));
	}

	void BroadMonitorNumChange(const int curAvailMonitorNums);

	void RequireInstallDrv(const BOOL& kbdReq, const BOOL& mouReq) 
	{

#ifndef TWINKLE_LOCAL_DEBUG

		if(GetCurrState()->id == s4) {
			Dbg("USER_EVT_INSTALL_DRIVE happen! in %s state", GetCurrState()->pszName);
			return;
		}
		Dbg("USER_EVT_INSTALL_DRIVE happen!");
		LogWarn(Severity_High, Error_InvalidState, 0, 
			(LPCTSTR)CSimpleStringA::Format("Need to install driver for %s | %s.",
			kbdReq ? "keyboard" : "", mouReq ? "mouse" : ""));
		DriveInstallEvent* evt = new DriveInstallEvent(kbdReq, mouReq);
		this->PostEventFIFO(evt);

#endif //TWINKLE_LOCAL_DEBUG

	}

	ErrorCodeEnum AgentAssistant(
		SpReqAnsContext<FreeRDPWrapSrv_AgentAssistant_Req,
		FreeRDPWrapSrv_AgentAssistant_Ans>::Pointer ctx);

	void SetFSMSickStatus(BOOL tellImmediately = TRUE) {
		m_ecSelfTest = Error_InvalidState;
		//TODO
	}
	void SetFSMRecoverStatus() {
		if(m_ecSelfTest != Error_Succeed) {
			m_ecSelfTest = Error_Succeed;
		}
	}

	void unitest_install_rdpwrap_component() {
		BOOL bWrapInstalled = FALSE;
		if( 0 == CheckRdpWrapInstall(bWrapInstalled)) {
			if(bWrapInstalled == FALSE) {
				auto rc = InstallRdpWrap();
				Dbg("install rdp component return : ", rc);
			}
		}
	}
	void unitest_unstall_rdpwrap_component() {
		BOOL bWrapInstalled = FALSE;
		if( 0 == CheckRdpWrapInstall(bWrapInstalled)) {
			if(bWrapInstalled == TRUE) {
				auto rc = UnstallRdpWrap();
				Dbg("unstall rdp component return : ", rc);
			}
		}
	}

	UINT UnitTest(LPCTSTR testTag);

	bool DetectPrimaryMonitors();

private:

	BOOL IsWrapperNeedUpdate();
	BOOL TerminateFreeRDPRoutine();

	BOOL CreateInviteFileName(CHAR* strFileName, const DWORD bufLen);

	void InitEnvironmentValue();

	void SetSysVal(int nFlag);

	ErrorCodeEnum CreateClientUserAccount();
	ErrorCodeEnum GetClientUserPsw(bool bRuncfgInitialized, CSimpleStringA& plainPsw);
	inline bool RemoveClientUser();

	bool IsInvalidCipherPsw(const CSimpleStringA& strCipherPsw)
	{
		return (!strCipherPsw.IsNullOrEmpty() && strCipherPsw.GetLength() < 24);
	}

	bool Plain2EncodeCipherString(const char* newPasswd, CSimpleStringA& strEnCipherText);
	bool EncodeCipher2PlainString(const CSimpleStringA& strEnCipherText, CSimpleStringA& strPlainText);

	inline void BackupClientUserPsw(const CSimpleStringA& psw);
	inline void RetrieveClientUserPswFromBakup(CSimpleStringA& psw);

	ErrorCodeEnum RetrieveFreeRDPUserPassword(CSimpleStringA& strOutPassword);
	ErrorCodeEnum StoreFreeRDPUserPassword(const CSimpleStringA& strInPassword);

	ErrorCodeEnum TryChangeClientUserPswWithDefault();


	int GetRealtimeMonitorInfo(CAutoArray<MonitorInfo>& monitorArr);

	/*return 2 means succeed. 0: primary, 1: vice */
	int GetMonitorInfoFromRunCfg(CAutoArray<MonitorInfo>& monitorArr);

	BOOL IfDontActiveClientManagerDesk();

public:

	friend struct CreateProcessTask; 

	BOOL CreateShareSession(
		SpReqAnsContext<FreeRDPWrapSrv_InviteRdpShare_Req, 
		FreeRDPWrapSrv_InviteRdpShare_Ans>::Pointer ctx);
	BOOL TerminateShareSession(
		SpReqAnsContext<FreeRDPWrapSrv_CloseRdpShare_Req,
		FreeRDPWrapSrv_CloseRdpShare_Ans>::Pointer ctx);
	BOOL ShowFreeRDPCursor(BOOL bShow = TRUE);

	ErrorCodeEnum UpdateAndChangeSrvStatus();
	BOOL ExecWaitWithExitCode(LPTSTR lpszCmdLine, DWORD& dwExitCode);
	BOOL ExecWaitWithResultContent(LPTSTR lpszCmdLine, CSimpleStringA& strResult);
	//ErrorCodeEnum CreateProcessRunAs(LPCTSTR lpcszCmdLine, LPCTSTR lpcszUserName);
	ErrorCodeEnum CreateProcessFromSrv(
		LPCTSTR lpcszCmdLine, LPCTSTR lpcszUserName, PROCESS_INFORMATION *ppi);
	ErrorCodeEnum CreateProcessFromSrvWait(
		LPCTSTR lpcszCmdLine, LPCTSTR lpcszUserName, PROCESS_INFORMATION *ppi);
	void SetSelfCheckCode(ErrorCodeEnum ec = Error_Succeed) {
		m_ecSelfTest = ec;
	}

	void SetBrocastEvent(bool bLock = true) {
		if(bLock) {
			SendWfreeWrapEvt(1);
		}
	}

	void SendWfreeWrapEvt(int evtType, int reserved1 = 0, int reserved2 = 0);

	void PromptInvalidMonitor() {
		//检测到显示器异常，请确保有且仅有2个显示屏处于可用状态！
		GetEntityBase()->GetFunction()->ShowFatalError("显示器异常，请确保有且仅有2个显示屏可用！");
	}

	ErrorCodeEnum CreateDeskShareProc(bool force = false);

	int CreateInstallDrvTask(const BOOL& kbdRequired, const BOOL& mouRequired);
	ErrorCodeEnum InstallFiltrDriver(DEVTYPE dt);

	void CheckCriticalThread();

	ErrorCodeEnum SetNumLockDefaultStatus();
	void SetNumLock(BOOL bState);

	void messageTest(BOOL on);

private:

	CSimpleStringA m_strUserName;

	ErrorCodeEnum m_ecSelfTest;
	int m_nSrcState;

	HANDLE m_hFreeRDPProc;
	DWORD m_dwFreeRDPProcID;
	HANDLE hExitEvent;

	HANDLE m_hRDPMaintainThread;
	UINT  m_dwRDPMaintainID;

	HANDLE m_hWarerThread;
	DWORD m_dwWarerThreadID;

	BOOL m_bInvited;
	BOOL m_bInterview;
	CSimpleStringA m_strInviteFileName;

	DWORD m_dwLockScreenMinu;

	DWORD m_dwWndThreadID;
	HANDLE m_hWndThread;

	//防止隔壁在请求服务执行进程时有其他请求冲进来
	HANDLE m_hSrvMutex;

	BOOL m_bAgentSituation;
	ShareMode m_eShareMode;

	BOOL m_bTestMode;

	UINT m_uMonitorNum;

	BOOL m_DeactiveClientManager;
};

struct CreateProcessTask : public ITaskSp
{
	CFreeRDPWrapFSM* fsm;

	CreateProcessTask(CFreeRDPWrapFSM* f) : fsm(f) {}
	SpReqAnsContext<FreeRDPWrapSrv_CreateProcessRunAs_Req, FreeRDPWrapSrv_CreateProcessRunAs_Ans>::Pointer m_ctx;
	void Process()
	{
		//FSMEvent *e = new FSMEvent(USER_EVT_CREATE_PROCESS_FINISHED);
		ErrorCodeEnum ec = Error_Succeed;
		PROCESS_INFORMATION pi = {0};
	
		ec = fsm->CreateProcessFromSrvWait(
			m_ctx->Req.strCmdLine, 
			m_ctx->Req.strUserName.IsNullOrEmpty() ? 
			(LPCTSTR)fsm->m_strUserName
			: (LPCTSTR)m_ctx->Req.strUserName,
			&pi);
		if(ISSUCCEEDED(ec)) {
			m_ctx->Ans.reserved1 = 1;
			m_ctx->Ans.retCode = pi.dwProcessId;
			Dbg("fulfill retCode with pid: %d", m_ctx->Ans.retCode);
		}
		m_ctx->Answer(ec);
	}
};

struct DrvInstallTask : public ITaskSp
{
	CFreeRDPWrapFSM* fsm;
	BOOL kbdRequired;
	BOOL mouRequired;
	DrvInstallTask(CFreeRDPWrapFSM* f): fsm(f), kbdRequired(FALSE), mouRequired(FALSE) {}
	void Process()
	{
		if(!fsm) return;
		
		if(kbdRequired) {
			if(fsm->InstallFiltrDriver(DEV_KEYBOARD) == Error_Succeed) {
				LogEvent(Severity_Low, Error_Succeed, "Install Keyboard driver succ.");
			}
			else {
				LogWarn(Severity_Middle, Error_RegistryFailed, ERROR_FREERDP_DRIVER_INSTALL_KEYBOARD_FAILED,
					"Install Keyboard Driver failed!");
			}
			if(mouRequired) {
				Sleep(1000);
			}
		}

		if(mouRequired) {

			if(fsm->InstallFiltrDriver(DEV_MOUSE) == Error_Succeed) {
					LogEvent(Severity_Low, Error_Succeed, "Install Mouse driver succ.");

				}
				else {
					LogWarn(Severity_Middle, Error_RegistryFailed, ERROR_FREERDP_DRIVER_INSTALL_MOUSE_FAILED,
						"Install Mouse Driver failed!");
				}
			}
		fsm->PostEventFIFO(new FSMEvent(USER_EVT_INSTALL_DRIVE_DONE));
	}
};


struct SpDeskShareCreateTask : public ITaskSp
{
	CFreeRDPWrapFSM* fsm;
	bool m_force;
	SpDeskShareCreateTask(CFreeRDPWrapFSM* f) : fsm(f), m_force(false) {}
	SpDeskShareCreateTask(CFreeRDPWrapFSM* f, bool bForce) : fsm(f), m_force(bForce) {}
	void Process()
	{
		ErrorCodeEnum ec = Error_Param;
		if(fsm != NULL) {
			ec = fsm->CreateDeskShareProc(m_force);
			Dbg("Execute SpDeskShareCreateTask returned: %d", ec);
		}
	}
};


struct AgentAssistTask : public ITaskSp
{
	CFreeRDPWrapFSM* fsm;
	AgentAssistTask(CFreeRDPWrapFSM* f) : fsm(f) {}
	SpReqAnsContext<FreeRDPWrapSrv_AgentAssistant_Req, FreeRDPWrapSrv_AgentAssistant_Ans>::Pointer m_ctx;
	void Process()
	{
		LOG_ASSERT(fsm != NULL);
		ErrorCodeEnum ec = Error_Param;
		ec = fsm->AgentAssistant(m_ctx);

		FSMEvent* evt = new FSMEvent(USER_EVT_AGENT_ASSIST_DONE);
		evt->param1 = ec == Error_Succeed ? 1 : 0;
		fsm->PostEventFIFO(evt);
	}
};

//////////////////////////////////////////////////////////////////////////
struct HIDMaintainTask : public ITaskSp
{
	CFreeRDPWrapFSM* fsm;
	HIDMaintainTask(CFreeRDPWrapFSM* f) : fsm(f) {}
	void Process() {
		LOG_ASSERT(fsm != NULL);
		DevMnt_SetReference(fsm);
		DevMnt_MainWndStartAndLoop(fsm);
		Dbg("DevMnt_MainWndStartAndLoop end !");
		//TODO:
	}
};

struct WarerMaintainTask : public ITaskSp
{
	CFreeRDPWrapFSM* fsm;
	WarerMaintainTask(CFreeRDPWrapFSM* f) : fsm(f) {}
	void Process() {
		LOG_ASSERT(fsm != NULL);
		DevMnt_SetReference(fsm);
		RDPWarer_MainWndStartAndLoop(fsm);
		Dbg("RDPWarer_MainWndStartAndLoop end !");
		//TODO:
	}
};


class CInteractCtrlClient : public UIService_ClientBase
{
public:
	CInteractCtrlClient(CEntityBase* pEntity)
		:UIService_ClientBase(pEntity) {}
};

#endif //_FREERDPWRAP_FSM_H__