/*

* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

*

* This program is free software: you can redistribute it and/or modify

* it under the terms of the GNU Lesser General Public License as published by

* the Free Software Foundation, version 2.1 of the License.

* 

* This program is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

* GNU Lesser General Public License for more details.

*

* You should have received a copy of the GNU Lesser General Public License

* along with this program.  If not, 

* see "http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html/".

*

* Description:                                                         

*

*/   

#include "xqservicelog.h"

#include "xqservicechannel.h"

#include "xqservicethreaddata.h"

#include "xqserviceipcclient.h"

#include <xqserviceutil.h>

#include <xqsharablefile.h>

/*!

    \class XQServiceChannel

    \inpublicgroup QtBaseModule

    \ingroup qws

    \brief The XQServiceChannel class provides communication capabilities

    between clients.

    XQSERVICE is a many-to-many communication protocol for transferring

    messages on various channels. A channel is identified by a name,

    and anyone who wants to can listen to it. The XQSERVICE protocol allows

    clients to communicate both within the same address space and

    between different processes, but it is currently only available

    for \l {Qt for Embedded Linux} (on X11 and Windows we are exploring the use

    of existing standards such as DCOP and COM).

    Typically, XQServiceChannel is either used to send messages to a

    channel using the provided static functions, or to listen to the

    traffic on a channel by deriving from the class to take advantage

    of the provided functionality for receiving messages.

    XQServiceChannel provides a couple of static functions which are usable

    without an object: The send() function, which sends the given

    message and data on the specified channel, and the isRegistered()

    function which queries the server for the existence of the given

    channel.

    In addition, the XQServiceChannel class provides the channel() function

    which returns the name of the object's channel, the virtual

    receive() function which allows subclasses to process data

    received from their channel, and the received() signal which is

    emitted with the given message and data when a XQServiceChannel

    subclass receives a message from its channel.

    \sa XQServiceServer, {Running Qt for Embedded Linux Applications}

*/

/*!

    Constructs a XQService channel with the given \a parent, and registers it

    with the server using the given \a channel name.

    \sa isRegistered(), channel()

*/

XQServiceChannel::XQServiceChannel(const QString& channel, bool isServer, QObject *parent)

    : QObject(parent)

{

    XQSERVICE_DEBUG_PRINT("XQServiceChannel::XQServiceChannel");

    XQSERVICE_DEBUG_PRINT("channel: %s, isServer: %d", qPrintable(channel), isServer );

    d = new XQServiceChannelPrivate(this, channel, isServer);

    d->ref.ref();

    XQServiceThreadData *td = XQService::serviceThreadData();

    // do we need a new channel list ?

    XQServiceClientMap::Iterator it = td->clientMap.find(channel);

    if (it != td->clientMap.end()) {

        XQSERVICE_DEBUG_PRINT("Channel exits");

        it.value().append(XQServiceChannelPrivatePointer(d));

        return;

    }

    XQSERVICE_DEBUG_PRINT("New channel");

    it = td->clientMap.insert(channel, QList<XQServiceChannelPrivatePointer>());

    it.value().append(XQServiceChannelPrivatePointer(d));

}

/*!

    Destroys the client's end of the channel and notifies the server

    that the client has closed its connection. The server will keep

    the channel open until the last registered client detaches.

    \sa XQServiceChannel()

*/

XQServiceChannel::~XQServiceChannel()

{

    XQSERVICE_DEBUG_PRINT("XQServiceChannel::~XQServiceChannel");

    XQServiceThreadData *td = XQService::serviceThreadData();

    XQServiceClientMap::Iterator it = td->clientMap.find(d->channel);

    Q_ASSERT(it != td->clientMap.end());

    it.value().removeAll(XQServiceChannelPrivatePointer(d));

    // still any clients connected locally ?

    if (it.value().isEmpty()) {

        if (td->hasClientConnection(d->channel))

            td->closeClientConnection(d->channel);

        td->clientMap.remove(d->channel);

    }

    // Dereference the private data structure.  It may stay around

    // for a little while longer if it is in use by sendLocally().

    d->object = 0;

    if (!d->ref.deref())

        delete d;

}

bool XQServiceChannel::connectChannel()

{

    XQSERVICE_DEBUG_PRINT("XQServiceChannel::connectChannel");

    bool ret = true;

    XQServiceThreadData *td = XQService::serviceThreadData();

    if (!td->hasClientConnection(d->channel)) {

        XQSERVICE_DEBUG_PRINT("Create new client connection (1)");

        ret = td->createClientConnection(d->channel,d->server);

    }

    return ret;

}

/*!

    Returns the name of the channel.

    \sa XQServiceChannel()

*/

QString XQServiceChannel::channel() const

{

    XQSERVICE_DEBUG_PRINT("XQServiceChannel::channel");

    XQSERVICE_DEBUG_PRINT("channel: %s", qPrintable(d->channel));

    return d->channel;

}

/*!

    \fn void XQServiceChannel::receive(const QString& message, const QByteArray &data)

    This virtual function allows subclasses of XQServiceChannel to process

    the given \a message and \a data received from their channel. The default

    implementation emits the received() signal.

    Note that the format of the given \a data has to be well defined

    in order to extract the information it contains. In addition, it

    is recommended to use the DCOP convention. This is not a

    requirement, but you must ensure that the sender and receiver

    agree on the argument types.

    Example:

    \code

        void MyClass::receive(const QString &message, const QByteArray &data)

        {

            QDataStream in(data);

            if (message == "execute(QString,QString)") {

                QString cmd;

                QString arg;

                in >> cmd >> arg;

                ...

            } else if (message == "delete(QString)") {

                QString fileName;

                in >> fileName;

                ...

            } else {

                ...

            }

        }

    \endcode

    This example assumes that the \c message is a DCOP-style function

    signature and the \c data contains the function's arguments.

    \sa send()

 */

QVariant XQServiceChannel::receive(const QString& msg, const QByteArray &data, const XQSharableFile &sf )

{

    XQSERVICE_DEBUG_PRINT("XQServiceChannel::receive");

    XQSERVICE_DEBUG_PRINT("msg: %s, data: %s", qPrintable(msg), data.constData());

    emit received(msg, data,sf);

    return QVariant();

}

void XQServiceChannel::commandReceive(const XQServiceCommand cmd)

{

    XQSERVICE_DEBUG_PRINT("XQServiceChannel::commandReceive %d", cmd);

    emit commandReceived(cmd);

}

/*!

    \fn void XQServiceChannel::received(const QString& message, const QByteArray &data)

    This signal is emitted with the given \a message and \a data whenever the

    receive() function gets incoming data.

    \sa receive()

*/

/*!

    \fn bool XQServiceChannel::send(const QString& channel, const QString& message,

                       const QByteArray &data)

    Sends the given \a message on the specified \a channel with the

    given \a data.  The message will be distributed to all clients

    subscribed to the channel. Returns true if the message is sent

    successfully; otherwise returns false.

    It is recommended to use the DCOP convention. This is not a

    requirement, but you must ensure that the sender and receiver

    agree on the argument types.

    Note that QDataStream provides a convenient way to fill the byte

    array with auxiliary data.

    Example:

    \code

        QByteArray data;

        QDataStream out(&data, QIODevice::WriteOnly);

        out << QString("cat") << QString("file.txt");

        XQServiceChannel::send("System/Shell", "execute(QString,QString)", data);

    \endcode

    Here the channel is \c "System/Shell". The \c message is an

    arbitrary string, but in the example we've used the DCOP

    convention of passing a function signature. Such a signature is

    formatted as \c "functionname(types)" where \c types is a list of

    zero or more comma-separated type names, with no whitespace, no

    consts and no pointer or reference marks, i.e. no "*" or "&".

    \sa receive()

*/

bool XQServiceChannel::send(const QString& channel, const QString& msg,

                            const QByteArray &data, QVariant &retValue,

                            bool sync, XQServiceRequestCompletedAsync* rc)

{

    XQSERVICE_DEBUG_PRINT("XQServiceChannel::send(1). No user data");

    // Delegate to actual send.

    // No user data argument present in this version

    return send(channel,msg,data,retValue,sync,rc,NULL);

}

bool XQServiceChannel::send(const QString& channel, const QString& msg,

                       const QByteArray &data, QVariant &retValue,

                       bool sync, XQServiceRequestCompletedAsync* rc,

                       const void* userData)

{

    XQSERVICE_DEBUG_PRINT("XQServiceChannel::send(2) start");

    XQSERVICE_DEBUG_PRINT("\t channel: %s, msg: %s", qPrintable(channel), qPrintable(msg));

    XQSERVICE_DEBUG_PRINT("\t data: %s, sync: %d", data.constData(), sync);

    bool ret=true;

    if (!XQService::serviceThreadData()->hasClientConnection(channel)) {

        XQSERVICE_DEBUG_PRINT("\t Create new client connection (2)");

        ret = XQService::serviceThreadData()->createClientConnection(channel,false,sync,rc, userData);

        XQSERVICE_DEBUG_PRINT("\t creation succeeded: %d", ret);

    }

    if (ret) {

        XQSERVICE_DEBUG_PRINT("\t ret = true");

        XQServiceIpcClient *cl = XQService::serviceThreadData()->clientConnection(channel);

        QByteArray retData ;

        ret = cl ? cl->send(channel, msg, data, retData) : false;

        if (sync) {

            retValue = XQServiceThreadData::deserializeRetData(retData);

        }

    }

    XQSERVICE_DEBUG_PRINT("\t ret: %d", ret);

	XQSERVICE_DEBUG_PRINT("XQServiceChannel::send(2) end");

    return ret;

}

bool XQServiceChannel::cancelPendingSend(const QString& channel)

{

    XQSERVICE_DEBUG_PRINT("XQServiceChannel::cancelPendingSend start");

    XQSERVICE_DEBUG_PRINT("\t channel: %s", qPrintable(channel));

    bool ret=true;

    if (ret) {

        XQServiceIpcClient *cl = XQService::serviceThreadData()->clientConnection(channel);

        XQSERVICE_DEBUG_PRINT("\t XQService::serviceThreadData()->clientConnection(channel): %d", cl);

        XQSERVICE_DEBUG_PRINT("\t cl->cancelPendingSend(%s)", qPrintable(channel));

        ret = cl ? cl->cancelPendingSend(channel) : false;

    }

    XQSERVICE_DEBUG_PRINT("\t ret: %d", ret);

	XQSERVICE_DEBUG_PRINT("XQServiceChannel::cancelPendingSend end");

    return ret;

}

/*!

    \internal

    Client side: distribute received event to the XQService instance managing the

    channel.

*/

QVariant XQServiceChannel::sendLocally(const QString& ch, const QString& msg,

                                const QByteArray &data, const XQSharableFile &sf )

{

    XQSERVICE_DEBUG_PRINT("XQServiceChannel::sendLocally");

    XQSERVICE_DEBUG_PRINT("channel: %s, msg: %s", qPrintable(ch), qPrintable(msg));

    XQSERVICE_DEBUG_PRINT("data: %s", data.constData());

    QVariant ret;

    // feed local clients with received data

    XQServiceThreadData *td = XQService::serviceThreadData();

    QList<XQServiceChannelPrivatePointer> clients = td->clientMap[ch];

    for (int i = 0; i < clients.size(); ++i) {

        XQServiceChannelPrivate *channel = clients.at(i).data();

        if (channel->object)

            ret = channel->object->receive(msg, data,sf );

    }

    XQSERVICE_DEBUG_PRINT("ret: %s", qPrintable(ret.toString()));

    return ret ;

}

int XQServiceChannel::latestError()

{

    XQSERVICE_DEBUG_PRINT("XQServiceChannel::latestError");

    return XQService::serviceThreadData()->latestError();

}

void XQServiceChannel::sendCommand(const QString& ch,const XQServiceCommand cmd)

{

    XQSERVICE_DEBUG_PRINT("XQServiceChannel::sendCommand");

    XQSERVICE_DEBUG_PRINT("channel: %s, cmd: %d", qPrintable(ch), cmd);

    // feed local clients with received data

    XQServiceThreadData *td = XQService::serviceThreadData();

    QList<XQServiceChannelPrivatePointer> clients = td->clientMap[ch];

    for (int i = 0; i < clients.size(); ++i) {

        XQServiceChannelPrivate *channel = clients.at(i).data();

        if (channel->object)

            channel->object->commandReceive(cmd);

    }

}