// NetWorkOper.cpp: implementation of the CNetWorkOper class.
//
//////////////////////////////////////////////////////////////////////
#include "StdAfx.h"
#include "GeoMative.h"
#include "NetWorkOper.h"
#include "TransferCtrl.h"
#include "TaskDataOper.h"
#include "Lock\AutoLock.h"
#include "FileOperTools.h"
#include "MainFrm.h"
#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

extern int g_iTransFileMode;
extern BOOL g_bIsOnlineTransfer;
extern int g_iUILanguage;
extern CGeoMativeApp theApp;
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CNetWorkOper::CNetWorkOper()
{
	InitializeCriticalSection(&m_netCs);
	InitializeCriticalSection(&m_realHwndCs);
	m_tcpClient = NULL;
	m_bIsRunning = false;
	m_pThread = NULL;
	m_bIsTransfer = false;
	m_pNotifyFunc = NULL;
	m_bIsNeedResp = false;
	m_bIsNeedSend = false;
	m_ucCmd = 0;
	m_pNotifyParam = NULL;
	m_pDevNotifyFunc = NULL;
	memset(m_chSendBuf, 0, sizeof(m_chSendBuf));
	m_pDevNotfiyParam = NULL;
	m_bIsSuspend = false;
	m_bIsGetDevAddr = false;


}


CNetWorkOper::~CNetWorkOper()
{
	ConsumerThread::StopThread();
	ProducerThread::StopThread();
	DeleteCriticalSection(&m_netCs);
	DeleteCriticalSection(&m_realHwndCs);
	if (m_tcpClient)
	{
		m_tcpClient->CloseConnect();
		delete m_tcpClient;
	}
}

bool CNetWorkOper::Initialize()
{
	if (NULL != m_tcpClient)
	{
		return true;
	}

	InitializeCriticalSection(&m_MutexSec);
	m_tcpClient = new CTransferCtrl();
	return m_tcpClient->Initialize();
}

bool CNetWorkOper::StartConnect(CString strDstIP, int iPort)
{
	if (strDstIP.IsEmpty() || iPort < 1)
	{
		if (LANG_ZHCN == g_iUILanguage)
			AfxMessageBox(_T("输入服务器参数错误"));
		else
			MessageBoxEx(NULL, _T("Input server param error"), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
		return false;
	}
	CString strLog;	
	strLog.Format(_T("zm: CNetWorkOper::StartConnect connect to server ip=%s, port=%d"), strDstIP, iPort);
	CFileOperTools::GetInstance()->WriteComLog(strLog);
	if (NULL == m_tcpClient || !m_tcpClient->ConnectToServer(strDstIP, iPort))
	{		
		strLog.Format(_T("zm: CNetWorkOper::StartConnect connect to server ip=%s, port=%d failed."), strDstIP, iPort);
		CFileOperTools::GetInstance()->WriteComLog(strLog);
		return false;
	}

	strLog.Format(_T("zm: CNetWorkOper::StartConnect connect to server ip=%s, port=%d success."), strDstIP, iPort);
	CFileOperTools::GetInstance()->WriteComLog(strLog);
	return true;
}

bool CNetWorkOper::StartWork()
{
	if (NULL == m_tcpClient || !m_tcpClient->GetConnectStatus())
	{
		if (LANG_ZHCN == g_iUILanguage)
			AfxMessageBox(_T("请先连接服务器"));
		else
			MessageBoxEx(NULL, _T("Please connect to server firstly."), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
		return false;
	}
	if (m_pThread)
	{
		//		AfxMessageBox(_T("Thread has been started,no need to start."));
		return true;
	}
	ConsumerThread::StartThread();
	ProducerThread::StartThread();

	/*m_pThread = AfxBeginThread(StartProcFunc,(LPVOID)this);
	if (NULL == m_pThread)
	{
	AfxMessageBox(_T("Create process data thread failed."));
	return false;
	}*/
	//ProducerThread::StartThread();
	return true;

}

bool CNetWorkOper::TransferOper(BYTE ucCmd, STSendDataInfo* pSendCtrl, bool bIsNeedResp, STRespDataInfo* pRespInfo, PNOTIFY_FUNC pNotifyFunc, LPVOID lpParam)
{
	if (m_bIsTransfer)
	{
		if (LANG_ZHCN == g_iUILanguage)
			AfxMessageBox(_T("请等待转发完成，在启动一个新的转发前"));
		else
			MessageBoxEx(NULL, _T("Please wait for transfer complete before start a new taransfer"), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
		return false;
	}
	EnterCriticalSection(&m_MutexSec);

	m_ucCmd = ucCmd;
	memset(m_chSendBuf, 0, sizeof(m_chSendBuf));
	memcpy(m_chSendBuf, pSendCtrl->pData, pSendCtrl->wDataLen);
	m_stSendCtrlInfo.pData = m_chSendBuf;
	m_stSendCtrlInfo.wDataLen = pSendCtrl->wDataLen;
	m_stSendCtrlInfo.ucDstType = pSendCtrl->ucDstType;
	m_stSendCtrlInfo.uiDevID = pSendCtrl->uiDevID;
	m_bIsNeedSend = true;

	m_bIsNeedResp = bIsNeedResp;
	memcpy(&m_stRespDataInfo, pRespInfo, sizeof(STRespDataInfo));
	m_pNotifyFunc = pNotifyFunc;
	m_pNotifyParam = lpParam;
	LeaveCriticalSection(&m_MutexSec);
	return true;
}

bool CNetWorkOper::ProcPlcStatus(char* pData, int iLen)
{
	if (iLen != sizeof(STRemPlcDataInfo))
	{
		CString strErr = _T("");
		if (LANG_ZHCN == g_iUILanguage)
		{
			strErr.Format(_T("接受PLC状态长度错误，接收长度 %d,实际长度 %d"), iLen, sizeof(STRemPlcDataInfo));			
			AfxMessageBox(strErr);
		}
		else
		{
			strErr.Format(_T("Recv Plc status length error,recv_value = %d,should be %d"), iLen, sizeof(STRemPlcDataInfo));
			MessageBoxEx(NULL, strErr, STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
		}
		
		return false;
	}
	const char* pPlcData = pData;
	//////////////////////////temp add 临时增加接收到定时任务后发送回应////////////////////////////////////////////////
	SendCtrlMsgDirect(0x88, ntohl(m_tcpClient->GetPlcAddr()), 4, NULL, 0);
	//////////////////////////////////////////////////////////////////////////
	CTaskDataOper dataOper;
	return dataOper.InsertPlcStatusData((const STRemPlcDataInfo*)pPlcData);


}

bool CNetWorkOper::SendCtrlMsgDirect(BYTE ucCmd, UINT32 uiDevID, BYTE ucDevType, const char* pData, WORD wDataLen)
{
	if (NULL == m_tcpClient || !m_tcpClient->GetConnectStatus())
	{
		CFileOperTools::GetInstance()->WriteComLog(_T("zm: SendCtrlMsgDirect GetConnectStatus --------------------------"));
		return false;
	}
	EnterCriticalSection(&m_MutexSec);
	STTransCtrlInfo stTransCtrl;
	stTransCtrl.ucCmd = ucCmd;
	stTransCtrl.uiDevID = uiDevID;
	stTransCtrl.ucDevType = ucDevType;

	bool bRes = m_tcpClient->SendCtrlInfo((const char*)(&stTransCtrl), pData, wDataLen);
	LeaveCriticalSection(&m_MutexSec);
	if (bRes)
		m_ucCmd = ucCmd;
	return bRes;

}

int CNetWorkOper::RecvMsgDirect(char* pData, int* pRecvLen, int iMaxRecvLen, int iTimeout)
{
	if (NULL == m_tcpClient || !m_tcpClient->GetConnectStatus())
	{
		CFileOperTools::GetInstance()->WriteComLog(_T("zm: RecvMsgDirect GetConnectStatus --------------------------"));
		//AfxMessageBox(_T("Line break;"));
		return EN_RECV_LINK_INTERRUPT;
	}
	EnterCriticalSection(&m_MutexSec);
	int iRet = m_tcpClient->RecvRspMsg(pData, pRecvLen, iMaxRecvLen, iTimeout);
	LeaveCriticalSection(&m_MutexSec);
	return iRet;

}



void CNetWorkOper::ClearSendInfo()
{
	CAutoLock clsLock(&m_MutexSec);
	m_ucCmd = 0;
	m_bIsNeedSend = false;
	m_bIsNeedResp = false;
	memset(&m_stSendCtrlInfo, 0, sizeof(m_stSendCtrlInfo));
	memset(&m_stRespDataInfo, 0, sizeof(m_stRespDataInfo));
}

void CNetWorkOper::ClearNotfiyFuncInfo()
{
	CAutoLock clsLock(&m_MutexSec);
	m_pNotifyFunc = NULL;
	m_pNotifyParam = NULL;

}

bool CNetWorkOper::SendLoginMsgBrocast()
{

	BYTE ucData = 3;
	UINT32 uiDevID = 0;
	SendCtrlMsgDirect(0xFE, uiDevID, 3, (char*)(&ucData), 1);
	return true;
}

void CNetWorkOper::PutRequestPacket(const STRequestPacket& clsRequestPacket)
{
	LPEQUESTPACKET pRequestPacket = new STRequestPacket();
	pRequestPacket->dwMsgID = clsRequestPacket.dwMsgID;
	pRequestPacket->hWnd = clsRequestPacket.hWnd;
	pRequestPacket->clsPacketBase.ucCmd = clsRequestPacket.clsPacketBase.ucCmd;
	pRequestPacket->clsPacketBase.ucDevType = clsRequestPacket.clsPacketBase.ucDevType;
	pRequestPacket->clsPacketBase.uiDevID = clsRequestPacket.clsPacketBase.uiDevID;
	pRequestPacket->wDataLen = clsRequestPacket.wDataLen;
	pRequestPacket->iMaxRecvLen = clsRequestPacket.iMaxRecvLen;
	pRequestPacket->iTimeout = clsRequestPacket.iTimeout;

	pRequestPacket->pData = new char[clsRequestPacket.wDataLen];
	memcpy_s((void *)pRequestPacket->pData, clsRequestPacket.wDataLen, clsRequestPacket.pData, clsRequestPacket.wDataLen);

	this->PutDataToQue(pRequestPacket);
}

void CNetWorkOper::ReleaseData(void* pData)
{
	LPEQUESTPACKET pRequestPacket = (LPEQUESTPACKET)pData;
	if (NULL == pRequestPacket)
	{
		return;
	}

	if (pRequestPacket->pData != NULL)
	{
		delete[] pRequestPacket->pData;
		pRequestPacket->pData = NULL;
	}
	delete[] pRequestPacket;
	pRequestPacket = NULL;
}

void CNetWorkOper::ConsumeDataFromQue(void * pData)
{
	LPEQUESTPACKET pRequestPacket = (LPEQUESTPACKET)pData;
	if (NULL == pRequestPacket)
	{
		return;
	}

	DWORD dwWParam = -1;  //0-获取消息成功 1-发送消息失败  2-获取数据失败 
	char *pRecvDataBuf = NULL;
	int iRet = 0;
	int iLen = 0;
	{
		CAutoLock clsAutoLock(&m_netCs);
		if (!SendCtrlMsgDirect(pRequestPacket->clsPacketBase.ucCmd, pRequestPacket->clsPacketBase.uiDevID,
			pRequestPacket->clsPacketBase.ucDevType, pRequestPacket->pData, pRequestPacket->wDataLen))
		{
			dwWParam = 11;
		}

		//只有点名函数需要处理
		if ((EN_CTRL_ROLLCALL_CABLE == pRequestPacket->clsPacketBase.ucCmd)
			|| (EN_REQ_DOWNLOAD_CABLE_INFO == pRequestPacket->clsPacketBase.ucCmd))
		{
			::SendMessage(pRequestPacket->hWnd, WM_MSG_SEND_CABLE_ROLLCALL, dwWParam, pRequestPacket->clsPacketBase.ucCmd);
		}

		pRecvDataBuf = new char[pRequestPacket->iMaxRecvLen];

		iLen = pRequestPacket->iMaxRecvLen;
		iRet = RecvMsgDirect(pRecvDataBuf, &iLen, pRequestPacket->iMaxRecvLen, pRequestPacket->iTimeout);
		if (EN_RECV_SUCCESS != iRet)
		{
			dwWParam = 22;
		}
	}

	if (-1 != dwWParam)
	{
		::SendMessage(pRequestPacket->hWnd, pRequestPacket->dwMsgID, iRet, NULL);
		//::SendMessage(pRequestPacket->hWnd, pRequestPacket->dwMsgID, dwWParam, NULL);
		delete[] pRecvDataBuf;
		return;
	}

	dwWParam = 0;
	ST_RESPONSE_PACKET clsResponsePacket;
	clsResponsePacket.clsPacketBase.ucCmd = pRequestPacket->clsPacketBase.ucCmd;
	clsResponsePacket.clsPacketBase.ucDevType = pRequestPacket->clsPacketBase.ucDevType;
	clsResponsePacket.clsPacketBase.uiDevID = pRequestPacket->clsPacketBase.uiDevID;
	clsResponsePacket.pData = pRecvDataBuf;
	clsResponsePacket.wDataLen = iLen;

	::SendMessage(pRequestPacket->hWnd, pRequestPacket->dwMsgID, dwWParam, (LPARAM)&clsResponsePacket);
	delete[] pRecvDataBuf;
	pRecvDataBuf = NULL;
}

void CNetWorkOper::RegeditRealMsgCall(HWND hWnd)
{
	CAutoLock clsLock(&m_realHwndCs);
	list<HWND>::iterator iterFind = std::find(m_listRealHwnd.begin(), m_listRealHwnd.end(), hWnd);
	if (iterFind != m_listRealHwnd.end())
	{
		return;
	}

	m_listRealHwnd.push_back(hWnd);
}

void CNetWorkOper::UnRegeditRealMsgCall(HWND hWnd)
{
	CAutoLock clsLock(&m_realHwndCs);
	list<HWND>::iterator iterFind = std::find(m_listRealHwnd.begin(), m_listRealHwnd.end(), hWnd);
	if (iterFind == m_listRealHwnd.end())
	{
		return;
	}
	m_listRealHwnd.erase(iterFind);
}
void CNetWorkOper::ThreadFunction()
{
	while (ProducerThread::m_bEngineRunning)
	{
		if (!m_tcpClient->GetConnectStatus())
		{
			CFileOperTools::GetInstance()->WriteComLog(_T("zm: ThreadFunction() GetConnectStatus --------------------------"));
			//隔30秒进行重连操作
			//m_tcpClient->CloseConnect();
			//Sleep(10000);
			if (!m_tcpClient->ReConnect())
			{
				CFileOperTools::GetInstance()->WriteComLog(_T("zm: ThreadFunction() ReConnect() --------------------------"));
				Sleep(5000);
				continue;
			}
		}

		int iCtrlLen = 0;
		int iRet;
		int iCtrlRes;

		{
			CAutoLock clsAutoLock(&m_netCs);
			//接收实时消息并判断是否有接受到控制类的报文
			iCtrlRes = m_tcpClient->RecvCtrlMsg(m_chRcvCtrlBuf, &iCtrlLen, MAX_RCV_CTRLBUF, 100);
		}
		if (EN_RECV_CTRL_CMD == iCtrlRes)
		{
			CFileOperTools::GetInstance()->WriteComLog("zm:EN_RECV_CTRL_CMD begin..................");

			BYTE ucCmd = m_tcpClient->GetCurrCtrlCmd();
			if (m_pDevNotifyFunc)
			{
				STCtrlCmdInfo stCtrlCmd;
				stCtrlCmd.iDataLen = iCtrlLen;
				stCtrlCmd.pData = m_chRcvCtrlBuf;
				m_pDevNotifyFunc(&stCtrlCmd, ucCmd, m_pDevNotfiyParam);
				CFileOperTools::GetInstance()->WriteComLog("zm:EN_RECV_CTRL_CMD ..................");
			}

			CFileOperTools::GetInstance()->WriteComLog("zm:EN_RECV_CTRL_CMD end..................");
			//如果是WIFI连接的话，则需要发送回应
			if (EN_TRANSFER_FILE_BY_WIFI == g_iTransFileMode && 0 == ucCmd)
			{
				CFileOperTools::GetInstance()->WriteComLog("zm:EN_TRANSFER_FILE_BY_WIFI begin ..................");
				if (iCtrlLen != 7 || ntohs(*(WORD*)(m_chRcvCtrlBuf)) != 1)
				{
					CString strErrTxt = _T("");
					if (LANG_ZHCN == g_iUILanguage)
					{
						strErrTxt.Format(_T("严重错误.命令长度 = %d, 设备号 = %d"), iCtrlLen, ntohs(*(WORD*)(m_chRcvCtrlBuf)));
						AfxMessageBox(strErrTxt);
					}
					else
					{
						strErrTxt.Format(_T("Serious error.ctr_data_len = %d, dev_number = %d"), iCtrlLen, ntohs(*(WORD*)(m_chRcvCtrlBuf)));
						MessageBoxEx(NULL, strErrTxt, STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
					}					
					continue;
				}
				STTransCtrlInfo stTransCtrl;
				stTransCtrl.ucCmd = 0;
				stTransCtrl.ucDevType = 3;
				stTransCtrl.uiDevID = *((UINT*)(m_chRcvCtrlBuf + 3));
				BYTE ucData = 3;
				CAutoLock clsAutoLock(&m_netCs);
				m_tcpClient->SendCtrlInfo((const char*)(&stTransCtrl), (char*)(&ucData), 1, 2);
				CFileOperTools::GetInstance()->WriteComLog("zm:EN_TRANSFER_FILE_BY_WIFI end ..................");
			}

		}
		else if (EN_RECV_PLC_STATUS == iCtrlRes)
		{
			CFileOperTools::GetInstance()->WriteComLog("zm:EN_RECV_PLC_STATUS begin...............");
			CAutoLock clsAutoLock(&m_netCs);
			ProcPlcStatus(m_chRcvCtrlBuf, iCtrlLen);
			memset(m_chRcvCtrlBuf, 0, sizeof(m_chRcvCtrlBuf));
			CFileOperTools::GetInstance()->WriteComLog("zm:EN_RECV_PLC_STATUS end...............");
			continue;
		}
		else if (EN_REAL_TIME_TESTING_DATA == iCtrlRes)
		{
			CFileOperTools::GetInstance()->WriteComLog("zm:CNetWorkOper::ThreadFunction EN_REAL_TIME_TESTING_DATA begin...............");
			//if (ucCmd == EN_CTRL_MEASURE_DATA)//接收到服务端正在测量的数据
			{
				if (m_listRealHwnd.size() <= 0)
				{
					continue;
				}
				CString str;
				list<HWND>::iterator iterCur = m_listRealHwnd.begin();
				list<HWND>::iterator iterEnd = m_listRealHwnd.end();
				str.Format(_T("zm:wnd address iterCur=%0x, *iterCur=%0x"), iterCur, *iterCur);
				CFileOperTools::GetInstance()->WriteComLog(str);
				if (iCtrlLen == 0)
				{
					iCtrlLen = MAX_RCV_CTRLBUF;
				}
				for (; iterCur != iterEnd; ++iterCur)
				{
					if (IsWindowVisible(*iterCur))
					{
						::SendMessage(*iterCur, WM_NET_RECV_REAL_TIME_DATA, (WPARAM)m_chRcvCtrlBuf, iCtrlLen);
						CFileOperTools::GetInstance()->WriteComLog("zm:CNetWorkOper::ThreadFunction EN_REAL_TIME_TESTING_DATA end...............");
					}
				}
				continue;
			}
		}
		else if (EN_RECV_SUCCESS == iCtrlRes)
		{
			CFileOperTools::GetInstance()->WriteComLog("zm:CNetWorkOper::ThreadFunction EN_RECV_SUCCESS == iCtrlRes...............");
			memset(m_chRcvCtrlBuf, 0, sizeof(m_chRcvCtrlBuf));
		}
		else if (EN_RECV_NOTIFY_DEVICE_ONLINE == iCtrlRes)
		{
			if (NULL == m_chRcvCtrlBuf)
				continue;

			//数量(2bytes)，1类型(1byte)，1sn(4byte)，2类型，2sn
			u_short* pDevNum = NULL;
			pDevNum = (u_short*)(&m_chRcvCtrlBuf);
			u_short usDevNum = ntohs(*pDevNum);
			UINT32* uiDevID = NULL;
			BYTE* pByDevType = NULL;
			BYTE devType = 0;
			CString strDevSN,strLog;
			for (int i = 0; i < usDevNum; i++)
			{
				pByDevType = (BYTE*)(&m_chRcvCtrlBuf[sizeof(short)]);
				devType = *pByDevType;
				switch (devType)
				{
				case EN_DEV_GD10:
				{
					uiDevID = (UINT32*)(&m_chRcvCtrlBuf[sizeof(short) + (i + 1)*sizeof(BYTE) + i*sizeof(UINT)]);
					strDevSN.Format(_T("SN%d"), ntohl(*uiDevID));
					strLog.Format(_T("zm:设备列表添加设备GD CNetWorkOper::ThreadFunction 接收到设备上线:%s"), strDevSN);
					CFileOperTools::GetInstance()->WriteComLog(strLog);
					STSigRemoteDev stRemoteDev;
					stRemoteDev.ucDevType = EN_DEV_GD10;
					stRemoteDev.uiDevID = ntohl(*uiDevID);
					//开机
					theApp.m_pDevManager->AddRemoteDevice(stRemoteDev);
					theApp.m_pDevManager->DeleteObjInMem(strDevSN);
				}
				break;
				case EN_DEV_PLC:
				{
					uiDevID = (UINT32*)(&m_chRcvCtrlBuf[sizeof(short) + (i + 1)*sizeof(BYTE) + i*sizeof(UINT)]);
					strDevSN.Format(_T("PLC%d"), ntohl(*uiDevID));
					strLog.Format(_T("zm:设备列表添加设备PLC CNetWorkOper::ThreadFunction 接收到设备上线:%s"), strDevSN);
					CFileOperTools::GetInstance()->WriteComLog(strLog);
					STSigRemoteDev stRemoteDev;
					stRemoteDev.ucDevType = EN_DEV_PLC;
					stRemoteDev.uiDevID = ntohl(*uiDevID);
					//开机
					theApp.m_pDevManager->AddRemoteDevice(stRemoteDev);
					theApp.m_pDevManager->DeleteObjInMem(strDevSN);
				}
				break;
				default:
					break;
				}
			}

			/*CString strLog;
			UINT32* uiDevID = NULL;
			CString strDevSN;
			uiDevID = (UINT32*)(&m_chRcvCtrlBuf[3]);
			strDevSN.Format(_T("SN%d"), ntohl(*uiDevID));
			strLog.Format(_T("zm:设备列表添加设备CNetWorkOper::ThreadFunction 接收到设备上线:%s"), strDevSN);
			CFileOperTools::GetInstance()->WriteComLog(strLog);
			STSigRemoteDev stRemoteDev;
			stRemoteDev.ucDevType = EN_DEV_GD10;
			stRemoteDev.uiDevID = ntohl(*uiDevID);
			//开机
			theApp.m_pDevManager->AddRemoteDevice(stRemoteDev);
			theApp.m_pDevManager->DeleteObjInMem(strDevSN);*/
			CMainFrame* pMainFrm = (CMainFrame*)AfxGetApp()->GetMainWnd();
			if (NULL != pMainFrm)
			{
				pMainFrm->SendMessage(WM_MSG_NOTIFY_DEVICE_ON_OR_OFF, (WPARAM)0, (LPARAM)0);
			}
		}
		else if (EN_RECV_NOTIFY_DEVICE_OFFLINE == iCtrlRes)
		{
			if (NULL == m_chRcvCtrlBuf)
				continue;

			CString strLog;
			UINT32* uiDevID = NULL;
			CString strDevSN;
			uiDevID = (UINT32*)(&m_chRcvCtrlBuf);
			strDevSN.Format(_T("SN%d"), ntohl(*uiDevID));
			strLog.Format(_T("zm:设备列表移除设备CNetWorkOper::ThreadFunction 接收到设备离线:%s"), strDevSN);
			CFileOperTools::GetInstance()->WriteComLog(strLog);

			STSigRemoteDev stRemoteDev;
			stRemoteDev.ucDevType = EN_DEV_GD10;
			stRemoteDev.uiDevID = ntohl(*uiDevID);
			//关机
			theApp.m_pDevManager->DeleteRemoteDevice(stRemoteDev);
			theApp.m_pDevManager->AddOfflineObjInMem(strDevSN);
			CMainFrame* pMainFrm = (CMainFrame*)AfxGetApp()->GetMainWnd();
			if (NULL != pMainFrm)
			{
				pMainFrm->SendMessage(WM_MSG_NOTIFY_DEVICE_ON_OR_OFF, (WPARAM)0, (LPARAM)0);
			}
		}	

		if (m_bIsNeedSend)
		{
			OutputDebugString(_T("zm:zm is enter if (m_bIsNeedSend) \n\n"));
			CString strLog;
			CFileOperTools::GetInstance()->WriteComLog("zm:m_bIsNeedSend begin..............");
			CAutoLock clsAutoLock(&m_netCs);
			STTransCtrlInfo stTransCtrl;
			stTransCtrl.ucCmd = m_ucCmd;
			stTransCtrl.ucDevType = m_stSendCtrlInfo.ucDstType;
			stTransCtrl.uiDevID = m_stSendCtrlInfo.uiDevID;
			//如果之前的接收操作失败，则在发送数据之前清空接收缓冲区
			// 			if (iRet!=EN_RECV_SUCCESS)
			// 			{
			// 				pNetOper->m_tcpClient->ClearRecvBuffer();
			// 			}
			//如果发送失败，则中断此次操作
			if (false == m_tcpClient->SendCtrlInfo((const char*)&stTransCtrl, m_stSendCtrlInfo.pData, m_stSendCtrlInfo.wDataLen))
			{
				//如果有通知的函数接口，则进行操作结果的通知
				if (m_pNotifyFunc)
				{
					strLog.Format(_T("zm:m_bIsNeedSend TransferOper cmd=%0x, DevType=%d, DevID=%u failed"), stTransCtrl.ucCmd, stTransCtrl.ucDevType, stTransCtrl.uiDevID);
					CFileOperTools::GetInstance()->WriteComLog(strLog);
					m_pNotifyFunc(EN_NETWORK_SEND, EM_SEND_FAILED, m_pNotifyParam);
				}
				ClearNotfiyFuncInfo();

				ClearSendInfo();
				//	pNetOper->m_tcpClient->ClearRecvBuffer();
				continue;
			}
			m_bIsNeedSend = false;
			strLog.Format(_T("zm:m_bIsNeedSend TransferOper cmd=%0x, DevType=%d, DevID=%u success"), stTransCtrl.ucCmd, stTransCtrl.ucDevType, stTransCtrl.uiDevID);
			CFileOperTools::GetInstance()->WriteComLog(strLog);
			//如果需要接受数据的话，则此刻进行数据的接收操作
			if (m_bIsNeedResp)
			{
				int iRecvLen = 0;

				iRet = m_tcpClient->RecvRspMsg(m_stRespDataInfo.pData, m_stRespDataInfo.pRecvLen,
					m_stRespDataInfo.iMaxRcvLen, m_stRespDataInfo.iTimeout);
				while ((EN_RECV_CTRL_CMD == iRet) || (EN_RECV_PLC_STATUS == iCtrlRes))
				{
					if (EN_RECV_PLC_STATUS == iCtrlRes)
					{
						ProcPlcStatus(m_stRespDataInfo.pData, *(m_stRespDataInfo.pRecvLen));
						//	memset(pNetOper->m_chRcvCtrlBuf, 0, sizeof(pNetOper->m_chRcvCtrlBuf));
					}
					else
					{
						if (EN_TRANSFER_FILE_BY_WIFI == g_iTransFileMode)
						{
							if (LANG_ZHCN == g_iUILanguage)
								AfxMessageBox(_T("在WiFi模式接收数据时控制命令不能被接收"));
							else
								MessageBoxEx(NULL, _T("Ctrl_cmd can not be received when rece data in wifi mode"), STRING_MESSAGEBOXEX_TITLE, MB_OK, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US));
							break;
						}
						if (m_pDevNotifyFunc)
						{
							STCtrlCmdInfo stCtrlCmd;
							stCtrlCmd.iDataLen = *(m_stRespDataInfo.pRecvLen);
							stCtrlCmd.pData = m_stRespDataInfo.pData;
							m_pDevNotifyFunc(&stCtrlCmd, m_tcpClient->GetCurrCtrlCmd(), m_pDevNotfiyParam);
						}
					}

					iRet = m_tcpClient->RecvRspMsg(m_stRespDataInfo.pData, m_stRespDataInfo.pRecvLen,
						m_stRespDataInfo.iMaxRcvLen, m_stRespDataInfo.iTimeout);
				}

				if (m_ucCmd == EN_CTRL_MEASURE_DATA)
				{
					CFileOperTools::GetInstance()->WriteComLog(_T("zm:debugging measure task wnd m_ucCmd == EN_CTRL_MEASURE_DATA is need transfer"));
					//调测测量窗口，可能关闭了
					if (g_bIsOnlineTransfer == FALSE)
					{
						CFileOperTools::GetInstance()->WriteComLog(_T("zm:debugging measure task wnd g_bIsOnlineTransfer == FALSE"));
						if (m_pNotifyFunc)
						{
							// 					if (iRet != EN_RECV_SUCCESS)
							// 					{
							// 						pNetOper->m_tcpClient->ClearRecvBuffer();
							// 					}
							m_pNotifyFunc(EN_NETWORK_RECV, iRet, m_pNotifyParam);
						}
					}					
				}
				else
				{
					if (m_pNotifyFunc)
					{
						CFileOperTools::GetInstance()->WriteComLog(_T("zm:m_ucCmd != EN_CTRL_MEASURE_DATA"));
						strLog.Format(_T("zm: m_stRespDataInfo.pData="));
						for (int i = 0; i < *m_stRespDataInfo.pRecvLen; i++)
						{
							strLog.AppendFormat(_T(" %02x"), m_stRespDataInfo.pData[i]);
						}
						CFileOperTools::GetInstance()->WriteComLog(strLog);

						strLog.Format(_T("zm:m_stRespDataInfo.pRecvLen=%d"), *m_stRespDataInfo.pRecvLen);
						CFileOperTools::GetInstance()->WriteComLog(strLog);
						// 					if (iRet != EN_RECV_SUCCESS)
						// 					{
						// 						pNetOper->m_tcpClient->ClearRecvBuffer();
						// 					}
						m_pNotifyFunc(EN_NETWORK_RECV, iRet, m_pNotifyParam);
					}
				}				

				CFileOperTools::GetInstance()->WriteComLog("zm:m_bIsNeedSend end..............");
			}
			ClearNotfiyFuncInfo();
			ClearSendInfo();
		}/*else if (iCtrlRes == EN_RECV_SUCCESS)
		{
			//bRet = true;
			list<HWND>::iterator iterCur = m_listRealHwnd.begin();
			list<HWND>::iterator iterEnd = m_listRealHwnd.end();
			for (; iterCur != iterEnd; ++iterCur)
			{
				::SendMessage(*iterCur, WM_NET_RECV_REAL_TIME_DATA, (WPARAM)m_chRcvCtrlBuf, iCtrlLen);
			}
		}*/
	}
}
void CNetWorkOper::SetSuspendForThread(bool bIsSuspend)
{
	m_bIsSuspend = bIsSuspend;
}