Simulator/DroneClientCpp/NetClient.cpp

#include "NetClient.h"

namespace DroneSimulator {

    // Конструктор ConnectData
    NetClient::ConnectData::ConnectData(bool connect, Socket^ server)
    {
        Connect = connect;
        Server = server;
    }

    // Конструктор ReceiveData
    NetClient::ReceiveData::ReceiveData(array<Byte>^ buffer, int size, Socket^ server)
    {
        Buffer = buffer;
        Size = size;
        Server = server;
    }

    // Конструктор NetClient
    NetClient::NetClient()
    {
        Connected = false;
        ServerSocket = nullptr;
        DataServer = gcnew ServerData(); // Инициализация DataServer
    }

    // Реализация метода Connect
    NetClient::ClientState NetClient::Connect(String^ Addr, int Port, ClientCallback^ Connection, ClientCallback^ Receive)
    {
        if (Connected)
        {
            Close();
            return ClientState::Stop;
        }

        ConnectionCallback = Connection;
        ReceiveCallback = Receive;

        IPEndPoint^ ep = gcnew IPEndPoint(IPAddress::Parse(Addr), Port);
        ServerSocket = gcnew Socket(AddressFamily::InterNetwork, SocketType::Stream, ProtocolType::Tcp);

        try { if (ServerSocket) ServerSocket->Connect(ep); }
        catch (...) { ServerSocket->Close(); return ClientState::Error; }

        Connected = true;

        ConnectionCallback(gcnew ConnectData(true, ServerSocket));

        ReceiveData^ receiveData = gcnew ReceiveData(DataServer->buffer, ServerData::size, ServerSocket);

        try { if (ServerSocket) ServerSocket->BeginReceive(DataServer->buffer, 0, ServerData::size, SocketFlags::None, gcnew AsyncCallback(this, &NetClient::ReadCallback), receiveData); }
        catch (...) {}

        return ClientState::Connected;
    }

    // Реализация метода Close
    void NetClient::Close()
    {
        try { if(ServerSocket) ServerSocket->Shutdown(SocketShutdown::Both); }
        catch (...) {}
        if(ServerSocket) ServerSocket->Close();
        Connected = false;
    }

    // Реализация метода Send
    void NetClient::Send(array<Byte>^ data)
    {
        if (ServerSocket != nullptr && Connected)
        {
            try { if (ServerSocket) ServerSocket->Send(data); }
            catch (...) {}
        }
    }

    // Реализация метода ReadCallback
    void NetClient::ReadCallback(IAsyncResult^ ar)
    {
        ReceiveData^ cd = (ReceiveData^)ar->AsyncState;
        if (cd == nullptr) return;

        int bytes = 0;
        try { bytes = ServerSocket->EndReceive(ar); }
        catch (...) {}

        if (bytes == 0)
        {
          if (ServerSocket) ServerSocket->Close();
            Connected = false;

            if (ServerSocket != nullptr)
            {
                ConnectionCallback(gcnew ConnectData(false, nullptr));
            }

            return;
        }

        ReceiveCallback(gcnew ReceiveData(cd->Buffer, bytes, ServerSocket));

        try { if (ServerSocket) ServerSocket->BeginReceive(cd->Buffer, 0, ServerData::size, SocketFlags::None, gcnew AsyncCallback(this, &NetClient::ReadCallback), cd); }
        catch (...) {}
    }
}