#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>
#include <glib.h>
#include <unistd.h>
using namespace std;
typedef enum _EngineState
{
ENGINE_SERVER_STATE_NONE,
ENGINE_SERVER_STATE_READY,
ENGINE_SERVER_STATE_STARTING,
ENGINE_SERVER_STATE_SENDING,
ENGINE_SERVER_STATE_PROCESSING,
ENGINE_SERVER_STATE_MAX
}EngineState;
typedef enum _eEngineMsg
{
ENGINE_MSG_NONE,
ENGINE_MSG_START,
ENGINE_MSG_REQUEST,
ENGINE_MSG_STOP,
ENGINE_MSG_MAX
}eEngineMsg;
typedef struct _EngineMsg
{
eEngineMsg MsgType;
long param_1;
long param_2;
char* param_3;
bool param_4;
}EngineMsg;
typedef struct _ServerTask
{
GThread *Thread;
GAsyncQueue *Queue;
gint running;
}ServerTask;
class CEngineServer
{
public:
CEngineServer()
{
}
virtual ~CEngineServer()
{
}
void SetServerSRState(EngineState state)
{
m_EngineState = state;
}
EngineState GetServerSRState(void)
{
return m_EngineState;
}
static CEngineServer *GetInstance(void)
{
if(m_pInstance == NULL)
{
m_pInstance = new CEngineServer();
}
return m_pInstance;
}
bool SetServerSRMsg(eEngineMsg MsgType, long MsgParam1 = 0, long MsgParam2 = 0, void* MsgParam3 = NULL, bool openFlag = true)
{
if(m_pServerTask == NULL)
{
printf("[ERROR] Task is not created yet..\n");
return false;
}
if(g_atomic_int_get(&m_pServerTask->running))
{
EngineMsg* tmpMsg = (EngineMsg*)malloc(sizeof(EngineMsg));
if(tmpMsg == NULL)
{
printf("memory allocation fail");
return false;
}
tmpMsg->MsgType = ENGINE_MSG_NONE;
tmpMsg->param_1 = 0;
tmpMsg->param_2 = 0;
tmpMsg->param_3 = NULL;
tmpMsg->param_4 = true;
tmpMsg->MsgType = MsgType;
tmpMsg->param_1 = (long)MsgParam1;
tmpMsg->param_2 = (long)MsgParam2;
tmpMsg->param_3 = (char*)MsgParam3;
tmpMsg->param_4 = openFlag;
g_async_queue_push(m_pServerTask->Queue, (gpointer)tmpMsg);
}
else
{
printf("[ERROR] Task is not running ..\n");
return false;
}
printf("[Engine] success ..\n");
return true;
}
static gpointer t_ServerSRThread(gpointer data)
{
printf("t_ServerSRThread run !\n");
CEngineServer* pSvr = CEngineServer::GetInstance();
pSvr->SetServerSRState(ENGINE_SERVER_STATE_READY);
EngineMsg loopMsg;
while(g_atomic_int_get(&m_pServerTask->running))
{
EngineMsg* msg = NULL;
msg = (EngineMsg*) g_async_queue_try_pop (m_pServerTask->Queue);
if(msg != NULL)
{
loopMsg.MsgType = msg->MsgType;
loopMsg.param_1 = msg->param_1;
loopMsg.param_2 = msg->param_2;
loopMsg.param_3 = msg->param_3;
loopMsg.param_4 = msg->param_4;
}
switch(pSvr->GetServerSRState())
{
case ENGINE_SERVER_STATE_READY:
{
if(loopMsg.MsgType == ENGINE_MSG_START)
{
loopMsg.MsgType = ENGINE_MSG_NONE;
pSvr->SetServerSRState(ENGINE_SERVER_STATE_STARTING);
printf("[Engine] -READY- Start ..\n");
}
break;
}
case ENGINE_SERVER_STATE_STARTING:
{
if(loopMsg.MsgType == ENGINE_MSG_REQUEST)
{
int nServerMode = (int)loopMsg.param_1;
if(nServerMode == (0x01 | 0x02))
{
pSvr->SetServerSRState(ENGINE_SERVER_STATE_SENDING);
printf("[Engine] -STARTING- Open Success, -Sending-\n");
}
}
break;
}
case ENGINE_SERVER_STATE_SENDING:
{
if(loopMsg.MsgType == ENGINE_MSG_STOP)
{
loopMsg.MsgType = ENGINE_MSG_NONE;
pSvr->SetServerSRState(ENGINE_SERVER_STATE_PROCESSING);
printf("[Engine] -SENDING- Receive the Stop, Change Status to Processing ..\n");
}
break;
}
case ENGINE_SERVER_STATE_PROCESSING:
{
bool bEngineStop = true;
if(bEngineStop){
pSvr->SetServerSRState(ENGINE_SERVER_STATE_READY);
printf("[Engine] -ENGINE_SERVER_STATE_READY..\n");
}
if(loopMsg.MsgType == ENGINE_MSG_STOP)
{
pSvr->SetServerSRState(ENGINE_SERVER_STATE_READY);
printf("[Engine] -PROCESSING- ");
}
break;
}
default:
break;
}
}
usleep(8000);
}
int CreateServerTask(void)
{
if(m_pServerTask == NULL)
{
m_pServerTask = g_new(ServerTask, 1);
m_pServerTask->Queue = g_async_queue_new();
g_atomic_int_set (&m_pServerTask->running, 1);
m_pServerTask->Thread = g_thread_new("t_ServerSR", t_ServerSRThread,NULL);
return 0;
}
else
{
printf("[Error] Create Engine Server Task is exist .. ");
return 0;
}
}
private:
EngineState m_EngineState;
static ServerTask * m_pServerTask;
static CEngineServer * m_pInstance;
};
ServerTask *CEngineServer::m_pServerTask = NULL;
CEngineServer* CEngineServer::m_pInstance = NULL;
int main()
{
CEngineServer server;
server.CreateServerTask();
GMainLoop *mainloop = g_main_loop_new(NULL, FALSE);
sleep(3);
server.SetServerSRMsg(ENGINE_MSG_START);
sleep(3);
int mode = 0x01 | 0x02;
server.SetServerSRMsg(ENGINE_MSG_REQUEST, mode);
sleep(3);
server.SetServerSRMsg(ENGINE_MSG_STOP);
g_main_loop_run(mainloop);
return 0;
}
