source: chevmsgr/trunk/msgclnt.cpp@ 12

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

#include <algorithm>

#include <stdlib.h>

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

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

typedef struct SCallbackWorkerArg
{
    MessageQ * messageQ;
    SCallback callback;
} SCallbackWorkerArg;

static int messageQworekr(void * arg)
{
    SMessageQWorkerArg * inst = (SMessageQWorkerArg *)arg;

    Protocol::Message message;
    cf::bin raw;

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

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

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

    free(inst);

    return 0;
}

static inline SConversation toCnversation(const Protocol::Message & message)
{
    SConversation c;

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

static inline SOpenSession toOpenSession(const Protocol::Message & message)
{
    SOpenSession o;

    o.sessid = message.get<std::string>(ProtocolType::SESSION_ID);
    o.idList = message.getList<std::string>(ProtocolType::ID_LIST);

    return o;
}

static int callbackWorker(void * arg)
{
    SCallbackWorkerArg * inst = (SCallbackWorkerArg *)arg;

    Protocol::Message message;

    while (true)
    {
        message = inst->messageQ->pop(ProtocolType::CHAT, false);
        if (message.type() != ProtocolType::NONE)
            inst->callback.onChat(toCnversation(message));

        message = inst->messageQ->pop(ProtocolType::OPEN_SESSION, false);
        if (message.type() != ProtocolType::NONE)
            inst->callback.onOpenSession(toOpenSession(message));
    }

    free(inst);

    return 0;
}

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

void MessageQ::push(const Protocol::Message & message)
{
    mutex.lock();
    messageQ.push_back(message);
    mutex.unlock();
}

Protocol::Message MessageQ::pop(const std::string & requestType, bool isWait)
{
    while (isWait)
    {
        SYNCHRONIZED(mutex)
        {
            Protocol::Message message = messageQ.front();

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

                return message;
            }
        }
    }

    return Protocol::Message(); // return dummy NONE
}

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

chev::chev()
    : listener(messageQworekr),
      caller(callbackWorker)
{
}

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

        SMessageQWorkerArg * arg = (SMessageQWorkerArg *)malloc(sizeof(SMessageQWorkerArg));
        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
    {
        idList.insert(idList.begin(), request.getUserID());

        if (idList.size() == 2)
            std::sort(idList.begin(), idList.end());

        std::string concat = joinStrings(idList);

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

bool chev::listen(const SCallback & callback)
{
    SCallbackWorkerArg * arg = (SCallbackWorkerArg *)malloc(sizeof(SCallbackWorkerArg));
    if (!arg)
        return false;

    arg->messageQ = &messageQ;
    arg->callback = callback;

    caller.start(arg);

    return true;
}