Cocos2d-x 3.x利用Socket创建客户端和服务端

转载:http://blog.csdn.net/ctxdecs/article/details/42032279

Socket基类

包括Socket的初始化,主要是Windows上，在Android上就不需要了。

如果平台为Windows，则需要初始化

SocketBase::SocketBase()
{
    _bInitSuccess =  false ;
    # if  (CC_TARGET_PLATFORM == CC_PLATFORM_WIN32)
    WORD  wVersionRequested;
    wVersionRequested = MAKEWORD(2, 0);
    WSADATA wsaData;
    int  nRet = WSAStartup(wVersionRequested, &wsaData);
    if  (nRet != 0)
    {
        fprintf (stderr,  "Initilize Error!\n" );
        return ;
    }
    _bInitSuccess =  true ;
    #endif

}

当然析构时也要释放资源

SocketBase::~SocketBase()
{
    # if  (CC_TARGET_PLATFORM == CC_PLATFORM_WIN32)
    if  (_bInitSuccess)
    {
        WSACleanup();
    }
    #endif
}

因为Windows的socket()返回的socket句柄为SOCKET(UINT_PTR)与Android的socket()返回的socket句柄int, 类型不一样，所以都定义为HSocket。

对于服务端和客户端都有关闭连接，所以基类就实现共同的。

void  SocketBase::closeConnect(HSocket socket)
{
    # if  (CC_TARGET_PLATFORM == CC_PLATFORM_ANDROID)
    close(socket);
    #elif (CC_TARGET_PLATFORM == CC_PLATFORM_WIN32)
    closesocket(socket);
    #endif
}

当执行socket()出错时，Windows返回SOCKET_ERROR, Android返回<0，所以实现error()

bool  SocketBase::error(HSocket socket)
{
    # if  (CC_TARGET_PLATFORM == CC_PLATFORM_WIN32)
    return  socket == SOCKET_ERROR;
    #elif (CC_TARGET_PLATFORM == CC_PLATFORM_ANDROID)
    return  socket < 0;
    #endif
}

SocketBase.h

#ifndef __SOCKET_BASE_H__
#define __SOCKET_BASE_H__
#include "cocos2d.h"
#include
#include
USING_NS_CC;
// 对于windows平台
#if (CC_TARGET_PLATFORM == CC_PLATFORM_WIN32)
#include
#pragma comment(lib, "WS2_32.lib")
#define HSocket SOCKET
// 对于android平台
#elif (CC_TARGET_PLATFORM == CC_PLATFORM_ANDROID)
#include    // for inet_**
#include    // for gethost**
#include   // for sockaddr_in
#include    // for socket
#include   // for socket
#include
#include         // for printf
#include   // for exit
#include   // for bzero
#define HSocket int
#endif

class  SocketBase :  public  Ref
{
    public :
        SocketBase();
        ~SocketBase();

    protected :
        void  closeConnect(HSocket socket);
        bool  error(HSocket socket);

    protected :
        std::mutex _mutex;

    private :
        bool  _bInitSuccess;
};

#endif

服务端

初始化服务端

向指定客户端发送消息

void  sendMessage(HSocket socket,  const  char * data,  int  count);

向所有客户端发送消息

void  sendMessage( const  char * data,  int  count);

当服务端开启后的回调函数

std::function< void ( const  char * ip)> onStart;

当有新连接时的回调函数

std::function< void (HSocket socket)> onNewConnection;

当有消息时的回调函数

std::function< void ( const  char * data,  int  count)> onRecv;

当有客户端断开连接时的回调函数

std::function< void (HSocket socket)> onDisconnect;

SocketServer.h

#ifndef __SOCKET_SERVER_H__
#define __SOCKET_SERVER_H__

#include "SocketBase.h"

class  SocketServer :  public  SocketBase
{
    public :
    static  SocketServer* create();

    SocketServer();
    ~SocketServer();

    bool  startServer();
    void  sendMessage(HSocket socket,  const  char * data,  int  count);
    void  sendMessage( const  char * data,  int  count);

    std::function< void ( const  char * ip)> onStart;
    std::function< void (HSocket socket)> onNewConnection;
    std::function< void ( const  char * data,  int  count)> onRecv;
    std::function< void (HSocket socket)> onDisconnect;

    private :
    bool  initServer();
    void  acceptClient();
    void  acceptFunc();
    void  newClientConnected(HSocket socket);
    void  recvMessage(HSocket socket);

    private :
    HSocket _socketServer;

    private :
    std::list _clientSockets;

};

#endif

SocketServer.cpp

#include "SocketServer.h"

SocketServer* SocketServer::create()
{
    auto server =  new  SocketServer;

    return  server;
}

SocketServer::SocketServer() :
    _socketServer(0),
    onRecv(nullptr),
    onStart(nullptr),
    onNewConnection(nullptr)
{

}

SocketServer::~SocketServer()
{
    _clientSockets.clear();

    if  (_socketServer)
    {
        this ->closeConnect(_socketServer);
    }
};

bool  SocketServer::startServer()
{
    if  (!initServer())
    {
        return  false ;
    }

    return  true ;
}

bool  SocketServer::initServer()
{
    if  (_socketServer != 0)
    {
        this ->closeConnect(_socketServer);
    }
    _socketServer = socket(AF_INET, SOCK_STREAM, 0);
    if  (error(_socketServer))
    {
        log ( "socket error!" );
        _socketServer = 0;
        return  false ;
    }
    do
    {
        struct  sockaddr_in sockAddr;
        memset (&sockAddr, 0,  sizeof (sockAddr));

        sockAddr.sin_family = AF_INET;
        sockAddr.sin_port = htons(8000);
        sockAddr.sin_addr.s_addr = htonl(INADDR_ANY);
        int  ret = 0;
        ret = bind(_socketServer, ( const  sockaddr*)&sockAddr,  sizeof (sockAddr));
        if  (ret < 0)
        {
            log ( "bind error!" );
            break ;
        }

        ret = listen(_socketServer, 5);
        if  (ret < 0)
        {
            log ( "listen error!" );
            break ;
        }
        // start
        char  hostName[256];
        gethostname(hostName,  sizeof (hostName));
        struct  hostent* hostInfo = gethostbyname(hostName);
        char * ip = inet_ntoa(*( struct  in_addr *)*hostInfo->h_addr_list);
        this ->acceptClient();

        if  (onStart != nullptr)
        {
            log ( "start server!" );
            onStart(ip);
        }

        return  true ;

    }  while  ( false );

    this ->closeConnect(_socketServer);
    _socketServer = 0;
    return  false ;
}

void  SocketServer::acceptClient()
{
    std:: thread  th(&SocketServer::acceptFunc,  this );
    th.detach();
}

void  SocketServer::acceptFunc()
{
    int  len =  sizeof (sockaddr);
    struct  sockaddr_in sockAddr;
    while  ( true )
    {
        HSocket clientSock = accept(_socketServer, (sockaddr*)&sockAddr, &len);
        if  (error(clientSock))
        {
            log ( "accept error!" );
            break ;
        }

        this ->newClientConnected(clientSock);
    }
}

void  SocketServer::newClientConnected(HSocket socket)
{
    log ( "new connect!" );

    _clientSockets.push_back(socket);
    std:: thread  th(&SocketServer::recvMessage,  this , socket);
    th.detach();

    if  (onNewConnection != nullptr)
    {
        onNewConnection(socket);
    }
}

void  SocketServer::recvMessage(HSocket socket)
{
    char  buff[1024];
    int  ret = 0;

    while  ( true )
    {
        ret = recv(socket, buff,  sizeof (buff), 0);
        if  (ret < 0)
        {
            log ( "recv(%d) error!" , socket);
            _mutex.lock();
            this ->closeConnect(socket);
            _clientSockets. remove (socket);
            if  (onDisconnect != nullptr)
            {
                onDisconnect(socket);
            }
            _mutex.unlock();

            break ;
        }
        else
        {
            buff[ret] = 0;
            log ( "recv msg : %s" , buff);
            if  (ret > 0 && onRecv != nullptr)
            {
                onRecv(buff, ret);
            }
        }
    }
}

void  SocketServer::sendMessage(HSocket socket,  const  char * data,  int  count)
{
    for  (auto& sock : _clientSockets)
    {
        if  (sock == socket)
        {
            int  ret = send(socket, data, count, 0);
            if  (ret < 0)
            {
                log ( "send error!" );
            }
            break ;
        }
    }

}

void  SocketServer::sendMessage( const  char * data,  int  count)
{
    for  (auto& socket : _clientSockets)
    {
        int  ret = send(socket, data, count, 0);
        if  (ret < 0)
        {
            log ( "send error!" );
        }

    }

}

客户端

连接服务端

bool  connectServer( const  char * serverIP, unsigned  short  port);

向服务端发送消息

void  sendMessage( const  char * data,  int  count);

接受服务端数据的回调函数

std::function< void ( const  char * data,  int  count)> onRecv;

断开连接的回调函数

std::function< void ()> onDisconnect;

SocketClient.h

#ifndef __SOCKET_CLIENT_H__
#define __SOCKET_CLIENT_H__
#include "SocketBase.h"

class  SocketClient :  public  SocketBase
{
    public :
    SocketClient( void );
    ~SocketClient( void );

    bool  connectServer( const  char * serverIP, unsigned  short  port);
    void  sendMessage( const  char * data,  int  count);

    std::function< void ( const  char * data,  int  count)> onRecv;
    std::function< void ()> onDisconnect;

    private :
    bool  initClient();
    void  recvMessage();

    private :
    HSocket _socketServer;
    HSocket _socektClient;
};

#endif

SocketClient.cpp