/*

* 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 <QObject>

#include <qglobal.h>

#include "xqservicelog.h"

#include "xqaiwservicedriver.h"

#include "xqaiwfiledriver.h"

#include "xqaiwuridriver.h"

#include "xqaiwrequest.h"

/*!

    \class XQAiwRequest

    \inpublicgroup QtBaseModule

    \ingroup ipc

    The XQAiwRequest class encapsulates the core functionality of the interworking requests and hides the implementation details. 

    This object is created by the XQApplicationManager::create factory method.

    The Application Manager API offers centric place for applications UIs to handle application to application interworking use cases, like:

    - Synchronous out-of-process service call from client to service provider, where service provider needs to complete the request before

      control comes back to requesting client.

    - Asynchronous out-of-process service call from client to service provider, where Service provider completes the request whenever suitable.

      The control returns back requesting as soon the service provider has received the asynchronous call (can be applied to notifications as well).

    - Embedded out-of-process service call. In this case window groups are chained and "Back" returns to client window.

    - Any named Qt type in the Qt meta-object system can be used as a service call parameter or return value. Also own, custom meta-types are supported.

    - Apply UI related options upon service launch, like "launch as embedded", "launch to foreground" and "launch to backround".

    - Opening files to be viewed by a file viewing interface.

    - Miscellanous AIW support, like get service stasus or get DRM attributes.

    See the "examples/appmgrclient" included in the QtHighway release for usage examples.

    <b>Example usage:</b> \n

    The usage pattern for all the XQAiwRequest variants implemented as service providers , interface, QUrl, QFile, is similar both embedded

    and non-embedded usage.

    \code

        // Recommended way is to add XQApplicationManager as member variable to class

        // You can use the class also as local variable.

        class Client

        {

        public:

             // Service access

            bool accessService(void);

        private slots:

                void handleOk(const QVariant &result);

                void handleError(int errorCode, const QString& errorMessage);

        private:

              XQApplicationManager mAiwMgr;

        };

        //  In client.cpp

        bool Client::accessService(void)

        {

            QString parameter1("+3581234567890");

            int parameter2 = 3;

            bool embedded=true;  // or false

            XQAiwRequest *request;

            // Create request by interface name, the very first service implementation

            // applied.

            // If dedicated service is wanted, apply this 

            // request = mAiwMgr.create("Service", "Interface", 

            if (request == NULL)

            {

                // Service not found 

                return false;

            }

            // Connect result handling signal

            connect(request, SIGNAL(requestOk(const QVariant&)), this, SLOT(handleOk(const QVariant&)));

            // Connect error handling signal or apply lastError function instead.

            connect(request, SIGNAL(requestError(int,const QString&)), this, SLOT(handleError(int,const QString&)));

            // Set function parameters

           QList<QVariant> args;

           args << parameter1;

           args << parameter2;

           request->setArguments(args);

           // In this example, request embedded launch (window groups chained)

           request->setEmbedded(true);

           // Send the request

           if  (!res) 

           {

               // Request failed. 

              return false;

           }

           // If making multiple requests to same service, you can save the request as member variable

           // In this example all done.

           delete request;

           return true;

        }

        void Client::handleOk(const QVariant& result)

        {

           // Handle result here or just save them.

           // Result could be a service specific error code also.

           // 

        }

        void Client::handleError(int errorCode, const QString& errorMessage)

        {

           // Handle error

        }

    \endcode

    \sa XQApplicationManager

*/

/*!

    Constructs interworking request to service application by the given interface \a descriptor

    which points to the dedicated implementation. The service application is not started during

    creation of the request.

    \param descriptor Points to the dedicated service implementation. Obtained via the XQApplicationManager::list function.

    \param operation Service function to be called, equals \a message parameter in XQServiceRequest.

    \param embedded True if window groups should be chained, false otherwise

    \return Constructed interworking request to service application object.

*/

XQAiwRequest::XQAiwRequest(const XQAiwInterfaceDescriptor& descriptor, const QString &operation, bool embedded)

    : QObject(),

      currentRequest(NULL),

      errorMsg(),

      errorCode(0),

      completeSignalConnected(false),

      errorSignalConnected(false)

{

    XQSERVICE_DEBUG_PRINT("XQAiwRequest::XQAiwRequest: %s %s,%d,%x",

                          qPrintable(descriptor.interfaceName()),

                          qPrintable(operation),

                          embedded,

                          descriptor.property(XQAiwInterfaceDescriptor::ImplementationId).toInt());

    // Initialize service request

    // The XQServiceRequest should actually accept service descriptor as input....

    currentRequest = new XQAiwServiceDriver(descriptor, operation);

    if (currentRequest)

    {

        currentRequest->setEmbedded(embedded);

    }

}

/*!

    Constructs interworking request to service application by the given uri and the interface \a descriptor

    which points to the dedicated implementation. The service application is not started during

    creation of the request.

    \param uri Uri for the given interworking request to service application.

    \param descriptor Points to the dedicated service implementation. Obtained via the XQApplicationManager::list function.

    \param operation Service function to be called, equals \a message parameter in XQServiceRequest.

    \return Constructed interworking request to service application object.

*/

XQAiwRequest::XQAiwRequest(

    const QUrl &uri, const XQAiwInterfaceDescriptor& descriptor, const QString &operation)

    : QObject(),

      currentRequest(NULL),

      errorMsg(),

      errorCode(0),

      completeSignalConnected(false),

      errorSignalConnected(false)

{

    XQSERVICE_DEBUG_PRINT("XQAiwRequest::XQAiwRequest (uri): %s %s,%x",

                          qPrintable(descriptor.interfaceName()),

                          qPrintable(operation),

                          descriptor.property(XQAiwInterfaceDescriptor::ImplementationId).toInt());

    if (XQAiwUriDriver::hasCustomHandler(uri))

    {

        // Custom handling goes via URI driver

        currentRequest = new XQAiwUriDriver(uri, descriptor, operation);

    }

    else

    {

        // Otherwise, apply service based URI access

        currentRequest = new XQAiwServiceDriver(descriptor, operation);

    }

}

/*!

    Constructs interworking request to service application by the file and the interface \a descriptor

    which points to the dedicated implementation. The service application is not started during

    creation of the request.

    \param file File for the given interworking request to service application.

    \param descriptor Points to the dedicated service implementation. Obtained via the XQApplicationManager::list function.

    \param operation Service function to be called, equals \a message parameter in XQServiceRequest.

    \return Constructed interworking request to service application object.

*/

XQAiwRequest::XQAiwRequest(

    const QFile &file, const XQAiwInterfaceDescriptor& descriptor, const QString &operation)

    : QObject(),

     currentRequest(NULL),

      errorMsg(),

      errorCode(0),

      completeSignalConnected(false),

      errorSignalConnected(false)

{

   XQSERVICE_DEBUG_PRINT("XQAiwRequest::XQAiwRequest (file): %s %x",

                          qPrintable(file.fileName()),

                          descriptor.property(XQAiwInterfaceDescriptor::ImplementationId).toInt());

    // Initialize file service request

   if (!descriptor.interfaceName().isEmpty())

   {

       // Apply normal service request

       XQSERVICE_DEBUG_PRINT("Apply service driver");

       currentRequest = new XQAiwServiceDriver(descriptor, operation);

   }

   else 

   {

       // The is no service provider for the file.

       // So as backup plan, apply file driver to handle non-service file launches

       XQSERVICE_DEBUG_PRINT("Apply file driver");

       currentRequest = new XQAiwFileDriver(file, descriptor, operation);

   }

}

/*!

    Constructs interworking request to service application by the sharable file and the interface \a descriptor

    which points to the dedicated implementation. The service application is not started during

    creation of the request.

    \param file Sharable file for the given interworking request to service application.

    \param descriptor Points to the dedicated service implementation. Obtained via the XQApplicationManager::list function.

    \param operation Service function to be called, equals \a message parameter in XQServiceRequest.

    \return Constructed interworking request to service application object.

*/

XQAiwRequest::XQAiwRequest(

     const XQSharableFile &file, const XQAiwInterfaceDescriptor& descriptor, const QString &operation)

    : QObject(),

      currentRequest(NULL),

      errorMsg(),

      errorCode(0),

      completeSignalConnected(false),

      errorSignalConnected(false)

{

    XQSERVICE_DEBUG_PRINT("XQAiwRequest::XQAiwRequest (file handle): %x",

                          descriptor.property(XQAiwInterfaceDescriptor::ImplementationId).toInt());

    // Initialize file service request

    if (!descriptor.interfaceName().isEmpty())

    {

       // Apply normal service request

        XQSERVICE_DEBUG_PRINT("Apply service driver");

        currentRequest = new XQAiwServiceDriver(descriptor, operation);

    }

    else 

    {

       // The is no service provider for the file.

       // So as backup plan, apply file driver to handle non-service file launches

        XQSERVICE_DEBUG_PRINT("Apply file driver");

        currentRequest = new XQAiwFileDriver(file, descriptor, operation);

    }

}

XQAiwRequest::~XQAiwRequest()

{

    XQSERVICE_DEBUG_PRINT("~XQAiwRequest::XQAiwRequest");

    // Disconnect signals

    if (completeSignalConnected)

    {

        disconnect(currentRequest, SIGNAL(requestOk(const QVariant&)), this, SLOT(handleAsyncResponse(const QVariant&)));

    }

    if (errorSignalConnected)

    {

        disconnect(currentRequest, SIGNAL(requestError(int,const QString&)), this, SLOT(handleAsyncError(int)));

    }

    delete currentRequest; // Destructor cancels the async request

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

    {

        delete actionList[i];

    }

}

/*!

    Create a QAction related to request from the registration data. Caller can

    add the action to wanted UI widget. When the action  is triggered the XQAiwRequest

    emits triggered() signal for caller.

    The XQAiwRequest owns the action (caller shall not delete the action object).

    \return QAction object, if there was action attached to request. Otherwise 0.

*/

QAction *XQAiwRequest::createAction()

{

    XQSERVICE_DEBUG_PRINT("XQAiwRequest::createAction");

    QAction * action = currentRequest->createAction();

    if (action)

    {

        if (!connect(action, SIGNAL(triggered(bool)), this, SLOT(sendFromAction(bool)))) {

            XQSERVICE_CRITICAL_PRINT("Failed to connect QAction triggered signal to XQAiwRequest.");

        }

        actionList.append(action);

        return action; 

    }

    return NULL;

}

/*!

    Set arguments for the request. This shall be called before sending

    add the action to wanted UI widget. For the attached action, the

    triggered() signal emitted by the request is the last chance to

    add aguments.

    \param arguments List of arguments that will be transferred to service provider function

                     to be called

*/

void XQAiwRequest::setArguments(const QList<QVariant> &arguments)

{

    XQSERVICE_DEBUG_PRINT("XQAiwRequest::setArguments");

    currentRequest->setArguments(arguments);

}

/*!

    Returns the last error code occured.

    IPC errors:

        - ENoError          = 0

        - EConnectionError  = -5000,  (Server might be busy)

        - EConnectionClosed = -4999,  

        - EServerNotFound   = -4998,

        - EIPCError         = -4997,

        - EUnknownError     = -4996,

        - ERequestPending   = -4995,  (already pending request exists)

        - EMessageNotFound  = -4994,

        - EArgumentError    = -4993

    \return Error code as integer value.

    \sa xqserviceglobal.h for error codes

*/

int XQAiwRequest::lastError() const

{

    int err = currentRequest->lastError();

    XQSERVICE_DEBUG_PRINT("XQAiwRequest::lastError %d", err);

    return err;

}

/*!

    Returns the last error as text for debugging purposes.

    The content and details of the text may vary over API

    development time evolution.

    \return Error code as QString value.

*/

const QString& XQAiwRequest::lastErrorMessage() const