--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/utilities/serviceipcclient/serviceipcclient.cpp Fri Oct 15 17:30:59 2010 -0400
@@ -0,0 +1,227 @@
+/**
+ This file is part of CWRT package **
+
+ Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). **
+
+ 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/>.
+*/
+
+
+#include "serviceipcclient.h"
+#include "serviceipc.h"
+
+namespace WRT
+{
+
+/*!
+ \class ServiceIPCClient
+ This class is an extension to the current ServiceIPCClient interface
+ with the additional functionality of receiving messages from the server
+ */
+
+/*!
+ Destructor
+ */
+ServiceIPCClient::~ServiceIPCClient()
+{
+ delete m_syncIPC;
+ delete m_asyncIPC;
+ delete m_broadcastIPC;
+}
+
+/*!
+ Constructor
+ @param aBackend IPC backend to use
+ @param aParent Parent to this QObject
+ */
+ServiceIPCClient::ServiceIPCClient(QObject* aParent, TServiceIPCBackends aBackend) :
+ QObject(aParent)
+{
+ m_syncIPC = new ServiceFwIPC(aParent, aBackend);
+ m_asyncIPC = new ServiceFwIPC(aParent, aBackend);
+ m_broadcastIPC = new ServiceFwIPC(aParent, aBackend);
+
+ QObject::connect(m_asyncIPC, SIGNAL(readyRead()), this, SLOT(handleAsyncMsg()));
+ QObject::connect(m_broadcastIPC, SIGNAL(readyRead()), this, SLOT(handleBroadcastMsg()));
+}
+
+/*!
+ Connect to the server
+ @param aServerName name of the server to connect to
+ @return true if connected, false if not
+ */
+bool ServiceIPCClient::connect(const QString& aServerName)
+{
+ bool ret;
+ ret = m_syncIPC->connect(aServerName);
+ if (ret) {
+ int sessionId;
+ ret = m_syncIPC->getSessionId(sessionId);
+ if (ret) {
+ m_sessionId = sessionId;
+ ret = m_asyncIPC->connect(aServerName);
+ if (ret) {
+ ret = m_asyncIPC->setSessionId(sessionId);
+ if (ret) {
+ ret = m_broadcastIPC->connect(aServerName);
+ if (ret) {
+ ret = m_broadcastIPC->setSessionId(sessionId);
+ if (!ret) {
+ //async. IPC set session ID fail, disconnect broadcast IPC
+ m_broadcastIPC->disconnect();
+ }
+ else {
+ subscribeBroadcastMsg();
+ }
+ }
+ }
+ if (!ret) {
+ //async. IPC set session ID fail or broadcast IPC connect fail, disconnect async IPC
+ m_asyncIPC->disconnect();
+ }
+ }
+ }
+ if (!ret) {
+ m_syncIPC->disconnect(); //get sessionId failed or async. IPC connect fail, disconnect sync IPC
+ }
+ }
+ return ret;
+}
+
+/*!
+ Disconnect from the server
+ @return void
+ */
+void ServiceIPCClient::disconnect()
+{
+ m_syncIPC->disconnect();
+ m_asyncIPC->disconnect();
+ m_broadcastIPC->disconnect();
+}
+
+/*!
+ Starts the service
+ @param aServerName name of the server
+ @param aExeName executable of the server
+ @return true if connected
+ */
+bool ServiceIPCClient::startServer(const QString& aServerName,
+ const QString& aExeName)
+{
+ return m_syncIPC->startServer(aServerName, aExeName);
+}
+
+/*!
+ Send a request synchronously
+ @param aRequestType name of the request
+ @param aData data to send
+ @return true if sent successful, otherwise false
+ */
+bool ServiceIPCClient::sendSync(const QString& aRequestType,
+ const QByteArray& aData)
+{
+ return m_syncIPC->sendSync(aRequestType, aData);
+}
+
+/*!
+ Send a request asynchronously
+ @param aRequestType name of the request
+ @param aData data to send
+ @note Errors will be emitted via errors() signal
+ @return void
+ */
+void ServiceIPCClient::sendAsync(const QString& aRequestType,
+ const QByteArray& aData)
+{
+ m_asyncIPC->sendAsync(aRequestType, aData);
+}
+
+/*!
+ Reads all data pending in the buffer.\n
+ For Sync version this will wait until all of the data is available.\n
+ @return QByteArray of results
+ */
+QByteArray ServiceIPCClient::readAll()
+{
+ return m_syncIPC->readAll();
+}
+
+/*!
+ Check if an async request is already pending
+ @return true if an async request is pending
+ false otherwise
+ */
+/*bool ServiceIPCClient::requestPending()
+{
+ return m_asyncIPC->requestPending();
+}*/
+
+/*!
+ Reads all data pending in the buffer.\n
+ For Async version it will return the currently read buffer.\n
+ Use only after readyRead() signal is emitted. However partial data can be read
+ */
+void ServiceIPCClient::handleAsyncMsg()
+{
+ // Read the results
+ QByteArray ipcResult(m_asyncIPC->readAll());
+
+ if (!ipcResult.isEmpty()) {
+ emit readAsync(ipcResult);
+ }
+}
+
+/*!
+ Client side interface to subscribe broadcast message
+ */
+void ServiceIPCClient::subscribeBroadcastMsg()
+{
+ QString null;
+ m_broadcastIPC->sendAsync(SUBSCRIBEBROADCASTMSG, null.toAscii());
+}
+
+/*!
+ Reads all data pending in the buffer.\n
+ For broadcast version it will return the currently read buffer.\n
+ Use only after readyRead() signal is emitted. However partial data can be read
+ */
+void ServiceIPCClient::handleBroadcastMsg()
+{
+ // Read the results
+ QByteArray ipcResult(m_broadcastIPC->readAll());
+
+ if (!ipcResult.isEmpty()) {
+ emit handleMessage(ipcResult);
+ subscribeBroadcastMsg();
+ }
+}
+
+}
+
+
+/*!
+ \fn WRT::ServiceIPCClient::error( int aError )
+
+ Signal emitted to handle any errors
+ @param aError error code
+ @note: For local socket implementation, the error can be interpreted
+ as QLocalSocket::LocalSocketError
+ @return void
+ */
+
+/*!
+ \fn WRT::ServiceIPCClient::readyRead()
+
+ Handle when a reply has been received for async requests\n
+ Emitted when the entire data packet has been received
+ @return void
+ */
+// END OF FILE