Work/CapServer/MonitorThread.cpp

#include <common/windows.hpp>
#include <common/array.hpp>
#include <common/openfile.hpp>
#include <CapServer/MonitorThread.hpp>
#include <CapServer/SocketHeader.hpp>
#include <socket/socket.hpp>
#include <socket/hostent.hpp>

MonitorThread::MonitorThread()
: mIsRunning(false), mTimeout(DefaultTimeout)
{
  mCallback.setCallback(this,&MonitorThread::threadCallback);
	insertHandler(&mCallback);
}

MonitorThread::~MonitorThread()
{
  stop();
  removeHandler(&mCallback);
}

void MonitorThread::startMonitor(const String &host,int port,DWORD timeout)
{
  message("MonitorThread::startMonitor");
  ThreadMessage threadMessage(ThreadMessage::TM_USER,MsgMonitorStart);
	mHost=host;
	mPort=port;
	mTimeout=timeout;
	getHostAddress();
	postMessage(threadMessage);
}

void MonitorThread::stopMonitor(void)
{
  message("MonitorThread::startMonitor");
  ThreadMessage threadMessage(ThreadMessage::TM_USER,MsgMonitorStop);
	postMessage(threadMessage);
	mMonitorEvent.waitEvent();
}

DWORD MonitorThread::threadCallback(ThreadMessage &threadMessage)
{
	switch(threadMessage.message())
	{
	  case ThreadMessage::TM_CREATE :
		  break;
	  case ThreadMessage::TM_DESTROY :
		  break;
	  case ThreadMessage::TM_USER :
	    switch(MonitorThMsg(threadMessage.userDataOne()))
		  {
			  case MsgMonitorStart :
				  handleMonitorStart();
					break;
				case MsgMonitorStop :
				  handleMonitorStop();
					break;
			}
			break;
	}
  return 0;
}

void MonitorThread::handleMonitorStart()
{
	DWORD elapsedTime;
  message("[MonitorThread::handleMonitorStart]ENTER");
  mIsRunning=true;
  message(String("[MonitorThread::handleMonitorStart]InitDelay=")+String().fromInt(InitDelay)+String(" (ms)."));
	::Sleep(InitDelay);
	while(mIsRunning)
	{
		elapsedTime=::GetTickCount();
		getImage();
		elapsedTime=::GetTickCount()-elapsedTime;
	  message("[MonitorThread::handleMonitorStart]GetImage Took "+String().fromInt(elapsedTime)+String(" (ms)."));
	  ::Sleep(mTimeout);
	}
  message("]MonitorThread::handleMonitorStart]LEAVE");
}

void MonitorThread::handleMonitorStop()
{
  message("[MonitorThread::handleMonitorStop]ENTER");
  message("[MonitorThread::handleMonitorStop]LEAVE");
  mIsRunning=false;
}

void MonitorThread::getHostAddress()
{
	Block<InternetAddress> internetAddresses;
	HostEnt hostEnt;

  hostEnt.hostByName(mHost);
	internetAddresses=hostEnt.addresses();
	if(!internetAddresses.size())return;
	for(int index=0;index<internetAddresses.size();index++)
	{
    message(String("[MonitorThread::getHostAddress]")+mHost+String("->")+internetAddresses[0].toString());
	}
	mInternetAddress=internetAddresses[0];
}

void MonitorThread::getImage()
{
  INETSocketAddress internetSocketAddress;
	Socket socket;
	SocketHeader socketHeader;
	Array<BYTE> content;

	message("[MonitorThread::getImage]starting client");
	internetSocketAddress.family(PF_INET);
	internetSocketAddress.port(mPort);
	internetSocketAddress.internetAddress(mInternetAddress);
	if(!socket.create())
	{
	  message("[MonitorThread::getImage]create socket failed...");
	  return;
	}
	if(!socket.connect(internetSocketAddress))
	{
	  message(String("[MonitorThread::getImage]connect to '")+internetSocketAddress.toString()+String("' failed..."));
	  return;
	}
	message("[MonitorThread::getImage]reading socket header...");
	socketHeader.unmarshall(socket);
  message("[MonitorThread::getImage]header length",socketHeader.getSizeHeader());
  message("[MonitorThread::getImage]version",socketHeader.getVersion());
  message("[MonitorThread::getImage]content length",socketHeader.getContentLength());
  message("[MonitorThread::getImage]content type",(int)socketHeader.getContentType());
	content.size(socketHeader.getContentLength());
	message("[MonitorThread::getImage]reading content...");
	socket.receive((char*)&content[0],content.size());
	saveImage(content);
	message("[MonitorThread::getImage]done...");
	socket.destroy();
}

bool MonitorThread::saveImage(Array<BYTE> &imageData)
{
  SystemTime systemTime;
  String strPathImageFile;
  FileHandle openFile;

  if(!imageData.size())return message("[MonitorThread::saveImage] No Data"),false;
  strPathImageFile.reserve(1024);
  ::sprintf(strPathImageFile,"%04d%02d%02d%02d%02d%02d%02d.jpg",
	  systemTime.year(),systemTime.month(),systemTime.day(),
		systemTime.hour(),systemTime.minute(),systemTime.second(),
		systemTime.milliseconds());
	if(!openFile.open(strPathImageFile,FileHandle::Write,FileHandle::ShareRead,FileHandle::Overwrite))
	{
	  message(String("[MonitorThread::saveImage]Open '")+strPathImageFile+String("' for write Failed."));
	  return false;
	}
	openFile.write(&imageData[0],imageData.size());
	openFile.close();
	return true;
}