diff -r cfcbf08528c4 -r 2b40d63a9c3d qthighway/xqservice/src/xqaiwrequest.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/qthighway/xqservice/src/xqaiwrequest.cpp	Fri Apr 16 15:51:22 2010 +0300
@@ -0,0 +1,428 @@
+/*
+* 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"
+
+XQAiwRequest::XQAiwRequest(const XQAiwInterfaceDescriptor& descriptor, const QString &operation, bool embedded)
+    : QObject(),
+      currentRequest(NULL),
+      errorMsg(),
+      errorCode(0),
+      asyncErrorSet(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);
+    }
+}
+
+XQAiwRequest::XQAiwRequest(
+    const QUrl &uri, const XQAiwInterfaceDescriptor& descriptor, const QString &operation)
+    : QObject(),
+      currentRequest(NULL),
+      errorMsg(),
+      errorCode(0),
+      asyncErrorSet(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);
+    }
+    
+}
+
+
+
+XQAiwRequest::XQAiwRequest(
+    const QFile &file, const XQAiwInterfaceDescriptor& descriptor, const QString &operation)
+    : QObject(),
+     currentRequest(NULL),
+      errorMsg(),
+      errorCode(0),
+      asyncErrorSet(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 
+   {
+       // This means descriptor is incompete and created for carrying implementation information only.
+       // See XQApplicationManagerPrivate::getAppDescriptor or XQApplicationManagerPrivate::listMimeHandlers
+       XQSERVICE_DEBUG_PRINT("Apply file driver");
+       currentRequest = new XQAiwFileDriver(file, descriptor, operation);
+   }
+       
+}
+
+
+XQAiwRequest::XQAiwRequest(
+     const XQSharableFile &file, const XQAiwInterfaceDescriptor& descriptor, const QString &operation)
+    : QObject(),
+      currentRequest(NULL),
+      errorMsg(),
+      errorCode(0),
+      asyncErrorSet(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);
+    }
+
+    // No other way to pass sharable file as via service request
+
+}
+
+            
+XQAiwRequest::~XQAiwRequest()
+{
+    XQSERVICE_DEBUG_PRINT("~XQAiwRequest::XQAiwRequest");
+
+    // Disconnect error
+    if (asyncErrorSet)
+    {
+        disconnect(currentRequest, SIGNAL(requestOk(const QVariant&)), this, SLOT(handleAsyncResponse(const QVariant&)));
+        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.
+*/
+void XQAiwRequest::setArguments(const QList<QVariant> &arguments)
+{
+    XQSERVICE_DEBUG_PRINT("XQAiwRequest::setArguments");
+    currentRequest->setArguments(arguments);
+}
+
+
+/*!
+    Returns the last error code occured.
+    IPC errors:
+        EConnectionError  = -5000,  (Server might be busy)
+        EConnectionClosed = -4999,  
+        EServerNotFound   = -4998,
+        EIPCError         = -4997,
+        EUnknownError     = -4996,
+        ERequestPending   = -4995   (already pending request exists)
+        EM   = -4995   (already pending request exists)
+
+*/
+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.
+*/
+const QString& XQAiwRequest::lastErrorMessage() const
+{
+    XQSERVICE_DEBUG_PRINT("XQAiwRequest::lastErrorMessage");
+    return currentRequest->lastErrorMessage();
+}
+
+
+/*!
+    Returns the implementation descriptor of a service attached to request.
+    Caller can check meta-data information of the request.
+*/
+const XQAiwInterfaceDescriptor &XQAiwRequest::descriptor() const 
+{
+    XQSERVICE_DEBUG_PRINT("XQAiwRequest::descriptor");
+    return currentRequest->descriptor();
+}
+
+/*!
+    Send request on-ward.
+    The results are delivered via "requestOk" and "requestError" signals.
+    \return true on success, false otherwise
+*/
+bool XQAiwRequest::send()
+{
+    XQSERVICE_DEBUG_PRINT("XQAiwRequest::send");
+
+    // do request
+    if (sendExecute())
+    {
+        if (currentRequest->isSynchronous())
+        {
+            XQSERVICE_DEBUG_PRINT("XQAiwRequest::emit requestOk");
+            emit requestOk(result);
+            result.clear();
+        }
+        return true;
+    } else
+    {
+        XQSERVICE_DEBUG_PRINT("XQAiwRequest::emit requestError");
+        emit requestError(lastError(), lastErrorMessage());
+        return false;
+    }
+}
+
+
+/*!
+    Convinience method for sending a synchronous request on-ward.
+    The returnValue delivered via the output parameter.
+    \return true on success, false otherwise
+*/
+bool XQAiwRequest::send(QVariant &returnValue)
+{
+
+    XQSERVICE_DEBUG_PRINT("XQAiwRequest::send(retValue)");
+
+    // do request
+    if (sendExecute())
+    {
+        if (currentRequest->isSynchronous())
+        {
+            XQSERVICE_DEBUG_PRINT("XQAiwRequest::set retValue ");
+            // Do not emit requestOk as return value delivered directly
+            returnValue = result; // Copy return value
+            result.clear();
+        }
+        return true;
+    } else
+    {
+        XQSERVICE_DEBUG_PRINT("XQAiwRequest::emit requestError");
+        emit requestError(lastError(), lastErrorMessage());
+        return false;
+    }
+   
+}
+
+
+void XQAiwRequest::setEmbedded(bool embedded)
+{
+    XQSERVICE_DEBUG_PRINT("XQAiwRequest::setEmbedded=%d",embedded);
+    currentRequest->setEmbedded(embedded);
+}
+bool XQAiwRequest::isEmbedded() const
+{
+    XQSERVICE_DEBUG_PRINT("XQAiwRequest::isEmbedded");
+    return currentRequest->isEmbedded();
+}
+
+void XQAiwRequest::setOperation(const QString &operation)
+{
+    XQSERVICE_DEBUG_PRINT("XQAiwRequest::setOperation");
+    currentRequest->setOperation(operation);
+}
+
+const QString &XQAiwRequest::operation() const
+{
+    XQSERVICE_DEBUG_PRINT("XQAiwRequest::operation");
+    return currentRequest->operation();
+}
+
+
+void XQAiwRequest::setSynchronous(bool synchronous)
+{
+    XQSERVICE_DEBUG_PRINT("XQAiwRequest::setSynchronous=%d", synchronous);
+    currentRequest->setSynchronous(synchronous);
+}
+bool XQAiwRequest::isSynchronous() const
+{
+    XQSERVICE_DEBUG_PRINT("XQAiwRequest::isSynchronous");
+    return currentRequest->isSynchronous();
+}
+
+void XQAiwRequest::setBackground(bool background )
+{
+    XQSERVICE_DEBUG_PRINT("XQAiwRequest::setbackground=%d", background);
+    currentRequest->setBackground(background);
+}
+
+bool XQAiwRequest::isBackground() const
+{
+    XQSERVICE_DEBUG_PRINT("XQAiwRequest::isBackground");
+    return currentRequest->isBackground();
+}
+
+void XQAiwRequest::setInfo(const XQRequestInfo &info)
+{
+    XQSERVICE_DEBUG_PRINT("XQAiwRequest::setInfo");
+    return currentRequest->setInfo(info);
+}
+
+XQRequestInfo XQAiwRequest::info() const
+{
+    XQSERVICE_DEBUG_PRINT("XQAiwRequest::info");
+    return currentRequest->info();
+}
+
+
+
+const QVariant &XQAiwRequest::results() const
+{
+    XQSERVICE_DEBUG_PRINT("XQAiwRequest::results");
+    return result;
+}
+
+
+void XQAiwRequest::sendFromAction(bool checked)
+{
+    Q_UNUSED(checked);
+    
+    XQSERVICE_DEBUG_PRINT("XQAiwRequest::sendFromAction");
+    
+    emit triggered(); // Last chance to setup request parameters
+
+    // do request
+    if (sendExecute())
+    {
+        if (isSynchronous())
+        {
+            emit requestOk(result);
+            result.clear();
+        }
+    } else
+    {
+        emit requestError(lastError(), lastErrorMessage());
+    }
+}
+
+bool XQAiwRequest::sendExecute()
+{
+    XQSERVICE_DEBUG_PRINT("XQAiwRequest::sendExecute>>>");
+
+    QStringList list;
+    bool res = true;
+    if (!isSynchronous() && !asyncErrorSet)
+    {
+        // Set async request signals once
+        XQSERVICE_DEBUG_PRINT("request::async send");
+        connect(currentRequest, SIGNAL(requestOk(const QVariant&)), this, SLOT(handleAsyncResponse(const QVariant&)));
+        connect(currentRequest, SIGNAL(requestError(int,const QString&)), this, SLOT(handleAsyncError(int)));
+        asyncErrorSet = true;
+    }
+    
+    XQSERVICE_DEBUG_PRINT("request::send>>>");
+    res = currentRequest->send(result);  // Result is valid for sync request only    
+    XQSERVICE_DEBUG_PRINT("request::send: %d<<<", res);
+    
+    errorCode = currentRequest->lastError(); // ask always
+    if (errorCode || !res)
+    {
+        res = false;
+    }
+    
+    XQSERVICE_DEBUG_PRINT("XQAiwRequest::sendExecute: %d<<<", res);
+    
+    return res;
+
+}
+
+
+
+void XQAiwRequest::handleAsyncResponse(const QVariant& value)
+{
+    XQSERVICE_DEBUG_PRINT("XQAiwRequest::handleAsyncResponse");
+    emit requestOk(value);
+}
+
+void XQAiwRequest::handleAsyncError(int err)
+{
+   XQSERVICE_DEBUG_PRINT("XQAiwRequest::handleAsyncError");
+   errorCode = err;
+   emit requestError(lastError(), lastErrorMessage());
+}