diff -r 000000000000 -r 4e1aa6a622a0 sensorservices/sensorserver/src/server/sensrvtransaction.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/sensorservices/sensorserver/src/server/sensrvtransaction.cpp Tue Feb 02 00:53:00 2010 +0200 @@ -0,0 +1,341 @@ +/* +* Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: Sensor server transaction base class +* +*/ + + +#include "sensrvdefines.h" +#include "sensrvclientserver.h" +#include "sensrvtransaction.h" +#include "sensrvpluginproxy.h" +#include "sensrvproxymanager.h" +#include "sensrvsession.h" +#include "senserverchannel.h" + +// --------------------------------------------------------- +// Two phase constructor +// --------------------------------------------------------- +// +CSensrvTransaction* CSensrvTransaction::NewL(CSensrvMessage* aMessage, + CSensrvPluginProxy* aProxy, + CSensrvChannel* aChannel, + TSensrvTransactionType aType) + { + CSensrvTransaction* self = NewLC(aMessage, + aProxy, + aChannel, + aType); + + CleanupStack::Pop(self); + + return self; + } + +// --------------------------------------------------------- +// Two phase constructor +// --------------------------------------------------------- +// +CSensrvTransaction* CSensrvTransaction::NewLC(CSensrvMessage* aMessage, + CSensrvPluginProxy* aProxy, + CSensrvChannel* aChannel, + TSensrvTransactionType aType) + { + COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvTransaction::NewLC(aMessage: 0x%x, , aProxy: 0x%x, aChannel.Id(): %d, aType: %d )" ), + aMessage, + aProxy ? aProxy->ImplementationUid().iUid : 0, + aChannel ? aChannel->Id() : 0, + aType ) ); + + CSensrvTransaction* self = new CSensrvTransaction(aMessage, + aProxy, + aChannel, + aType); + + // Message needs to be completed if construction failed. + if (!self) + { + if (aMessage) + { + aMessage->Complete(KErrNoMemory); + } + User::Leave(KErrNoMemory); + } + + CleanupStack::PushL( self ); + + COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvTransaction::NewLC - return 0x%x" ), self ) ); + + return self; + } + +// --------------------------------------------------------- +// C++ constructor +// --------------------------------------------------------- +// +CSensrvTransaction::CSensrvTransaction(CSensrvMessage* aMessage, + CSensrvPluginProxy* aProxy, + CSensrvChannel* aChannel, + TSensrvTransactionType aType) + : iMessage(aMessage), + iProxy(aProxy), + iChannel(aChannel), + iType(aType), + iState(ETransStateUninitialized), + iErrorCode(KErrNone) + { + } + +// --------------------------------------------------------- +// Destructor +// --------------------------------------------------------- +// +CSensrvTransaction::~CSensrvTransaction() + { + COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvTransaction::~CSensrvTransaction()" ) ) ); + + Complete(); + + // Not owned components: iProxy, iProxyManager, iChannel not deleted + + COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvTransaction::~CSensrvTransaction - return" ) ) ); + } + + +// --------------------------------------------------------- +// Completes the related message thus ending transaction. +// Message is completed with the iErrorCode value. +// --------------------------------------------------------- +// +void CSensrvTransaction::Complete() + { + COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvTransaction::Complete()" ) ) ); + + iState = ETransStateCompleted; + + if (iMessage) + { + COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvTransaction::Complete - Completing with code: %d" ), iErrorCode ) ); + iMessage->Complete(iErrorCode); + iMessage = NULL; + } + + COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvTransaction::Complete - return" ) ) ); + } + +// --------------------------------------------------------- +// Sets transaction state. +// --------------------------------------------------------- +// +void CSensrvTransaction::SetState(TSensrvTransactionState aState) + { + COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvTransaction::SetState(aState: %d)" ), aState ) ); + + // In debug mode, panic on invalid transitions to detect problems + __ASSERT_DEBUG( + IsMediatorType() + || ((iState == ETransStateUninitialized && aState == ETransStateQueued ) + || (iState == ETransStateQueued && (aState == ETransStateExecuting || aState == ETransStateCompleted) ) + || (iState == ETransStateExecuting && (aState == ETransStateHandledAtSsy || aState == ETransStateCompleted || aState == ETransStateNotifyFailed) ) + || (iState == ETransStateHandledAtSsy && aState == ETransStateCompleted || aState == ETransStateNotifyFailed) + || (iState == ETransStateNotifyFailed && (aState == ETransStateHandledAtSsy || aState == ETransStateCompleted)) + || (iState == ETransStateCompleted)), + User::Panic(KSensrvPanicCategory, ESensrvPanicInvalidTransactionState)); + + iState = aState; + } + +// --------------------------------------------------------- +// Sets data to be returned to client. +// Transaction type determines how aData is interpreted. +// --------------------------------------------------------- +// +TInt CSensrvTransaction::SetMessageData(TAny* aData) + { + COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvTransaction::SetMessageData " ) ) ); + TInt err(KErrNone); + + switch(iType) + { + case ETransTypeClientQueryChannels: + { + COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvTransaction::SetMessageData - ETransTypeClientQueryChannels" ) ) ); + + // Cast list from parameter + RSensrvChannelInfoList* list = static_cast(aData); + TInt count(0); + if( list ) + { + count = list->Count(); + COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvTransaction::SetMessageData - (aData: 0x%x)" ), aData ) ); + } + // Dump list channel list and count to message if there is space + if (iMessage) + { + TSensrvTIntPckgBuf pckg(count); + + TInt space = iMessage->GetDesMaxLength( KSensrvQueryChannelsCountSlot ); + + if ( space >= pckg.Length() ) + { + err = iMessage->Write( KSensrvQueryChannelsCountSlot, pckg ); + + if (err != KErrNone) + { + ERROR_TRACE( ( _L( "Sensor Server - CSensrvTransaction::SetMessageData - ERROR: Write to KSensrvQueryChannelsCountSlot failed: %d" ), err ) ); + } + } + else + { + ERROR_TRACE( ( _L( "Sensor Server - CSensrvTransaction::SetMessageData - ERROR: Not enough space to write to KSensrvQueryChannelsCountSlot" ) ) ); + // Do not use KErrOverflow here, as it is very unlikely + // and overflow already has specific meaning in this command. + err = KErrBadDescriptor; + } + + if (err == KErrNone) + { + if (count > 0) + { + space = iMessage->GetDesMaxLength( KSensrvQueryChannelsChannelInfoArraySlot ); + TInt arraySize = ( sizeof(TSensrvChannelInfo) ) * count; + + if ( space >= arraySize ) + { + TPtr8 arrayPtr( reinterpret_cast(&(*list)[0]), arraySize, arraySize ); + err = iMessage->Write( KSensrvQueryChannelsChannelInfoArraySlot, arrayPtr ); + + if (err != KErrNone) + { + ERROR_TRACE( ( _L( "Sensor Server - CSensrvTransaction::SetMessageData - ERROR: Write to KSensrvQueryChannelsChannelInfoArraySlot failed: %d" ), err ) ); + } + } + else + { + // Not enough space to write. Note that this is not really an error. + // Overflow will trigger requery with enough space allocated. + ERROR_TRACE( ( _L( "Sensor Server - CSensrvTransaction::SetMessageData - Not enough space to write channel array. Expecting requery with more space. Completing with KErrOverflow (-9)" ) ) ); + err = KErrOverflow; + } + } + } + } + else + { + ERROR_TRACE( ( _L( "Sensor Server - CSensrvTransaction::SetMessageData - ERROR: No message defined" ) ) ); + err = KErrBadHandle; + } + } + break; + + case ETransTypeOpenChannel: + { + COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvTransaction::SetMessageData - ETransTypeOpenChannel" ) ) ); + + if ( aData && iMessage ) + { + TChannelOpenMessageData* data = static_cast(aData); + TSensrvTIntPckgBuf pckg(data->iMaxBufferingCount); + + TInt space = iMessage->GetDesMaxLength( KSensrvOpenChannelBufferSizeSlot ); + + if ( space >= pckg.Length() ) + { + err = iMessage->Write( KSensrvOpenChannelBufferSizeSlot, pckg ); + + if (err != KErrNone) + { + ERROR_TRACE( ( _L( "Sensor Server - CSensrvTransaction::SetMessageData - ERROR: Write to KSensrvOpenChannelBufferSizeSlot failed: %d" ), err ) ); + } + } + else + { + ERROR_TRACE( ( _L( "Sensor Server - CSensrvTransaction::SetMessageData - ERROR: Not enough space to write to KSensrvOpenChannelBufferSizeSlot" ) ) ); + err = KErrBadDescriptor; + } + + TSensrvTIntPckgBuf pckg2(data->iDataItemSize); + + space = iMessage->GetDesMaxLength( KSensrvOpenChannelDataItemSizeSizeSlot ); + if ( space >= pckg2.Length() ) + { + err = iMessage->Write( KSensrvOpenChannelDataItemSizeSizeSlot, pckg2 ); + + if (err != KErrNone) + { + ERROR_TRACE( ( _L( "Sensor Server - CSensrvTransaction::SetMessageData - ERROR: Write to KSensrvOpenChannelDataItemSizeSizeSlot failed: %d" ), err ) ); + } + } + else + { + ERROR_TRACE( ( _L( "Sensor Server - CSensrvTransaction::SetMessageData - ERROR: Not enough space to write to KSensrvOpenChannelDataItemSizeSizeSlot" ) ) ); + err = KErrBadDescriptor; + } + + } + else + { + ERROR_TRACE( ( _L( "Sensor Server - CSensrvTransaction::SetMessageData - ERROR: No message defined" ) ) ); + err = KErrBadHandle; + } + } + break; + + // The other types of transactions have no return data, so use default: + default: + ERROR_TRACE( ( _L( "Sensor Server - CSensrvTransaction::SetMessageData - ERROR: Invalid iType: %d, no data set" ), iType ) ); + break; + } + + COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvTransaction::SetMessageData - return %d" ), err ) ); + + return err; + } + +// --------------------------------------------------------- +// Set error code of transaction. +// --------------------------------------------------------- +// +void CSensrvTransaction::SetErrorCode(TInt aErrorCode) + { + COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvTransaction::SetErrorCode(aErrorCode: %d)" ), aErrorCode ) ); + + iErrorCode = aErrorCode; + +#ifdef ERROR_TRACE_DEBUG + if ( iErrorCode != KErrNone ) + { + ERROR_TRACE( ( _L( "Sensor Server - CSensrvTransaction::SetErrorCode - Message error code set: %d" ), aErrorCode ) ); + } +#endif + + COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvTransaction::SetErrorCode - return" ) ) ); + } + +// --------------------------------------------------------- +// Extract message from transaction +// --------------------------------------------------------- +// +CSensrvMessage* CSensrvTransaction::ExtractMessage() + { + COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvTransaction::ExtractMessage()" ) ) ); + + CSensrvMessage* message = iMessage; + + iMessage = NULL; + + COMPONENT_TRACE( ( _L( "Sensor Server - CSensrvTransaction::ExtractMessage - return 0x%x" ), message ) ); + + return message; + }