wxwidgets应用手记（5） TCP/IP操作

贴两个主要的类：

winsockclient.h

#ifndef WINSOCKCLIENT_H
#define WINSOCKCLIENT_H

#include <wx/event.h>
#include <wx/socket.h>

namespace ty
{
    class IWinsockClient
    {
    public:
        virtual void Connected(wxObject*) = 0;
        virtual void Disconnected(wxObject* ,bool server_closed/* 断开的原因，服务器关闭=true */) = 0;
        virtual void Received(wxObject* ,char*,int) = 0;
    };

    class CWinsockClient:wxEvtHandler
    {
    public:
        void Connect(wxString ip,long port);
        void Disconnect();
        void Send(const void* buf,int len);
        bool IsConnected();

    private:
        void OnSocketEvent(wxSocketEvent& event);

    public:
        CWinsockClient(IWinsockClient* owner);
        virtual ~CWinsockClient(void);

    private:
        wxString m_ip;
        unsigned short m_port;
        wxSocketBase* m_sock;
        IWinsockClient* m_owner;

    private:
        static const long ID_WinsockClient;
    };
};

#endif // WINSOCKCLIENT_H

winsockserver.h

#ifndef WINSOCKSERVER_H
#define WINSOCKSERVER_H

#include <wx/event.h>
#include <wx/socket.h>
#include <wx/dynarray.h>

namespace ty
{
    class IWinsockServer
    {
    public:
        virtual void Connected(wxObject*,wxSocketBase*) = 0;
        virtual void Disconnected(wxObject*,wxSocketBase*) = 0;
        virtual void Received(wxObject*,wxSocketBase*,char*,int) = 0;
    };

    class CWinsockServer:wxEvtHandler
    {
    public:
        CWinsockServer(IWinsockServer* owner);
        virtual ~CWinsockServer();

    public:
        void Start(long port);
        void Stop();
        bool IsListenning();
        int GetClientCount();
        wxSocketBase* GetClientItem(int index);
        wxString GetClientAddressInfo(int index);

    private:
        void OnServerEvent(wxSocketEvent& event);
        void OnSocketEvent(wxSocketEvent& event);

    private:
        unsigned short m_port;
        wxSocketServer* m_server;
        wxArrayPtrVoid m_clientList;
        IWinsockServer* m_owner;

    private:
        static const long ID_WinsockServer;
        static const long ID_WinsockClient;

    };
};

#endif // WINSOCKSERVER_H

winsockclient.cpp

#include "winsockclient.h"
using namespace ty;

const long CWinsockClient::ID_WinsockClient = wxNewId();

CWinsockClient::CWinsockClient(IWinsockClient* owner)
{
    wxASSERT(owner != NULL);

    m_sock = NULL;
    m_owner = owner;

    wxEvtHandler::Connect(ID_WinsockClient,wxEVT_SOCKET,(wxObjectEventFunction)&CWinsockClient::OnSocketEvent);
}

CWinsockClient::~CWinsockClient(void)
{
    Disconnect();
    wxEvtHandler::Disconnect(ID_WinsockClient,wxEVT_SOCKET,(wxObjectEventFunction)&CWinsockClient::OnSocketEvent);
}

void CWinsockClient::OnSocketEvent(wxSocketEvent& event)
{
    wxSocketBase* sock = event.GetSocket();
    switch(event.GetSocketEvent())
    {
    case wxSOCKET_CONNECTION:
    {
        m_sock = sock;
        m_owner->Connected(this);

        break;
    }

    case wxSOCKET_INPUT:
    {
        char buf[4096];
        sock->Read(buf,sizeof(buf));
        m_owner->Received(this,buf,sock->LastCount());

        break;
    }

    case wxSOCKET_LOST:
    {
        m_owner->Disconnected(this,true);

        sock->Destroy();
        m_sock = NULL;

        break;
    }
    }
}

void CWinsockClient::Connect(wxString ip,long port)
{
    if(m_sock == NULL)
    {
        this->m_ip = ip;
        this->m_port = port;

        wxIPV4address addr;
        addr.Hostname(m_ip);
        addr.Service(m_port);

        wxSocketClient* sock = new wxSocketClient();
        sock->SetEventHandler(*this,ID_WinsockClient);
        sock->SetNotify(wxSOCKET_CONNECTION_FLAG |wxSOCKET_INPUT_FLAG |wxSOCKET_LOST_FLAG);
        sock->Notify(true);
        sock->Connect(addr,false);
    }
}

void CWinsockClient::Disconnect()
{
    if(m_sock != NULL)
    {
        m_owner->Disconnected(this,false);
        m_sock->Destroy();
        m_sock = NULL;
    }
}

void CWinsockClient::Send(const void* buf,int len)
{
    if(m_sock != NULL)
    {
        m_sock->Write(buf,len);
    }
}

bool CWinsockClient::IsConnected()
{
    return m_sock != NULL;
}

winsockserver.cpp

#include "winsockserver.h"
using namespace ty;

const long CWinsockServer::ID_WinsockServer =wxNewId();
const long CWinsockServer::ID_WinsockClient = wxNewId();


CWinsockServer::CWinsockServer(IWinsockServer* owner)
{
    wxASSERT(owner != NULL);

    //ctor
    this->m_owner = owner;
    wxEvtHandler::Connect(ID_WinsockServer,wxEVT_SOCKET,(wxObjectEventFunction)&CWinsockServer::OnServerEvent);
    wxEvtHandler::Connect(ID_WinsockClient,wxEVT_SOCKET,(wxObjectEventFunction)&CWinsockServer::OnSocketEvent);

    m_server = NULL;
    m_clientList.clear();
}

CWinsockServer::~CWinsockServer()
{
    //dtor
    wxEvtHandler::Disconnect(ID_WinsockServer,wxEVT_SOCKET,(wxObjectEventFunction)&CWinsockServer::OnServerEvent);
    wxEvtHandler::Disconnect(ID_WinsockClient,wxEVT_SOCKET,(wxObjectEventFunction)&CWinsockServer::OnSocketEvent);

    Stop();
    for(unsigned int i=0; i< m_clientList.Count(); i++)
    {
        ((wxSocketBase*)m_clientList[i])->Destroy();
    }
    m_clientList.clear();
}

void CWinsockServer::Start(long port)
{
    if(m_server == NULL)
    {
        m_port = port;

        wxIPV4address addr;
        addr.Service(m_port);

        m_server = new wxSocketServer(addr);
        m_server->SetEventHandler(*this,ID_WinsockServer);
        m_server->SetNotify(wxSOCKET_CONNECTION_FLAG);
        m_server->Notify(true);
    }
}

void CWinsockServer::Stop()
{
    if(m_server != NULL)
    {
        m_server->Close();
        delete m_server;
        m_server = NULL;
    }
}

bool CWinsockServer::IsListenning()
{
    return m_server != NULL;
}

void CWinsockServer::OnServerEvent(wxSocketEvent& event)
{
    wxSocketBase* sock = m_server->Accept(false);

    sock->SetEventHandler(*this,ID_WinsockClient);
    sock->SetNotify(wxSOCKET_INPUT_FLAG|wxSOCKET_LOST_FLAG);
    sock->Notify(true);

    m_clientList.Add(sock);
    m_owner->Connected(this,sock);
}

void CWinsockServer::OnSocketEvent(wxSocketEvent& event)
{
    wxSocketBase* sock = event.GetSocket();
    switch(event.GetSocketEvent())
    {
    case wxSOCKET_INPUT:
    {
        char buf[4096];
        sock->Read(buf,sizeof(buf));
        m_owner->Received(this,sock,buf,sock->LastCount());

        break;
    }

    case wxSOCKET_LOST:
    {
        m_owner->Disconnected(this,sock);
        m_clientList.Remove(sock);
        sock->Destroy();

        break;
    }
    }
}

int CWinsockServer::GetClientCount()
{
    return m_clientList.Count();
}

wxSocketBase* CWinsockServer::GetClientItem(int index)
{
    return (wxSocketBase*)m_clientList[index];
}

wxString CWinsockServer::GetClientAddressInfo(int index)
{
    wxIPV4address addr;
    GetClientItem(index)->GetLocal(addr);
    return wxString::Format(_T("%s:%d"),addr.IPAddress().c_str(),addr.Service());
}

客户端主窗口实现接口 IWinsockClient

class IWinsockClient
{
public:
    virtual void Connected(wxObject*) = 0;
    virtual void Disconnected(wxObject* ,bool server_closed/* 断开的原因，服务器关闭=true */) = 0;
    virtual void Received(wxObject* ,char*,int) = 0;
};

服务器主窗口实现接口 IWinsockServer

class IWinsockServer
{
public:
    virtual void Connected(wxObject*,wxSocketBase*) = 0;
    virtual void Disconnected(wxObject*,wxSocketBase*) = 0;
    virtual void Received(wxObject*,wxSocketBase*,char*,int) = 0;
};