//NetworkManager.h
#ifndef _NET_WORK_MANAGER_
#define _NET_WORK_MANAGER_
#include "event2/util.h"
#include "event_struct.h"
#include<vector>
struct event_base;
struct evconnlistener;
struct sockaddr_in;
struct NetObserver
{
virtual void onReadDataNotify(struct bufferevent* be, const char* data,size_t size) {}
virtual void onCmdNotify(const char* data,size_t size) {}
};
class NetworkManager
{
public:
static NetworkManager* getInstance();
static void listenerEventBuffer(struct evconnlistener* listener, evutil_socket_t,struct sockaddr* addr, int socklen, void* data);
static void readEventBuffer(struct bufferevent* be,void* data);
static void writeEventBuffer(struct bufferevent* be,void* data);
static void eventEventBuffer(struct bufferevent *bev, short events, void *user_data);
static void timer(int fd, short event, void* arg);
static void eventLog(int severity, const char *msg);
void addObserver(NetObserver* observer);
void removeObserver(NetObserver* observer);
bool init(int port);
void listener(struct evconnlistener* listener, evutil_socket_t,struct sockaddr* addr);
void read(struct bufferevent* be);
void write(struct bufferevent* be, const char* data,size_t len);
void event(struct bufferevent* be,short events);
char* getDataBuffer(size_t size);
void dispatch();
void update();
private:
NetworkManager();
~NetworkManager();
private:
evconnlistener * m_listener;
event_base* m_eventBase;
struct event* m_timer;
struct timeval m_timeval;
sockaddr_in* m_lisSockAddr;
std::vector<NetObserver*> m_observers;
char* m_dataBuff;
size_t m_buffSize;
};
#endif // _NET_WORK_MANAGER_
//NetworkManager.cpp
#include "NetworkManager.h"
#include<string.h>
#include<stdio.h>
#include<chrono>
#include "event.h"
#include "listener.h"
#include "bufferevent.h"
#include "evutil.h"
#ifdef _WIN32
#include<WinSock2.h>
#endif
NetworkManager* NetworkManager::getInstance()
{
static NetworkManager mgr;
return &mgr;
}
void NetworkManager::listenerEventBuffer(struct evconnlistener* listener, evutil_socket_t fd,struct sockaddr* addr, int socklen, void* data)
{
NetworkManager::getInstance()->listener(listener,fd,addr);
}
void NetworkManager::readEventBuffer(struct bufferevent* be,void* data)
{
NetworkManager::getInstance()->read(be);
}
void NetworkManager::writeEventBuffer(struct bufferevent* be,void* data)
{
}
void NetworkManager::eventEventBuffer(struct bufferevent *be, short events, void *user_data)
{
NetworkManager::getInstance()->event(be,events);
}
void NetworkManager::timer(int fd, short event, void* arg)
{
NetworkManager::getInstance()->update();
}
void NetworkManager::eventLog(int severity, const char *msg)
{
const char *severity_str;
switch (severity)
{
case _EVENT_LOG_DEBUG:
severity_str = "debug";
break;
case _EVENT_LOG_MSG:
severity_str = "msg";
break;
case _EVENT_LOG_WARN:
severity_str = "warn";
break;
case _EVENT_LOG_ERR:
severity_str = "err";
break;
default:
severity_str = "???";
break;
}
fprintf(stderr, "[%s] %s\n", severity_str, msg);
}
/********************************************************/
NetworkManager::NetworkManager()
:m_listener(NULL)
,m_eventBase(NULL)
,m_lisSockAddr(NULL)
,m_dataBuff(NULL)
,m_buffSize(0)
,m_timer(NULL)
{
m_timeval.tv_sec = m_timeval.tv_usec = 0;
m_lisSockAddr = new sockaddr_in;
#ifdef _WIN32
WSADATA ws;
WSAStartup(MAKEWORD(2, 2), &ws);
#endif
}
NetworkManager::~NetworkManager()
{
delete m_lisSockAddr;
WSACleanup();
}
void NetworkManager::addObserver(NetObserver* observer)
{
for(auto iter = m_observers.begin(); iter != m_observers.end(); ++iter)
{
if((*iter) == observer)
return;
}
m_observers.push_back(observer);
}
void NetworkManager::removeObserver(NetObserver* observer)
{
for(auto iter = m_observers.begin(); iter != m_observers.end(); ++iter)
{
if((*iter) == observer)
{
m_observers.erase(iter);
return;
}
}
}
bool NetworkManager::init(int port)
{
memset(m_lisSockAddr,0,sizeof(sockaddr_in));
m_lisSockAddr->sin_family = AF_INET;
m_lisSockAddr->sin_port = htons(port);
m_eventBase = event_base_new();
if(!m_eventBase)
{
printf("Could not initialize libevent\n");
return false;
}
event_set_log_callback(&NetworkManager::eventLog);
m_listener = evconnlistener_new_bind(m_eventBase,NetworkManager::listenerEventBuffer,(void*)m_eventBase, LEV_OPT_REUSEABLE | LEV_OPT_CLOSE_ON_FREE,1,(struct sockaddr*)m_lisSockAddr ,sizeof(sockaddr_in));
if(!m_listener)
{
int errCode = EVUTIL_SOCKET_ERROR();
const char* reason = evutil_socket_error_to_string(errCode);
event_base_free(m_eventBase);
printf("Could not create a listener, msg : %s\n",reason);
return false;
}
evutil_gettimeofday(&m_timeval, NULL);
struct timeval tv = {1,0};
m_timer = event_new(m_eventBase,-1, EV_PERSIST, &NetworkManager::timer,"update");
event_add(m_timer, &tv);
printf("network init secceed...\n");
return true;
}
void NetworkManager::listener(struct evconnlistener* listener, evutil_socket_t fd,struct sockaddr* addr)
{
struct bufferevent* be = bufferevent_socket_new(m_eventBase,fd, BEV_OPT_CLOSE_ON_FREE);
if(!be)
{
printf("Could not create a bufferevent\n");
event_base_loopbreak(m_eventBase);
return ;
}
printf("connect a client...\n");
bufferevent_setcb(be,NetworkManager::readEventBuffer,NetworkManager::writeEventBuffer,NetworkManager::eventEventBuffer,NULL);
bufferevent_enable(be,EV_READ | EV_WRITE);
const char* str = "login secceed";
write(be,str,strlen(str));
}
void NetworkManager::read(struct bufferevent* be)
{
struct evbuffer* input = bufferevent_get_input(be);
size_t size = evbuffer_get_length(input);
if(size > 0)
{
char* buff = getDataBuffer(size);
bufferevent_read(be,buff,size);
for(auto iter = m_observers.begin(); iter != m_observers.end(); ++iter)
{
(*iter)->onReadDataNotify(be,buff,size);
}
}
}
void NetworkManager::write(struct bufferevent* be, const char* data,size_t len)
{
if(!m_eventBase)
return;
bufferevent_write(be,data,len);
}
void NetworkManager::event(struct bufferevent* be,short events)
{
if (events & BEV_EVENT_EOF)
{
printf("connection close \n");
bufferevent_free(be);
}
else if (events & BEV_EVENT_ERROR)
{
printf("connect error \n");
bufferevent_free(be);
}
else
{
printf("connect a event \n");
}
}
char* NetworkManager::getDataBuffer(size_t size)
{
if(m_buffSize < size)
{
delete [] m_dataBuff;
m_buffSize = 2 * size;
m_dataBuff = new char[m_buffSize];
}
memset(m_dataBuff,0,m_buffSize);
return m_dataBuff;
}
void NetworkManager::dispatch()
{
if(m_eventBase && m_listener)
{
printf("network dispatch...\n");
event_base_dispatch(m_eventBase);
evconnlistener_free(m_listener);
event_base_free(m_eventBase);
}
}
void NetworkManager::update()
{
struct timeval tv, difference;
evutil_gettimeofday(&tv, NULL);
evutil_timersub(&tv, &m_timeval, &difference);
double escape = difference.tv_sec + (difference.tv_usec / 1.0e6);
//printf("escape = %f\n", escape);
m_timeval = tv;
}
