source: chevmsgr/trunk/msgclnt.cpp@ 6

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

#include <stdlib.h>

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

typedef struct SWorkerArg
{
    cf::network::tcp * socket;
    MessageQ * messageQ;
} SWorkerArg;

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

    Protocol::Message parser;
    cf::bin raw;

    while (true)
    {
        try
        {
            raw = inst->socket->receive();
            parser.parse(raw.toString());
        }
        catch (cf::exception & e)
        {
            LOG(e.stackTrace());

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

        inst->messageQ->push(parser);
    }

    free(inst);

    return 0;
}

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

void MessageQ::push(const Protocol::Message & parser)
{
    SYNCHRONIZED(mutex)
    {
        messageQ.push_back(parser);
    }
}

Protocol::Message MessageQ::pop(const std::string & requestType)
{
    while (true)
    {
        SYNCHRONIZED(mutex)
        {
            Protocol::Message parser = messageQ.front();

            if (parser.type() == requestType)
            {
                messageQ.erase(messageQ.begin());

                return parser;
            }
        }
    }
}

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

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

chev::~chev()
{
    socket.close();
}

const std::string & chev::getLastError() const
{
    return error;
}

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

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

        arg->socket = &socket;
        arg->messageQ = &messageQ;

        listener.start(arg);

        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));

        return messageQ.pop(ProtocolType::JOIN).get<bool>(ProtocolType::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));

        return messageQ.pop(ProtocolType::LOGIN).get<bool>(ProtocolType::RESULT);
    }
    catch (cf::exception & e)
    {
        LOG(e.what());

        return false;
    }
}

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

        return messageQ.pop(ProtocolType::SMS).get<bool>(ProtocolType::RESULT);
    }
    catch (cf::exception & e)
    {
        LOG(e.what());

        return false;
    }
}

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

        return messageQ.pop(ProtocolType::ADD_FRIEND).get<bool>(ProtocolType::RESULT);
    }
    catch (cf::exception & e)
    {
        LOG(e.what());

        return false;
    }
}

std::vector<SFriend> chev::getFriendList()
{
    try
    {
        socket.send(request.getFriendList());
    }
    catch (cf::exception & e)
    {
        LOG(e.what());
    }
    return std::vector<SFriend>();
}

std::string chev::getSessionID(const std::vector<std::string> & idList)
{
    try
    {
        std::string concat = idList[0];

        for (int iter = 1 ; iter < idList.size() ; iter++)
            concat += "," + idList[iter];

        if (sessionMap.find(concat) == sessionMap.end())
        {
            socket.send(request.openSession(concat));

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

            if (!parser.get<bool>("result"))
                THROW_EXCEPTION("failed to open session id");

            sessionMap[concat] = parser.get<std::string>("sess-id");
        }

        return sessionMap[concat];
    }
    catch (cf::exception & e)
    {
        LOG(e.what());

        return "";
    }
}

bool chev::tell(const SConversation & conversation)
{
    try
    {
        const SConversation & c = conversation;

        socket.send(request.chat(c.sessid, c.message, c.sensitive));

        return messageQ.pop(ProtocolType::CHAT).get<bool>(ProtocolType::RESULT);
    }
    catch (cf::exception & e)
    {
        LOG(e.what());

        return false;
    }
}

SConversation chev::listen()
{
    SConversation c;
    Protocol::Message parser = messageQ.pop(ProtocolType::CHAT);

    c.sessid    = parser.get<std::string>(ProtocolType::SESSION_ID);
    c.message   = parser.get<std::string>(ProtocolType::MESSAGE);
    c.sensitive = parser.get<int>(ProtocolType::SENSITIVE);
    c.isError   = parser.get<bool>(ProtocolType::RESULT);

    c.from      = parser.get<std::string>(ProtocolType::FROM);

    return c;
}