source: chevmsgr/trunk/msgclnt.cpp@ 5

#include "msgclnt.h"
#include "msg.hpp"

#include <stdlib.h>

// --------------------------------------------------------------

typedef struct SWorkerArg
{
    cf::network::tcp * socket;
    SCallback * callback;
} SWorkerArg;

int worker(void * arg)
{
    SWorkerArg * inst = (SWorkerArg *) arg;

    bool isError = false;
    Message::Parser parser;
    cf::bin raw;

    while (true)
    {
        try
        {
            raw = inst->socket->receive();
            parser.parse(raw.toString());

            isError = false;
        }
        catch (cf::exception & e)
        {
            LOG(e.stackTrace());

            // closed
            if (raw.size() == 0)
                break;

            isError = true;
        }

        if (parser.type() == "result")
        {
            SResultResponse recv;

            recv.result  = parser.get<bool>("result");
            recv.isError = isError;

            inst->callback->result(recv);
        }
        else if (parser.type() == "chat")
        {
            SReceivedMessage recv;

            recv.sessid  = parser.get<std::string>("sess-id");
            recv.sender  = parser.get<std::string>("from");
            recv.message = parser.get<std::string>("message");
            recv.isError = isError;

            inst->callback->message(recv);
        }
    }

    free(arg);

    return 0;
}

// --------------------------------------------------------------

chev::chev()
    : listener(worker)
{
}

bool chev::connect(const std::string & host, const unsigned short port)
{
    try
    {
        socket.connect(host, port);

        return true;
    }
    catch (cf::exception & e)
    {
        LOG(e.what());

        return false;
    }
}

bool chev::join(const std::string & id, const std::string & pw, const std::string & sms)
{
    try
    {
        socket.send(request.join(id, pw, sms));

        std::string response = socket.receive().toString();
        Message::Parser parser;
        parser.parse(response);

        return parser.get<bool>("result");
    }
    catch (cf::exception & e)
    {
        LOG(e.what());

        return false;
    }
}

bool chev::login(const std::string & id, const std::string & pw)
{
    try
    {
        request.setUserID(id);

        socket.send(request.login(pw));

        std::string response = socket.receive().toString();
        Message::Parser parser;
        parser.parse(response);

        return parser.get<bool>("result");
    }
    catch (cf::exception & e)
    {
        LOG(e.what());

        return false;
    }
}

bool chev::sms(const std::string & phone)
{
    try
    {
        socket.send(request.sms(phone));

        std::string response = socket.receive().toString();
        Message::Parser parser;
        parser.parse(response);

        return parser.get<bool>("result");
    }
    catch (cf::exception & e)
    {
        LOG(e.what());

        return false;
    }
}

bool chev::runReceiver(const SCallback & cb)
{
    if (listener.isRunning())
        return true;

    callback = cb;

    SWorkerArg * arg = (SWorkerArg *)malloc(sizeof(SWorkerArg));
    if (!arg)
        return false;

    arg->socket = &socket;
    arg->callback = &callback;

    listener.start(arg);

    return true;
}

bool chev::sendMessage(const std::string & friendid, const std::string & sessid, const std::string & message)
{
    try
    {
        socket.send(request.chat(friendid, sessid, message));

        std::string response = socket.receive().toString();
        Message::Parser parser;
        parser.parse(response);

        return parser.get<bool>("result");
    }
    catch (cf::exception & e)
    {
        LOG(e.what());

        return false;
    }
}