/*

* 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 "xqservicerequest.h"

#include "xqservicethreaddata.h"

#include "xqservicechannel.h"

#include "xqserviceadaptor.h"

#include "xqrequestutil.h"

#include <QStringList>

#include <xqservicemanager.h>

/*!

    \class XQServiceRequest_Private

    \inpublicgroup QtBaseModule

    \ingroup ipc

    \brief Private implementation of the XQServiceRequest.

*/

class XQServiceRequest_Private : public XQServiceRequestCompletedAsync

{

public:

    XQServiceRequest_Private(XQServiceRequest* parent)

        : mSynchronous(true), mParent(parent),mServiceManager(NULL)

    {    

        XQSERVICE_DEBUG_PRINT("XQServiceRequest_Private::XQServiceRequest_Private(1)");

    };

    XQServiceRequest_Private(const QString& fullServiceName, 

                             const QString& message, 

                             const bool &synchronous, 

                             XQServiceRequest* parent)

        : mService(fullServiceName), mMessage(message), mSynchronous(synchronous), mParent(parent),mServiceManager(NULL)

    {    

        XQSERVICE_DEBUG_PRINT("XQServiceRequest_Private::XQServiceRequest_Private(2)");

    };

    XQServiceRequest_Private(const XQAiwInterfaceDescriptor &descriptor, 

                             const QString& message, 

                             const bool &synchronous, 

                            XQServiceRequest* parent)

            : mMessage(message), mSynchronous(synchronous), mParent(parent),mServiceManager(NULL)

    {

        XQSERVICE_DEBUG_PRINT("XQServiceRequest_Private::XQServiceRequest_Private(3)");

        // Construct service name understood by the QtHighway FW

        // (The descriptor has been created from the  XML)

        mService = descriptor.serviceName() + "." + descriptor.interfaceName();

        XQSERVICE_DEBUG_PRINT("XQServiceRequest_Private(3)::service=%s", qPrintable(mService));

        // Remember the descriptor

        mRequestUtil.mDescriptor = descriptor; 

    };

    ~XQServiceRequest_Private();

    // from XQServiceRequestCompletedAsync

    void requestCompletedAsync(const QVariant &retValue);

    void requestErrorAsync(int err);

    QList<QVariant> mArguments;

    QString mService;

    QString mMessage;

    bool mSynchronous;

    XQServiceRequest* mParent;

    XQRequestUtil mRequestUtil;

    XQServiceManager* mServiceManager;

    QString mUniqueChannelName;

};

XQServiceRequest_Private::~XQServiceRequest_Private()

{

    XQSERVICE_DEBUG_PRINT("XQServiceRequest_Private::~XQServiceRequest_Private");

    delete mServiceManager;

};

void XQServiceRequest_Private::requestCompletedAsync(const QVariant &retValue)

{    

    XQSERVICE_DEBUG_PRINT("XQServiceRequest_Private::requestCompletedAsync");

    emit mParent->requestCompleted(retValue);

}

void XQServiceRequest_Private::requestErrorAsync(int err)

{    

    XQSERVICE_DEBUG_PRINT("XQServiceRequest_Private::requestErrorAsync");

    emit mParent->requestError(err);

}

/*!

    \class XQServiceRequest

    \inpublicgroup QtBaseModule

    \ingroup ipc

    \brief Allows applications to request services from other applications.

    The XQServiceRequest class allows applications to request services from other applications.

    A XQServiceRequest encapsulates a service name and the message to be sent to that service.

    \note One should be using XQApplicationManager and the related XQAiwRequest instead of XQServiceRequest.

          The XQApplicationManager and related classes encapsulate basic, target-architecture approved

          support for out-of-process Application Interworking, e.g. support for launching URLs

          (including activity URLs), normal files, sharable files, etc. (whatever needed).

    \b Examples: \n

    How to create synchronous request without parameters and return value? 

    \note The full name (yourservice.Interface) need to be used (with dot (.) between service name and interface name).

    \code

        XQServiceRequest request("yourservice.<b>Interface</b>", "functionName1()");

        bool res = request.send();

        if  (!res) {

            int error = request.latestError();

        }

    \endcode

    How to create synchronous request with several parameters and return value?

    \code

        QString parameter1("+3581234567890");

        int parameter2 = 3;

        XQServiceRequest request("yourservice.<b>Interface</b>", "functionName2(QString, int)");

        request << parameter1;

        request << parameter2;

        int returnvalue;

        bool res = request.send(returnvalue);

        if  (!res) {

            int error = request.latestError();

        }

    \endcode

    How to create asynchronous request without return value?

    \code

        QString parameter1("+3581234567890");

        int parameter2 = 3;

        XQServiceRequest request("yourservice.Interface", "functionName2(QString, int)", false);

        request << parameter1;

        request << parameter2;

        bool res = request.send();

        if (!res) {

            int error = request.latestError();

        }

    \endcode

    How to create asynchronous request with return value?

    \code

        QString parameter1("+3581234567890");

        int parameter2 = 3;

        XQServiceRequest request("yourservice.Interface", "functionName2(QString, int)", false);

        request << parameter1;

        request << parameter2;

        connect(request, SIGNAL(requestCompleted(QVariant)), this, SLOT(requestCompleted(QVariant)));

        bool res = request.send();

        if (!res) {

            int error = request.latestError();

        }

        ...

        void requestCompleted(const QVariant& value)

        {

            int returnvalue = value.toInt();

        }

    \endcode

    How to use declare custom type?

    Header:

    \code

        class CustomType 

        { 

        public: 

            CustomType (){}; 

            virtual ~CustomType(){};

            QString mString1; 

            QString mString2; 

            QUuid mUid;

            template <typename Stream> void serialize(Stream &stream) const; 

            template <typename Stream> void deserialize(Stream &stream); 

        };

        Q_DECLARE_USER_METATYPE(CustomType)

    \endcode

    Implementation:

    \code        

        template <typename Stream> void CustomType::serialize(Stream &s) const 

            { 

            s << mString1; 

            s << mString2; 

            s << mUid; 

            }

        template <typename Stream> void CustomType::deserialize(Stream &s) 

            { 

            s >> mString1; 

            s >> mString2; 

            s >> mUid; 

            }

        Q_IMPLEMENT_USER_METATYPE(CustomType)

    \endcode

    How to declare custom type that doesn't need data stream operators?

    Header:

    \code

        typedef QList<CustomType> CustomTypeList;

        Q_DECLARE_USER_METATYPE_NO_OPERATORS(CustomTypeList)

    \endcode

    Implementation:

    \code

        Q_IMPLEMENT_USER_METATYPE_NO_OPERATORS(CustomTypeList)

    \endcode

*/

/*!

    \fn bool XQServiceRequest::send(T& retValue)

    Sends the request. If the request is synchronous, then client is blocked

    until service provider completes the request or request fails for some reason.

    If the request is asynchronous, then client won't be blocked.

    \param retValue Defines refence to a value service provider will return after service.

    \return False if there was no application that could service the request, otherwise true.

*/

/*!

    \fn XQServiceRequest &XQServiceRequest::operator<< (const T &var)

    Adds \a var to the list of arguments for this service request.

    \param var Defines the argument value to add to the list of arguments.

*/

/*!

    \fn XQServiceRequest &XQServiceRequest::operator<< (const char *var)

    Adds \a var to the list of arguments for this service request.

    \param var Defines the argument value to add to the list of arguments.

*/

/*!

    \fn void XQServiceRequest::requestCompleted(const QVariant& value)

    This signal is emitted when service provider returns a return value asynchronously back to the client.

    \param value Result of the request.

*/

/*!

    \fn void XQServiceRequest::requestError(int err);

    This signal is emitted when error has happened in request handling.

    \param err Error code as integer value.

    \sa XQService::ServiceIPCErrors

*/

/*!

    \fn void XQServiceRequest::addVariantArg(const QVariant& var)

    Adds the variant value to the list of arguments, so that the variant's

    value is serialized in send() rather than the variant itself.

    \param var Value to be added to the list of arguments.

*/

/*!

    Construct a null service request.

    setService() and setMessage() must be called before send(), but the

    service may be written prior to the calls.

 */

XQServiceRequest::XQServiceRequest()

{

    XQSERVICE_DEBUG_PRINT("XQServiceRequest::XQServiceRequest(1)");

    mData = new XQServiceRequest_Private(this);

}

/*!

    Construct a service request that will send \a message to

    a \a service when send() is called. The service may be written

    prior to the calls.

    \param service Defines the full service name to send message. The full name is:

                   - The name of the service in the service configuration file

                   - Character *.* (dot)

                   - The name of the interface from the service XML.

    \param message Defines the message to send to the service provider i.e. it is

                 the signature of the service provider function to be called.

    \param synchronous Defines should message be sent synchronously or asynchronously.

                     By default message is sent synchronously.

*/

XQServiceRequest::XQServiceRequest(const QString& service, const QString& message, const bool &synchronous)

{

    XQSERVICE_DEBUG_PRINT("XQServiceRequest::XQServiceRequest(2)");

    XQSERVICE_DEBUG_PRINT("service: %s, message: %s, synchronous: %d", qPrintable(service), qPrintable(message), synchronous);

    mData = new XQServiceRequest_Private(service,message,synchronous,this);

}

/*!

    Copy constructor. Any data previously written to the \a orig

    service will be in the copy.

    \param orig XQServiceRequest from which data will be copied to this object.

*/

XQServiceRequest::XQServiceRequest(const XQServiceRequest& orig)

{

    XQSERVICE_DEBUG_PRINT("XQServiceRequest::XQServiceRequest(3)");

    mData = new XQServiceRequest_Private(orig.mData->mService,orig.mData->mMessage,orig.mData->mSynchronous,this);

    mData->mArguments = orig.mData->mArguments;

}

/*!

    Construct a service request by service descriptor which contains exact details of the service and interface.

    The service may be written prior to the calls.

    \param descriptor Defines details of the service and it's interface.

    \param message Message to be sent when send() is called.

    \param synchronous Defines should message be sent synchronously or asynchronously.

                       By default message is sent synchronously.

*/

XQServiceRequest::XQServiceRequest(const XQAiwInterfaceDescriptor &descriptor, const QString& message, const bool &synchronous)

{

    XQSERVICE_DEBUG_PRINT("XQServiceRequest::XQServiceRequest(2)");

    XQSERVICE_DEBUG_PRINT("service: %s, interface %s, message: %s, synchronous: %d",

                          qPrintable(descriptor.serviceName()), qPrintable(descriptor.interfaceName()),

                          qPrintable(message), synchronous);

    mData = new XQServiceRequest_Private(descriptor,message,synchronous,this);

}

/*!

    Assignment operator.

    Any data previously written to the \a orig

    service will be in the copy.

*/

XQServiceRequest& XQServiceRequest::operator=(const XQServiceRequest& orig)

{

    XQSERVICE_DEBUG_PRINT("XQServiceRequest::operator=");

    if( &orig == this )

        return *this;

    mData->mService = orig.mData->mService;

    mData->mMessage = orig.mData->mMessage;

    mData->mArguments = orig.mData->mArguments;

    mData->mRequestUtil = orig.mData->mRequestUtil;

    return *this;

}

/*!

    Destroys the service request. Unlike QtopiaIpcEnvelope, the

    request is not automatically sent.

*/

XQServiceRequest::~XQServiceRequest()

{

    XQSERVICE_DEBUG_PRINT("XQServiceRequest::~XQServiceRequest %s", qPrintable(mData->mUniqueChannelName));

    XQServiceAdaptor::cancelPendingSend(mData->mUniqueChannelName);

    delete mData;

}

/*!

    Checks if request is NULL.

    \return True if either the service() or message() is not set.

    \sa service(), message()

 */

bool XQServiceRequest::isNull() const

{

    XQSERVICE_DEBUG_PRINT("XQServiceRequest::isNull");

    bool ret = mData->mService.isEmpty() || mData->mService.isNull() || mData->mMessage.isNull();

	XQSERVICE_DEBUG_PRINT("mData->mService.isEmpty() = %d", mData->mService.isEmpty());

	XQSERVICE_DEBUG_PRINT("mData->mService.isNull() = %d", mData->mService.isNull());

	XQSERVICE_DEBUG_PRINT("mData->mMessage.isNull() = %d", mData->mMessage.isNull());

	XQSERVICE_DEBUG_PRINT("return %d", ret);

	return ret;

}

/*!

    Checks if request is synchronous or asynchronous.

    \return True if request is synchronous, false if request is asynchronous.

    \sa setSynchronous()

 */

bool XQServiceRequest::isSynchronous() const

{

    XQSERVICE_DEBUG_PRINT("XQServiceRequest::isSynchronous");

    return mData->mSynchronous;

}

/*!

    Sets request to be synchronous or asynchronous.

    \param synchronous If set to true, request will be synchronous.

                       If set to false, request will be asynchronous.

    \sa isSynchronous()

 */

void XQServiceRequest::setSynchronous(const bool& synchronous)

{

    XQSERVICE_DEBUG_PRINT("XQServiceRequest::setSynchronous");

    mData->mSynchronous = synchronous;

}

/*!

    Sends the request. If the request is synchronous, then client is blocked

    until service provider completes the request or request fails for some reason.

    If the request is asynchronous, then client won't be blocked. If the request

    is asynchronous and clients wants to receive a return value from the service

    provider, then clients should connect to the requestCompleted() signal.

    \return False if there was no application that could service the request, otherwise true.

*/

bool XQServiceRequest::send()

{

    XQSERVICE_DEBUG_PRINT("XQServiceRequest::send(1)");

    QVariant retValue;

    return send(retValue);

}

/*!

    Sends the request. If the request is synchronous, then client is blocked

    until service provider completes the request or request fails for some reason.

    If the request is asynchronous, then client won't be blocked.

    \param retData Defines refence to a value service provider will return after service.

    \return False if there was no application that could service the request, otherwise true.

*/

bool XQServiceRequest::send(QVariant& retData)

{

    XQSERVICE_DEBUG_PRINT("XQServiceRequest::send(2)");

    if (isNull())

    {

        XQSERVICE_DEBUG_PRINT("XQServiceRequest::send error: null request");

        XQService::serviceThreadData()->setLatestError(XQService::EArgumentError);

        return false;

    }

    // Handle sharable file argument(s), if any

    if (!handleSharableFileArgs())

    {

        XQSERVICE_DEBUG_PRINT("XQServiceRequest::send error:invalid sharable file");

        XQService::serviceThreadData()->setLatestError(XQService::EArgumentError);

        return false;

    }

    mData->mRequestUtil.setSynchronous(mData->mSynchronous); // Ensure option is set !

    mData->mRequestUtil.mOperation = mData->mMessage;  // Save the operation name for startup

    // !!!

    // Add the info as extra argument to the request

    // This shall be removed by the server

    // !!!

    addArg(qVariantFromValue(mData->mRequestUtil.mInfo));

    // Pass always the util instance onwards as user data.

    // It can be utilized by the XQServiceManager::startServer

    // e.g. to optimize startup of a service server

    // Create unique channel name to separate multiple client requests to same channel name.

    quint32 handle = (unsigned int)mData;

    mData->mUniqueChannelName = QString("%1:").arg(handle) + mData->mService;

    XQSERVICE_DEBUG_PRINT("XQServiceRequest::send(2):uniqueChannel=%s", qPrintable(mData->mUniqueChannelName));

    return XQServiceAdaptor::send(mData->mUniqueChannelName,  message(), mData->mArguments, retData, mData->mSynchronous,mData,

                                 (const void *)&mData->mRequestUtil);

}

/*!

    Sets the full name of the service to which the request will be sent.

    \param fullServiceName Full name of the service to send message to. See

                           XQServiceRequest(const QString& service, const QString& message, const bool &synchronous)

                           for the full name definition.

    \sa service()

 */

void XQServiceRequest::setService(const QString& fullServiceName)

{

    XQSERVICE_DEBUG_PRINT("XQServiceRequest::setService");

    XQSERVICE_DEBUG_PRINT("service: %s", qPrintable(fullServiceName));

    mData->mService = fullServiceName;

    mData->mArguments.clear();

    mData->mRequestUtil.mDescriptor = XQAiwInterfaceDescriptor(); // Invalid descriptor

}

/*!

    Gets the service name to which this request will be sent.

    \return Full service name to which request will be sent.

    \sa setService()

*/

QString XQServiceRequest::service() const

{

    XQSERVICE_DEBUG_PRINT("XQServiceRequest::service");

    XQSERVICE_DEBUG_PRINT("service: %s", qPrintable(mData->mService));

    return mData->mService;

}

/*!

    Sets the \a message to be sent to the service.

    \param message Defines the message to send to a service provider. The message

                   is a valid Qt slot signature published by the service provider.

                   For example, "view(QString)".

    \sa message()

*/

void XQServiceRequest::setMessage(const QString& message)

{

    XQSERVICE_DEBUG_PRINT("XQServiceRequest::setMessage");

    XQSERVICE_DEBUG_PRINT("message: %s", qPrintable(message));

    mData->mMessage = message;

    mData->mArguments.clear();

}

/*!

    Gets the message set for the request.

    \return Message of the request as QString.

    \sa setMessage()

*/

QString XQServiceRequest::message() const

{