source: chevmsgr/trunk/msgclnt.cpp@ 10

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

#include <algorithm>

#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)
{
    mutex.lock();
    messageQ.push_back(parser);
    mutex.unlock();
}

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()
{
    std::vector<SFriend> friendList;

    try
    {
        socket.send(request.getFriendList());

        friendList = messageQ.pop(ProtocolType::FRIEND_LIST).getFriendList();
    }
    catch (cf::exception & e)
    {
        LOG(e.what());
    }

    return friendList;
}

std::string chev::getSessionID(std::vector<std::string> & idList)
{
    try
    {
        if (idList.size() == 2)
            std::sort(idList.begin(), idList.end());

        std::string concat = idList[0];

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

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

            Protocol::Message message = messageQ.pop(ProtocolType::SESSION_ID);

            if (!message.get<bool>(ProtocolType::RESULT))
                THROW_EXCEPTION("failed to open session id");

            sessionMap[concat] = message.get<std::string>(ProtocolType::SESSION_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 message = messageQ.pop(ProtocolType::CHAT);

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

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

    return c;
}