--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/qthighway/xqservice/src/xqserviceprovider.cpp Fri Apr 16 15:51:22 2010 +0300
@@ -0,0 +1,222 @@
+/*
+* 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 <xqserviceprovider.h>
+#include <qmetaobject.h>
+#include <QByteArray>
+
+#include <xqserviceadaptor.h>
+//#include <xqserviceservice.h>
+#include <xqserviceutil.h>
+
+/*!
+ \class XQServiceProvider
+ \inpublicgroup QtBaseModule
+
+ \brief The XQServiceProvider class provides an interface to messages on a XQService service
+ which simplifies remote slot invocations
+
+ Service messages consist of a service name, a message name, and a list of parameter values.
+ Qt extension extension dispatches service messages to the applications associated with the service
+ name, on the application's \c{QPE/Application/appname} channel, where
+ \c{appname} is the application's name.
+
+ The use of XQServiceProvider will be demonstrated using the \c{Time}
+ service. This has a single message called \c{editTime()} which asks
+ the service to pop up a dialog allowing the user to edit the current time.
+
+ \code
+ class TimeService : public XQServiceProvider
+ {
+ Q_OBJECT
+ public:
+ TimeService( QObject *parent = 0 );
+
+ public slots:
+ void editTime(QTime time);
+ };
+
+ TimeService::TimeService( QObject *parent )
+ : XQServiceProvider( "Time", parent )
+ {
+ publishAll();
+ }
+ \endcode
+
+ The call to publishAll() causes all public slots within \c{TimeService}
+ to be automatically registered as Service messages. This can be
+ useful if the service has many message types.
+
+ The client can send a request to the service using QtopiaServiceRequest:
+
+ \code
+ XQServiceRequest req( "Time", "editTime()" );
+ req << QTime::currentTime();
+ req.send();
+ \endcode
+
+*/
+
+class ServiceAdaptorProxy : public XQServiceAdaptor
+{
+ Q_OBJECT
+
+public:
+ ServiceAdaptorProxy(const QString &channel, QObject *parent=0);
+ virtual ~ServiceAdaptorProxy() ;
+
+ QString memberToMessage( const QByteArray& member );
+};
+
+ServiceAdaptorProxy::ServiceAdaptorProxy(const QString &channel, QObject *parent) :
+ XQServiceAdaptor(channel, parent)
+{
+ XQSERVICE_DEBUG_PRINT("ServiceAdaptorProxy::ServiceAdaptorProxy");
+ XQSERVICE_DEBUG_PRINT("channel: %s", qPrintable(channel));
+}
+
+ServiceAdaptorProxy::~ServiceAdaptorProxy()
+{
+ XQSERVICE_DEBUG_PRINT("ServiceAdaptorProxy::~ServiceAdaptorProxy");
+}
+
+QString ServiceAdaptorProxy::memberToMessage( const QByteArray& member )
+{
+ XQSERVICE_DEBUG_PRINT("ServiceAdaptorProxy::memberToMessage");
+ XQSERVICE_DEBUG_PRINT("member: %s", member.constData());
+// TO BE CHECKED
+// return m_channel + "::" + XQServiceAdaptor::memberToMessage( member );
+ return XQServiceAdaptor::memberToMessage( member );
+}
+
+class XQServiceProvider_Private
+{
+public:
+ XQServiceProvider_Private(const QString &service);
+
+ ~XQServiceProvider_Private();
+
+ XQServiceAdaptor *m_adaptor;
+
+ QString m_service;
+ bool m_publishAllCalled;
+ QObject* plugin;
+};
+
+XQServiceProvider_Private::XQServiceProvider_Private(const QString &service) :
+ m_adaptor(NULL),
+ m_service(service),
+ m_publishAllCalled(false),
+ plugin(NULL)
+{
+ XQSERVICE_DEBUG_PRINT("XQServiceProvider_Private::XQServiceProvider_Private");
+ XQSERVICE_DEBUG_PRINT("service: %s", qPrintable(service));
+ m_adaptor = new ServiceAdaptorProxy(service);
+}
+
+XQServiceProvider_Private::~XQServiceProvider_Private()
+{
+ XQSERVICE_DEBUG_PRINT("XQServiceProvider_Private::~XQServiceProvider_Private");
+ delete m_adaptor;
+}
+
+
+/*!
+ Construct a remote service object for \a service and attach it to \a parent.
+*/
+XQServiceProvider::XQServiceProvider( const QString& service, QObject *parent )
+ : QObject( parent )
+{
+ XQSERVICE_DEBUG_PRINT("XQServiceProvider::XQServiceProvider");
+ XQSERVICE_DEBUG_PRINT("service: %s", qPrintable(service));
+ m_data = new XQServiceProvider_Private(service);
+ connect(m_data->m_adaptor, SIGNAL(returnValueDelivered()), this, SIGNAL(returnValueDelivered()));
+ connect(m_data->m_adaptor, SIGNAL(clientDisconnected()), this, SIGNAL(clientDisconnected()));
+}
+
+/*!
+ Destroy this service handling object.
+*/
+XQServiceProvider::~XQServiceProvider()
+{
+ XQSERVICE_DEBUG_PRINT("XQServiceProvider::~XQServiceProvider");
+ if (m_data)
+ delete m_data;
+}
+
+
+void XQServiceProvider::SetPlugin(QObject* impl_plugin)
+ {
+ m_data->plugin=impl_plugin;
+ }
+
+
+/*!
+ Publishes all slots on this object within subclasses of XQServiceProvider.
+ This is typically called from a subclass constructor.
+*/
+void XQServiceProvider::publishAll()
+{
+ XQSERVICE_DEBUG_PRINT("XQServiceProvider::publishAll");
+ if (!m_data->plugin) {
+ m_data->m_adaptor->publishAll(this,XQServiceProvider::staticMetaObject.methodCount(),XQServiceAdaptor::Slots);
+ }
+ else {
+ m_data->m_adaptor->publishAll(m_data->plugin, 0, XQServiceAdaptor::Slots);
+ }
+}
+
+/*!
+* Sets current request to asynchronous mode so that provider can complete the
+* request later via the completeRequest() call.
+* \return Request ID which shall be used in the completeRequest() call.
+*/
+int XQServiceProvider::setCurrentRequestAsync()
+{
+ XQSERVICE_DEBUG_PRINT("XQServiceProvider::setCurrentRequestAsync");
+ return m_data->m_adaptor->setCurrentRequestAsync();
+}
+
+/*!
+* Completes the asynchronous request with the given value
+* \param index Request ID got from the setCurrentRequestAsync call.
+* \param retValue The value
+* \return true on success, false if index points to non-existing request.
+*/
+bool XQServiceProvider::completeRequest(int index, const QVariant& retValue)
+{
+ XQSERVICE_DEBUG_PRINT("XQServiceProvider::completeRequest");
+ XQSERVICE_DEBUG_PRINT("index: %d, retValue: %s", index, qPrintable(retValue.toString()));
+ return m_data->m_adaptor->completeRequest(index, retValue);
+}
+
+/*!
+* Return additional request information attached to request
+* \return Request info
+*/
+XQRequestInfo XQServiceProvider::requestInfo() const
+{
+ return m_data->m_adaptor->requestInfo();
+}
+
+#include "xqserviceprovider.moc"