diff -r 885c2596c964 -r 5d007b20cfd0 qthighway/xqserviceipc/xqserviceipcserver/xqserviceipcserver_apasymbiansession.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/qthighway/xqserviceipc/xqserviceipcserver/xqserviceipcserver_apasymbiansession.cpp Tue Aug 31 16:02:37 2010 +0300 @@ -0,0 +1,313 @@ +/* +* Copyright (c) 2008 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: Service IPC Session +* +*/ + +#include "xqservicelog.h" + +#include +#include "xqserviceipcobserver.h" +#include "xqserviceipcrequest.h" +#include "xqserviceipcserver_apasymbiansession.h" +#include "xqrequestutil.h" + +namespace QtService +{ + +// Constants for the IPC operation id +const TInt KIPCOperation = RApaAppServiceBase::KServiceCmdBase; +const TInt KIPCGetBuffer = KIPCOperation+1; +const TInt KIPCOperationWithSharableFile = KIPCOperation+2; // Sharable file support + + +/*! + \class CApaServerSymbianSession + \brief Symbian Session class +*/ + +/*! + Constructor. + \param aObserver Observer to the server. +*/ +CApaServerSymbianSession::CApaServerSymbianSession(MServiceIPCObserver* aObserver) : + ServiceIPCSession(aObserver) +{ + XQSERVICE_DEBUG_PRINT("CApaServerSymbianSession::CApaServerSymbianSession"); +} + +/*! + 2nd phased constructor. +*/ +void CApaServerSymbianSession::ConstructL() +{ +} + +/*! + Two-Phased Constructor. + \param aObserver Observer to the server. +*/ +CApaServerSymbianSession* CApaServerSymbianSession::NewL(MServiceIPCObserver* aObserver) +{ + XQSERVICE_DEBUG_PRINT("CApaServerSymbianSession::NewL"); + CApaServerSymbianSession* self = + new( ELeave ) CApaServerSymbianSession(aObserver); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; +} + +/*! + Destructor. +*/ +CApaServerSymbianSession::~CApaServerSymbianSession() +{ + XQSERVICE_DEBUG_PRINT("CApaServerSymbianSession::~CApaServerSymbianSession"); + if (iCurRequest) { + iObserver->handleDeleteRequest(iCurRequest); + delete iCurRequest; + } + iCurRequest = NULL; +} + +/*! + Write some data in response to a request. + \param aData Some data to write as response. + \return bool If write was successful. +*/ +bool CApaServerSymbianSession::write( const QByteArray& aData ) +{ + XQSERVICE_DEBUG_PRINT("CApaServerSymbianSession::write"); + XQSERVICE_DEBUG_PRINT("aData: %s,length=%d", aData.constData(), aData.length()); + // Implicitly shared + iData = aData; + return false; +} + +/*! + Complete a request. + \return true if request completed +*/ +bool CApaServerSymbianSession::completeRequest() +{ + XQSERVICE_DEBUG_PRINT("CApaServerSymbianSession::completeRequest"); + TPtrC8 data(reinterpret_cast (iData.constData()), iData.length()); + XQSERVICE_DEBUG_PRINT("data: %s, length=%d", iData.constData(), data.Length() ); + iMessage.Complete(data.Length()); + if (iCurRequest) { + iObserver->handleDeleteRequest(iCurRequest); + delete iCurRequest; + } + iCurRequest = NULL; + return true; +} + +/*! + Close a session and gracefully shutdown. +*/ +void CApaServerSymbianSession::close() +{ + XQSERVICE_DEBUG_PRINT("CApaServerSymbianSession::close"); + // Symbian doens't really do anything +} + +/*! + From CSession2. Service request. + \param aMessage Message object. +*/ +void CApaServerSymbianSession::ServiceL(const RMessage2& aMessage) +{ + XQSERVICE_DEBUG_PRINT("CApaServerSymbianSession::ServiceL"); + // Default ServiceErrorL() will complete the message if this method leaves + TInt operation(aMessage.Function()); + XQSERVICE_DEBUG_PRINT("\toperation: %d", operation); + switch (operation) { + case KIPCOperation: + case KIPCOperationWithSharableFile: + { + + XQSERVICE_DEBUG_PRINT("CApaServerSymbianSession::ServiceL handleRequest"); + handleRequestL(aMessage); + XQSERVICE_DEBUG_PRINT("CApaServerSymbianSession::ServiceL handleRequest end"); + //and here + break; + } + case KIPCGetBuffer: { + XQSERVICE_DEBUG_PRINT("CApaServerSymbianSession::ServiceL handleGetBufferL"); + handleGetBufferL(aMessage); + XQSERVICE_DEBUG_PRINT("CApaServerSymbianSession::ServiceL handleGetBufferL end"); + break; + } + + default: { + XQSERVICE_DEBUG_PRINT("CApaServerSymbianSession::ServiceL default"); + if (operation == 2 && iCurRequest) // maparnan + { + // Need to complete the pending request when handling the + // the EApaAppServerCancelNotifyServerExit (2) from the client + // It is too late to complete that in session disconnect + XQSERVICE_DEBUG_PRINT("CApaServerSymbianSession::ServiceL request cancelled"); + iMessage.Complete(KErrCancel); + } + + CApaAppServiceBase::ServiceL( aMessage ); + //aMessage.Complete(KErrNotFound); + XQSERVICE_DEBUG_PRINT("CApaServerSymbianSession::ServiceL default end"); + break; + } + } +} + +/*! + From CSession2. + Handle any disconnection from the client. + \param aMessage Message Object. +*/ +void CApaServerSymbianSession::Disconnect(const RMessage2 &aMessage) +{ + XQSERVICE_DEBUG_PRINT("CApaServerSymbianSession::Disconnect"); + if (iCurRequest) { + // Inform also observer, that current pending request is about to go + iObserver->handleCancelRequest(iCurRequest); + } + CApaAppServiceBase::Disconnect(aMessage); +} + +/*! + Handle an IPC request. + \param aMessage Message Object. +*/ +void CApaServerSymbianSession::handleRequestL( const RMessage2& aMessage ) +{ + XQSERVICE_DEBUG_PRINT("CApaServerSymbianSession::handleRequestL"); + // Store the message + iMessage = aMessage; + + // Convert from Symbian to QT + HBufC* request = ReadDesLC(aMessage, 0); + HBufC8* data = ReadDes8LC(aMessage, 1); + + XQSharableFile *file = 0; + if (aMessage.Function() == KIPCOperationWithSharableFile) + { + // Only one file support now ! + file = new XQSharableFile(); + AdoptSharableFile(aMessage, file); + } + + // Shallow copy only, we want a deep copy + QString d = QString::fromUtf16(request->Ptr(), request->Length()); + QString operation; + operation += d; + XQSERVICE_DEBUG_PRINT("operation: %s", qPrintable(operation)); + + /* + //QByteArray convertData; + TPtr8 ptr8(data->Des()); + const char* ptrz = reinterpret_cast (ptr8.PtrZ()); + //convertData.append(ptrz); + QByteArray convertData(ptrz,data->Length()); + */ + QByteArray convertData( reinterpret_cast(data->Ptr()), data->Length() ); + XQSERVICE_DEBUG_PRINT("convertData: %s", convertData.constData()); + + // New request + Q_ASSERT(!iCurRequest); + iCurRequest = new ServiceIPCRequest(this, 0, operation); + iData.clear(); + + // Get client info + ClientInfo *client = new ClientInfo(); + client->setProcessId(aMessage.SecureId().iId); + client->setVendorId(aMessage.VendorId().iId); + RThread clientThread; + aMessage.ClientL(clientThread); + RProcess clientProc; + User::LeaveIfError( clientThread.Process(clientProc) ); + client->setName(QString::fromUtf16(clientProc.Name().Ptr(), + clientProc.Name().Length())); + client->setCapabilities(ClientCapabilities(aMessage)); + clientThread.Close(); // close handle + + // Set the picked sharable file if any + if (file != 0) + { + // Support only one sharable file + iCurRequest->addSharableFile(file, 0); + } + + // + // Add data and callback to the observer + // + iCurRequest->addRequestdata(convertData); + iCurRequest->setClientInfo(client); // ownership passed + iObserver->handleRequest(iCurRequest); + + CleanupStack::PopAndDestroy(2, request); +} + +/*! + Handle getting the result buffer. + \param aMessage Message Object. +*/ +void CApaServerSymbianSession::handleGetBufferL( const RMessage2& aMessage ) +{ + XQSERVICE_DEBUG_PRINT("CApaServerSymbianSession::handleGetBufferL"); + XQSERVICE_DEBUG_PRINT("iData: %s", iData.constData()); + TPtrC8 data(reinterpret_cast (iData.constData()), iData.length()); + TInt err = aMessage.Write(0, data); + aMessage.Complete(err); + } + +/*! + Read a 16 bit descriptor from the message. + \param aMessage Message to read from. + \param aMsgSlot Slot to read from. +*/ +HBufC* CApaServerSymbianSession::ReadDesLC(const RMessage2& aMessage, + TInt aMsgSlot) +{ + XQSERVICE_DEBUG_PRINT("CApaServerSymbianSession::ReadDesLC"); + TInt length = aMessage.GetDesLengthL(aMsgSlot); + HBufC* des = HBufC::NewLC(length); + TPtr ptr = des->Des(); + aMessage.ReadL(aMsgSlot, ptr); + return des; +} + +/*! + Read a 8 bit descriptor from the message. + \param aMessage Message to read from. + \param aMsgSlot Slot to read from. + */ +HBufC8* CApaServerSymbianSession::ReadDes8LC(const RMessage2& aMessage, + TInt aMsgSlot) +{ + XQSERVICE_DEBUG_PRINT("CApaServerSymbianSession::ReadDes8LC"); + TInt length = aMessage.GetDesLengthL(aMsgSlot); + HBufC8* des = HBufC8::NewLC(length + 1); // 1 more for null terminator + TPtr8 ptr = des->Des(); + aMessage.ReadL(aMsgSlot, ptr); + return des; +} + +} + +// END OF FILE +