--- a/qthighway/xqservice/src/xqserviceipcclient.cpp Tue Aug 31 16:02:37 2010 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,827 +0,0 @@
-/*
-* 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 "xqserviceipcclient.h"
-#include "xqservicechannel.h"
-#include "xqservicethreaddata.h"
-#include "xqrequestutil.h"
-
-#include <xqserviceutil.h>
-#include <xqserviceipc.h>
-#include <xqserviceipcserver.h>
-#include <xqserviceipcrequest.h>
-#include <QProcess>
-#ifdef QT_S60_AIW_PLUGIN
-#include <xqplugin.h>
-#include <xqpluginloader.h>
-#include <xqplugininfo.h>
-#endif
-#include <QList>
-#include <xqserviceprovider.h>
-#include <e32err.h>
-
-#include <xqsharablefile.h>
-
-struct XQServicePacketHeader
-{
- int totalLength;
- int command;
- int chLength;
- int msgLength;
- int dataLength;
-};
-
-XQServiceIpcClient::XQServiceIpcClient(const QString& ipcConName, bool isServer,
- bool isSync, XQServiceRequestCompletedAsync* rc,
- const void *userData)
- : QObject(), cancelledRequest(NULL), serviceIpc(NULL), serviceIpcServer(NULL), callBackRequestComplete(rc),
- mUserData(userData) // User data can be NULL !
-{
- XQSERVICE_DEBUG_PRINT("XQServiceIpcClient::XQServiceIpcClient");
- XQSERVICE_DEBUG_PRINT("ipcConName: %s, isServer: %d, isSync: %d", qPrintable(ipcConName), isServer, isSync);
- XQSERVICE_DEBUG_PRINT("userData: %x, (int)userData)");
-
-
- mIpcConName = ipcConName;
- server = isServer;
- synchronous = isSync ;
- sendSyncLoop = NULL;
-
- // Incomplete in-process plugin support (just null data members)
- plugin=NULL;
- localProvider=NULL;
- lastId = 0; // Start IDs from 1
-
-#ifdef QT_S60_AIW_PLUGIN
- QList<XQPluginInfo> impls;
- XQPluginLoader pluginLoader;
-
- pluginLoader.listImplementations(ipcConName, impls);
- if (impls.count()) {
- pluginLoader.setUid(impls.at(0).uid());
- // Use the very first plugin found, otherwise impl. ui need to be passed here
- plugin = pluginLoader.instance();
- }
-#endif
-}
-
-XQServiceIpcClient::~XQServiceIpcClient()
-{
- XQSERVICE_DEBUG_PRINT("XQServiceIpcClient::~XQServiceIpcClient");
-#ifdef QT_S60_AIW_PLUGIN
- delete plugin;
- delete localProvider;
-#endif
-// disconnected();
-}
-
-bool XQServiceIpcClient::listen()
-{
- XQSERVICE_DEBUG_PRINT("XQServiceIpcClient::listen,isServer?=%d", server);
-#
-#ifdef QT_S60_AIW_PLUGIN
- if (plugin) return true;
-#endif
-
- if (server) {
- serviceIpcServer = new ServiceFwIPCServer(this, this, ESymbianApaServer);
- bool embedded = XQServiceUtil::isEmbedded();
- XQSERVICE_DEBUG_PRINT("embedded: %d", embedded);
- QString conName = mIpcConName;
- if (embedded) {
- // For embedded launch ass the server app ID to connection name
- // The client side will check the same embedded options and use the
- // same pattern
- quint64 processId = qApp->applicationPid();
- conName = mIpcConName + "." + QString::number(processId);
- }
- XQSERVICE_DEBUG_PRINT("conName: %s", qPrintable(conName));
- return serviceIpcServer->listen(conName);
- }
- XQSERVICE_DEBUG_PRINT("No server");
- return false;
-}
-
-bool XQServiceIpcClient::connectToServer()
-{
- XQSERVICE_DEBUG_PRINT("XQServiceIpcClient::connectToServer, isServer?=%d", server);
-#ifdef QT_S60_AIW_PLUGIN
- if (plugin)
- {
- localProvider= new XQServiceProvider( mIpcConName, NULL);
- localProvider->SetPlugin(plugin);
- // localProvider->publishAll();
- return true;
- }
-#endif
-
- // Attension.
- // The 'mIpcConName' may contai the unique session identifier to separate connections using the same
- // By default server name is the same as the channel name.
- // When embedded launch, we add the server process ID to name to make it unique
- QString serverName = XQRequestUtil::channelName(mIpcConName);
-
- if (!serviceIpc) {
- XQSERVICE_DEBUG_PRINT("New serviceIpc:mIpcConName=%s,serverName=%s",
- qPrintable(mIpcConName), qPrintable(serverName));
-
- serviceIpc = new ServiceFwIPC(this, ESymbianApaServer);
- serviceIpc->setUserData(mUserData); // Attach user data, if any, to request
- const XQRequestUtil *util = static_cast<const XQRequestUtil*>(mUserData);
- bool embedded = util->mInfo.isEmbedded();
-
- connect(serviceIpc, SIGNAL(error(int)), this, SLOT(clientError(int)));
- connect(serviceIpc, SIGNAL(readyRead()), this, SLOT(readyRead()));
- XQSERVICE_DEBUG_PRINT("\tembedded: %d", embedded);
- if (embedded) {
- quint64 processId=0;
- // Embedded server launch.
- // Server executable is always started with common name.
- // The server has to add the it's process ID to server names when creating Symbian server names to
- // be connected to. That's how client and server can establish unique connection.
- //
- bool ret = serviceIpc->startServer(serverName,"", processId, ServiceFwIPC::EStartInEmbeddedMode);
- XQSERVICE_DEBUG_PRINT("ret: %d", ret);
- if (ret && (processId > 0)) {
- //
- // Start application in embedded mode. Add process ID to server name to make
- // server connection unique.
- serverName = serverName + "." + QString::number(processId);
- XQSERVICE_DEBUG_PRINT("Try connect to embedded service: %s", qPrintable(serverName));
- retryCount = 0;
- while (!serviceIpc->connect(serverName) && retryCount < retryToServerMax) {
- XQSERVICE_DEBUG_PRINT("retryCount: %d", retryCount+1);
- ++retryCount;
- wait(200);
- }
- if (retryCount == retryToServerMax) {
- XQSERVICE_DEBUG_PRINT("Couldn't connect to embedded server");
- XQService::serviceThreadData()->setLatestError(ServiceFwIPC::EConnectionError); // Set error also
- processId = 0;
- }
- }
- if (!processId) {
- XQSERVICE_WARNING_PRINT("Could not connect to embedded service %s", qPrintable(serverName));
- delete serviceIpc;
- serviceIpc = NULL;
- return false;
- }
- XQSERVICE_DEBUG_PRINT("Embedded connection created");
- }
- else {
- // Not embedded
- XQSERVICE_DEBUG_PRINT("Use existing serviceIpc:mIpcConName=%s, serverName=%s",
- qPrintable(mIpcConName), qPrintable(serverName));
- if (!serviceIpc->connect(serverName)) {
- XQSERVICE_DEBUG_PRINT("Trying to start server %s", qPrintable(serverName));
- quint64 processId=0;
- bool ret=serviceIpc->startServer(serverName,"",processId);
- XQSERVICE_DEBUG_PRINT("starServer ret=%d", ret);
- if (ret && (processId > 0)) {
- retryCount = 0;
- while (!serviceIpc->connect(serverName) && retryCount < retryToServerMax) {
- XQSERVICE_DEBUG_PRINT("retryCount: %d", retryCount+1);
- ++retryCount;
- wait(200);
- }
- if (retryCount == retryToServerMax) {
- XQSERVICE_DEBUG_PRINT("Couldn't connect to server");
- XQService::serviceThreadData()->setLatestError(ServiceFwIPC::EConnectionError); // Set error also
- processId = 0;
- }
- }
- if (!processId) {
- XQSERVICE_WARNING_PRINT("Could not connect to the service %s", qPrintable(serverName));
- delete serviceIpc;
- serviceIpc = NULL;
- return false;
- }
- }
- XQSERVICE_DEBUG_PRINT("Connection created");
- }
- }
- return true;
-}
-
-bool XQServiceIpcClient::handleRequest( ServiceIPCRequest *aRequest )
-{
- XQSERVICE_DEBUG_PRINT("XQServiceIpcClient::handleRequest,isServer?=%d", server);
- XQService::serviceThreadData()->setLatestError(KErrNone);
- bool result(true);
- int index = setCurrentRequest(aRequest);
- XQSERVICE_DEBUG_PRINT("index: %d", index);
- const QString oper = aRequest->getOperation();
- XQSERVICE_DEBUG_PRINT("oper: %s", qPrintable(oper));
- const QByteArray packet=aRequest->getData();
- const char *startPtr = packet.constData();
- XQSERVICE_DEBUG_PRINT("packet: %s", packet.constData());
-
-
- // We have a full packet to be processed. Parse the command
- // and the channel name, but nothing else just yet.
- XQServicePacketHeader *header = (XQServicePacketHeader *)startPtr;
- int command = header->command;
- XQSERVICE_DEBUG_PRINT("command: %d", command);
- QString channel;
- const char *ptr = startPtr + sizeof(XQServicePacketHeader);
- if (header->chLength > 0) {
- channel = QString::fromUtf16
- ((const ushort *)ptr, header->chLength);
- ptr += header->chLength * 2;
- }
- XQSERVICE_DEBUG_PRINT("channel: %s", qPrintable(channel));
- // Parse the rest of the packet now that we know we need it.
- QString msg;
- QByteArray data;
- if (header->msgLength > 0) {
- msg = QString::fromUtf16
- ((const ushort *)ptr, header->msgLength);
- ptr += header->msgLength * 2;
- }
- XQSERVICE_DEBUG_PRINT("msg: %s", qPrintable(msg));
- if (header->dataLength > 0) {
- data = QByteArray ((const char *)ptr, header->dataLength);
- ptr += header->dataLength;
- }
- XQSERVICE_DEBUG_PRINT("data: %s", data.constData());
- QVariant ret;
- // Processing command on server side.
- if (command == XQServiceCmd_Send) {
- //Only support 1 sharable file, so index is 0
- ret=XQServiceChannel::sendLocally(channel, msg, data, aRequest->sharableFile(0) );
- }
- else if (command == XQServiceCmd_ReturnValueDelivered) {
- XQServiceChannel::sendCommand(channel,XQServiceChannel::ReturnValueDelivered);
- }
-
- if (XQService::serviceThreadData()->latestError() ||
- !aRequest->isAsync()) {
- ret=completeRequest(index,ret);
- }
- XQSERVICE_DEBUG_PRINT("ret: %d", result);
- return result;
-}
-
-/*!
- * From MServiceIPCObserver
- * \see MServiceIPCObserver::handleCancelRequest( ServiceIPCRequest *aRequest )
- */
-void XQServiceIpcClient::handleCancelRequest(ServiceIPCRequest* aRequest)
-{
- XQSERVICE_DEBUG_PRINT("XQServiceIpcClient::handleCancelRequest isServer?=%d", server);
- if (server)
- {
- // Save the request to be cancelled if service provider wants to as
- // XQRequestInfo for details
- // Valid only upon sendCommand call
- cancelledRequest = aRequest;
-
- //Attention! At the moment in server side channel name and connection name are the same
- // it might be that in the future will be different then this is not valid anymore.
- XQServiceChannel::sendCommand(mIpcConName,XQServiceChannel::ClientDisconnected);
-
- // Remember to reset immediatelly
- cancelledRequest = 0;
-
- cancelRequest(aRequest);
- }
-}
-
-/*
-* From MServiceIPCObserver
-* \see MServiceIPCObserver::handleDeleteRequest( ServiceIPCRequest *aRequest )
-*/
-void XQServiceIpcClient::handleDeleteRequest(ServiceIPCRequest* aRequest)
-{
- XQSERVICE_DEBUG_PRINT("XQServiceIpcClient::handleDeleteRequest isServer?=%d, reqId=", server);
- if (server)
- {
- cancelRequest(aRequest);
- }
-}
-
-bool XQServiceIpcClient::cancelRequest(ServiceIPCRequest* aRequest) {
- bool ret(false);
-
- if (aRequest == NULL)
- return ret;
-
- if (server) {
- XQSERVICE_DEBUG_PRINT("XQServiceIpcClient::cancelRequest, isServer?=%d, reqId=%d", server, aRequest->id());
- if (requestsMap.contains(aRequest->id())) {
- requestsMap.take(aRequest->id()); // Use "take" not to delete the request !!
- ret = true;
- } else {
- ret = false;
- }
- XQSERVICE_DEBUG_PRINT("XQServiceIpcClient::cancelRequest, ret=%d", ret);
- }
- return ret;
-}
-
-bool XQServiceIpcClient::sendChannelCommand(int cmd, const QString& ch)
-{
- XQSERVICE_DEBUG_PRINT("XQServiceIpcClient::sendChannelCommand, isServer?=%d", server);
- XQSERVICE_DEBUG_PRINT("cmd: %d, ch: %s", cmd, qPrintable(ch));
- if (!connectToServer()){
- XQSERVICE_DEBUG_PRINT("Couldn't connect to the server");
- return false;
- }
- int len = ch.length() * 2 + sizeof(XQServicePacketHeader);
- XQSERVICE_DEBUG_PRINT("cmd: %d", len);
- int writelen;
- char *buf;
- bool freeBuf = false;
- if (len <= minPacketSize) {
- buf = outBuffer;
- memset(buf + len, 0, minPacketSize - len);
- writelen = minPacketSize;
- } else {
- buf = new char [len];
- writelen = len;
- freeBuf = true;
- }
- XQSERVICE_DEBUG_PRINT("writelen: %d", writelen);
- XQServicePacketHeader *header = (XQServicePacketHeader *)buf;
- header->command = cmd;
- header->totalLength = len;
- header->chLength = ch.length();
- header->msgLength = 0;
- header->dataLength = 0;
- char *ptr = buf + sizeof(XQServicePacketHeader);
- memcpy(ptr, ch.constData(), ch.length() * 2);
- QByteArray sndBuf(buf,writelen);
- XQSERVICE_DEBUG_PRINT("sndBuf: %s", sndBuf.constData());
-
- bool ret = serviceIpc->sendSync("sendChannelCommand",sndBuf);
-
- if (freeBuf)
- delete[] buf;
-
- XQSERVICE_DEBUG_PRINT("XQServiceIpcClient::sendChannelCommand: ret=%d", ret);
- return ret;
-}
-
-bool XQServiceIpcClient::send(const QString& ch,
- const QString& msg,
- const QByteArray& data,
- QByteArray &retData,
- int cmd)
-{
- XQSERVICE_DEBUG_PRINT("XQServiceIpcClient::send, isServer?=%d", server);
-
- // Attension. The 'ch' name may contain unique session identifier to separate requests going
- // the same channel. Before real IPC calls need to get the normalized channel name.
- // The 'mIpcConName' contains the same session identifier to separate connections using the same
- // channel name.
- QString channel = XQRequestUtil::channelName(ch);
-
- XQSERVICE_DEBUG_PRINT("\tchannel: %s, msg: %s", qPrintable(channel), qPrintable(msg));
- XQSERVICE_DEBUG_PRINT("\tdata: %s, cmd: %d", data.constData(), cmd);
-
- XQService::serviceThreadData()->setLatestError(KErrNone);
- if (!connectToServer()){
- XQSERVICE_DEBUG_PRINT("\tCouldn't connect to the server");
- return false;
- }
-
-#ifdef QT_S60_AIW_PLUGIN
- if (plugin) {
- QVariant ret=XQServiceChannel::sendLocally(channel, msg, data);
- retData = XQServiceThreadData::serializeRetData(ret, XQService::serviceThreadData()->latestError());
- return true;
- }
-#endif
- int len = channel.length() * 2 + msg.length() * 2 + data.length();
- len += sizeof(XQServicePacketHeader);
- XQSERVICE_DEBUG_PRINT("\tcmd: %d", len);
- int writelen;
- char *buf;
- bool freeBuf = false;
- if (len <= minPacketSize) {
- buf = outBuffer;
- memset(buf + len, 0, minPacketSize - len);
- writelen = minPacketSize;
- } else {
- buf = new char [len];
- writelen = len;
- freeBuf = true;
- }
- XQSERVICE_DEBUG_PRINT("\twritelen: %d", writelen);
- XQServicePacketHeader *header = (XQServicePacketHeader *)buf;
- header->command = cmd;
- header->totalLength = len;
- header->chLength = channel.length();
- header->msgLength = msg.length();
- header->dataLength = data.length();
- char *ptr = buf + sizeof(XQServicePacketHeader);
- memcpy(ptr, channel.constData(), channel.length() * 2);
- ptr += channel.length() * 2;
- memcpy(ptr, msg.constData(), msg.length() * 2);
- ptr += msg.length() * 2;
- memcpy(ptr, data.constData(), data.length());
- QByteArray sndBuf(buf,writelen);
- XQSERVICE_DEBUG_PRINT("\tsndBuf: %s", sndBuf.constData());
- bool ret = true;
- XQSERVICE_DEBUG_PRINT("\tsynchronous: %d", synchronous);
-
- if (synchronous) {
-
- ret=serviceIpc->sendSync("send",sndBuf);
- if (ret) {
- retData=serviceIpc->readAll();
- XQSERVICE_DEBUG_PRINT("\t readAll done, error=%d", XQService::serviceThreadData()->latestError());
- if (!XQService::serviceThreadData()->latestError())
- {
- // No point to send channel command on error. Error could be also
- // caused by server exit without completing the actual request
- sendChannelCommand(XQServiceCmd_ReturnValueDelivered,channel);
- }
- else
- ret = false;
- }
- }
- else {
- // At the moment we can not have multiple send async
- if (serviceIpc->requestPending()) {
- XQSERVICE_DEBUG_PRINT("Request already pending");
- XQService::serviceThreadData()->setLatestError(ServiceFwIPC::ERequestPending); // maparnan
- ret = false ;
- }
- else {
- serviceIpc->sendAsync("send",sndBuf);
- ret = true;
- }
- }
- if (freeBuf)
- delete[] buf;
- XQSERVICE_DEBUG_PRINT("\tret: %d", ret);
- return ret;
-}
-
-
-/*!
- * This method cancels requests.
- */
-bool XQServiceIpcClient::cancelPendingSend(const QString& ch)
-{
- Q_UNUSED(ch); //
- XQSERVICE_DEBUG_PRINT("XQServiceIpcClient::cancelPendingSend, isServer?=%d", server);
- if (serviceIpc) {
- // Close the client connection silently
- disconnect(serviceIpc, SIGNAL(error(int)), this, SLOT(clientError(int)));
- XQService::serviceThreadData()->closeClientConnection(mIpcConName);
- // No callback wanted any more
- callBackRequestComplete = NULL;
- }
-
- return true;
-}
-
-void XQServiceIpcClient::disconnected()
-{
- XQSERVICE_DEBUG_PRINT("XQServiceIpcClient::disconnected START");
- XQSERVICE_DEBUG_PRINT("\t server: %d, lastId=%d", server, lastId);
- if (server) {
- // Closing down IPC
- ServiceIPCRequest* request = NULL;
-
- //
- // Go through all requests and send disconnected error to them
- //
- QHashIterator<int, ServiceIPCRequest*> iter(requestsMap);
- while (iter.hasNext()) {
- iter.next();
- int reqId = iter.key();
- request=iter.value();
- XQSERVICE_DEBUG_PRINT("\t request iter: id=%d", reqId);
- XQSERVICE_DEBUG_PRINT("\t request iter requestAsync=%d", request->isAsync());
- if (request->isAsync()) {
- QVariant ret;
- // Consider server side end as connection closure.
- XQService::serviceThreadData()->setLatestError(ServiceFwIPC::EConnectionClosed);
- completeRequest(reqId, ret);
- // In disconnnect phase let's wait a bit in order to be sure
- // That completeRequest and application exit notification event goes in the client side
- wait(200);
- }
- }
- if (serviceIpcServer) {
- serviceIpcServer->disconnect();
- delete serviceIpcServer;
- serviceIpcServer = NULL;
- XQSERVICE_DEBUG_PRINT("\tXQServiceIpcClient deleteLater");
- wait(200);
- XQSERVICE_DEBUG_PRINT("\tXQServiceIpcClient deleteLater over");
- }
- } else {
- if (sendSyncLoop && sendSyncLoop->isRunning()) {
- XQSERVICE_DEBUG_PRINT("Quit sendSyncLoop");
- sendSyncLoop->quit();
- }
- if (serviceIpc) {
- XQSERVICE_DEBUG_PRINT("Disconnect serviceIpc");
- serviceIpc->disconnect();
- delete serviceIpc;
- serviceIpc = NULL;
- }
- }
- deleteLater();
- XQSERVICE_DEBUG_PRINT("XQServiceIpcClient::disconnected END");
-}
-
-void XQServiceIpcClient::clientError(int error)
-{
- XQSERVICE_DEBUG_PRINT("XQServiceIpcClient::clientError, isServer?=%d", server);
- XQSERVICE_DEBUG_PRINT("error: %d", error);
-
-
- if (serviceIpc) {
- XQService::serviceThreadData()->setLatestError(error);
- disconnect(serviceIpc, SIGNAL(error(int)), this, SLOT(clientError(int)));
- //disconnected();
- XQService::serviceThreadData()->closeClientConnection(mIpcConName);
- }
-
- //complete the client request with error value
- if (callBackRequestComplete) {
- XQSERVICE_DEBUG_PRINT("requestErrorAsync mapped error=%d", error);
- callBackRequestComplete->requestErrorAsync(error);
- }
- XQSERVICE_DEBUG_PRINT("clientError end mapped error=%d", error);
-}
-
-/**
-* Async read operation
-*/
-
-void XQServiceIpcClient::readyRead()
-{
- XQSERVICE_DEBUG_PRINT("XQServiceIpcClient::readyRead, isServer?=%d", server);
-
- // Clear error
- XQService::serviceThreadData()->setLatestError(KErrNone);
-
- //in case it has been connected before
- //this prevents calling twice of the callback functions
- disconnect(serviceIpc, SIGNAL(ReadDone()), this, SLOT(readDone()));
- connect(serviceIpc, SIGNAL(ReadDone()), this, SLOT(readDone()));
- serviceIpc->readAll( iRetData );
-}
-
-
-/**
-* readDone, send return value back to client
-*/
-void XQServiceIpcClient::readDone()
- {
- XQSERVICE_DEBUG_PRINT("XQServiceIpcClient::readDone");
- QVariant retValue = XQServiceThreadData::deserializeRetData(iRetData);
-
-#ifdef XQSERVICE_DEBUG
- QString s = retValue.toString();
- int len=s.length();
- XQSERVICE_DEBUG_PRINT("retValue: type=%s,len=%d,value(max.1024)=%s",
- retValue.typeName(),len,qPrintable(s.left(1024)));
-#endif
- int err = XQService::serviceThreadData()->latestError();
- XQSERVICE_DEBUG_PRINT("err: %d", err);
-
- if (err)
- {
- XQSERVICE_DEBUG_PRINT("there is error!");
- //emitError(err);
- clientError(err);
- }
- else if (iRetData.length())
- {
- XQSERVICE_DEBUG_PRINT("there is return data");
- if (callBackRequestComplete &&
-// !retValue.isNull() && (retValue.type() != QVariant::Invalid)) maparnan
- retValue.isValid())
- {
- XQSERVICE_DEBUG_PRINT("before compelete async request");
-
- //should this send before compete the request ?
- //Attention ! Map mIpcConName name may contain unique identifier to separate connections using the same
- // channel name. So need to get channel name.
- QString channel = XQRequestUtil::channelName(mIpcConName);
- sendChannelCommand(XQServiceCmd_ReturnValueDelivered, channel);
-
- callBackRequestComplete->requestCompletedAsync( retValue );
- XQSERVICE_DEBUG_PRINT("After complete async request");
- }
- else
- {
- clientError( KErrUnknown );
- }
- //attention at the moment channel name and connection name are the same
- // it might be that in the future will be different then this is not valid anymore.
- //sendChannelCommand(XQServiceCmd_ReturnValueDelivered,mIpcConName);
- }
- else
- {
- //err is KErrNone but no return value
- //reading failed
- clientError( KErrUnknown );
- }
- }
-
-
-int XQServiceIpcClient::setCurrentRequest(ServiceIPCRequest* request)
-{
- XQSERVICE_DEBUG_PRINT("XQServiceIpcClient::setCurrentRequest START");
- XQSERVICE_DEBUG_PRINT("\t isServer=%d", server);
- int id = -1;
- if (request) {
- lastId = lastId + 1;
- XQSERVICE_DEBUG_PRINT("\t new id=%d assigned to current request", lastId);
- request->setAsync(false);
- request->setId(lastId);
- requestsMap.insert(lastId, request);
- id = lastId;
- } else {
- XQSERVICE_DEBUG_PRINT("\t request was NULL");
- }
- XQSERVICE_DEBUG_PRINT("\t returning id=%d", id);
- XQSERVICE_DEBUG_PRINT("XQServiceIpcClient::setCurrentRequest END");
- return id;
-}
-
-//
-// This function need to be called during a slot call before returning from
-// the slot.
-// The lastId might change after returning from the slot call as
-// other possible requests may arrive
-//
-int XQServiceIpcClient::setCurrentRequestAsync()
-{
- XQSERVICE_DEBUG_PRINT("XQServiceIpcClient::setCurrentRequestAsync");
- XQSERVICE_DEBUG_PRINT("\t isServer=%d", server);
- ServiceIPCRequest* request = requestPtr(lastId);
- int id = -1;
-
- if (request) {
- request->setAsync(true);
- id = request->id();
- }
-
- XQSERVICE_DEBUG_PRINT("\t returning request's id=%d", id);
- return id;
-}
-
-bool XQServiceIpcClient::completeRequest(int index, const QVariant& retValue)
-{
- XQSERVICE_DEBUG_PRINT("XQServiceIpcClient::completeRequest START");
- XQSERVICE_DEBUG_PRINT("\t isServer=%d", server);
- XQSERVICE_DEBUG_PRINT("\t index=%d", index);
-#ifdef XQSERVICE_DEBUG
- QString s = retValue.toString();
- int len=s.length();
- XQSERVICE_DEBUG_PRINT("retValue: type=%s,len=%d,value(max.1024)=%s",
- retValue.typeName(),len,qPrintable(s.left(1024)));
-#endif
-
- ServiceIPCRequest* request = requestPtr(index);
- if (!request){
- XQSERVICE_DEBUG_PRINT("\t request = NULL");
- XQSERVICE_DEBUG_PRINT("\t return false");
- XQSERVICE_DEBUG_PRINT("XQServiceIpcClient::completeRequest END (1)");
- return false;
- }
-#ifdef QT_S60_AIW_PLUGIN
- if (plugin) {
- if (callBackRequestComplete &&
- !retValue.isNull() && (retValue.type() != QVariant::Invalid))
- {
- callBackRequestComplete->requestCompletedAsync(retValue);
- }
- XQSERVICE_DEBUG_PRINT("\t return true");
- XQSERVICE_DEBUG_PRINT("XQServiceIpcClient::completeRequest END (2)");
- return true;
- }
-#endif
- QByteArray array = XQServiceThreadData::serializeRetData(retValue,
- XQService::serviceThreadData()->latestError() );
- XQSERVICE_DEBUG_PRINT("\t array: %s", array.constData());
- XQService::serviceThreadData()->setLatestError(KErrNone);
- request->write(array);
- bool ret = request->completeRequest();
- // cancelRequest(request);
- XQSERVICE_DEBUG_PRINT("\t return %d", ret);
- XQSERVICE_DEBUG_PRINT("XQServiceIpcClient::completeRequest END (3)");
- return ret;
-}
-
-
-//
-// This function need to be called during a slot call before returning from
-// the slot.
-// The lastId might change after returning from the slot call as
-// other possible requests may arrive
-//
-XQRequestInfo XQServiceIpcClient::requestInfo() const
-{
- XQSERVICE_DEBUG_PRINT("XQServiceIpcClient::requestInfo");
- XQSERVICE_DEBUG_PRINT("\t isServer=%d", server);
- ServiceIPCRequest* request = requestPtr(lastId);
-
- if (request) {
- return request->requestInfo();
- }
- return XQRequestInfo();
-}
-
-//
-// This internal function need to be called before a slot call to set the request info
-// The provider can then call requestInfo() to get the data.
-// The lastId might change after returning from the slot call as
-// other possible requests may arrive
-//
-bool XQServiceIpcClient::setRequestInfo(XQRequestInfo &info)
-{
- XQSERVICE_DEBUG_PRINT("XQServiceIpcClient::setRequestInfo");
- XQSERVICE_DEBUG_PRINT("\t isServer=%d", server);
- ServiceIPCRequest* request = requestPtr(lastId);
-
- if (request) {
- request->setRequestInfo(&info);
- }
- return request != NULL;
-}
-
-
-// in disconnnect phase let's wait a bit in order to be sure
-// that completeRequest and application exit notification event goes in the client side
-void XQServiceIpcClient::wait(int msec)
-{
- XQSERVICE_DEBUG_PRINT("XQServiceIpcClient::wait, isServer?=%d", server);
-
- if (server)
- return;
-
- User::After(1000 * msec); //Contribution from Seppo
-
- /*
- if (!QCoreApplication::instance())
- {
- User::After(1000 * msec); //Contribution from Seppo
- return;
- }
-
- QTime t1 = QTime::currentTime();
- QEventLoop w = QEventLoop();
- XQSERVICE_DEBUG_PRINT("XQServiceIpcClient::wait start");
- QTimer::singleShot(msec, &w, SLOT(quit()));
- w.exec();
- QTime t2 = QTime::currentTime();
- XQSERVICE_DEBUG_PRINT("XQServiceIpcClient::wait end elapsed=%d", t1.msecsTo(t2));
- */
-}
-
-//
-// Returns the handle of the current request
-//
-ServiceIPCRequest *XQServiceIpcClient::requestPtr(int index) const
-{
- ServiceIPCRequest* request = NULL;
-
- // If request is being cancelled (saved by handleCancelRequest()) use it's id instead
- // By that way service provider can access the XQRequestInfo of the cancelled request
- // Upon handling clientDisconnected
- if (cancelledRequest)
- {
- index = cancelledRequest->id();
- XQSERVICE_DEBUG_PRINT("\t Cancelled request id=%d", index);
- }
-
- if (requestsMap.contains(index)) {
- XQSERVICE_DEBUG_PRINT("\t request having id=%d FOUND", index);
- request = requestsMap[index];
- } else {
- XQSERVICE_DEBUG_PRINT("\t request having id=%d NOT FOUND", index);
- }
-
- return request;
-
-}