/*!

    \class XQAiwRequest

    \inpublicgroup QtBaseModule

    \ingroup ipc

    \brief Encapsulates the core functionality of the interworking requests

    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.

    This class is a part of API to be used by the applications instead of using XQServiceRequest directly.

    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.

    - Launched service provider application (.exe) if not already running when client makes service call to it.

    - List and discover services dynamically.

    - 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.

    - Opening URI to be viewed by a URI viewing interface. Includes also launching activity URIs (appto) as fire-and-forget manner.

    - 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

        // Later on when caching of services

        // 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.

            request = mAiwMgr.create("Interface", "functionName2(QString, int)", embedded);

            // If dedicated service is wanted, apply this 

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

            //                          "functionName2(QString, int)", embedded);

            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

           bool res = request.send();

           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.

*/

/*!

    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.

*/

/*!

    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.

*/

/*!

    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.

*/

    emits triggered() signal for caller.

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

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

                     to be called

        - 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

    \return Error code as QString value.

    \return Implementation descriptor attached to the request.

    Starts the service application if necessary and sends request on-ward.

    The results are delivered via requestOk() and requestError() signals.

    If the request is synchronous, the client application is blocked until

    service provider completes the request.

    \return True on success, false otherwise

    \return True on success, false otherwise

/*!

    Request service application to be launched in embedded mode.

    \param embedded If set to true, service application will be launched

                    in embedded mode

*/

/*!

    Get the value of embedded option of the request.

    \return True if request is set to launch service application in embedded

            mode, false otherwise

*/

/*!

    Sets service operation. The XQApplicationManager::create() functions for

    files and URLs set the default operation, but it can be overriden using

    this function.

    \param operation Operation to be set to the request.

*/

/*!

    Returns operation attached to the request.

    \return Operation attached to the request

*/

/*!