diff -r 000000000000 -r d0791faffa3f mtpfws/mtpfw/dataproviders/dputility/src/cmtprequestprocessor.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/mtpfws/mtpfw/dataproviders/dputility/src/cmtprequestprocessor.cpp Tue Feb 02 01:11:40 2010 +0200 @@ -0,0 +1,399 @@ +// Copyright (c) 2006-2009 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: +// + +#include +#include +#include +#include +#include +#include + +#include "cmtprequestprocessor.h" +#include "cmtprequestchecker.h" + +const static TInt KNullBufferSize = 4096; +__FLOG_STMT(_LIT8(KComponent,"MTPRequestProcessor");) + +/** +Standard c++ constructor +@param aFramework The data provider framework +@param aConnection The connection from which the request comes +@param aElementCount Number of element in the request. +@param aElements The element info data. +@return a pointer to the created request processor object +*/ +EXPORT_C CMTPRequestProcessor::CMTPRequestProcessor( + MMTPDataProviderFramework& aFramework, + MMTPConnection& aConnection, + TInt aElementCount, + const TMTPRequestElementInfo* aElements) + :CActive(EPriorityStandard), + iFramework(aFramework), + iConnection(aConnection), + iElementCount(aElementCount), + iElements(aElements) + { + CActiveScheduler::Add(this); + __FLOG_OPEN(KMTPSubsystem, KComponent); + } + +/** +Destructor +*/ +EXPORT_C CMTPRequestProcessor::~CMTPRequestProcessor() + { + Cancel(); + iNullBuffer.Close(); + delete iRequestChecker; + __FLOG_CLOSE; + } + +/** +Relese (delete) this request processor +*/ +EXPORT_C void CMTPRequestProcessor::Release() + { + delete this; + } + +/** +Send a response to the initiator +@param aResponseCode The response code to send +@param aParamCount The number of parameters +@param aParmas The pointer to array of parameters +*/ +EXPORT_C void CMTPRequestProcessor::SendResponseL(TMTPResponseCode aResponseCode, TInt aParameterCount, TUint32* aParams) + { + __ASSERT_DEBUG(aParameterCount < TMTPTypeRequest::ENumElements, User::Invariant()); + + iResponse.SetUint16(TMTPTypeResponse::EResponseCode, aResponseCode); + + iResponse.SetUint32(TMTPTypeResponse::EResponseSessionID, iSessionId); + + iResponse.SetUint32(TMTPTypeResponse::EResponseTransactionID, iTransactionCode); + + TInt i = 0; + for(i = 0; i < aParameterCount; i++) + { + iResponse.SetUint32(TMTPTypeResponse::EResponseParameter1 + i, aParams[i]); + } + + i += TMTPTypeResponse::EResponseParameter1; + while(i <= TMTPTypeResponse::EResponseParameter5) + { + iResponse.SetUint32(i, KMTPNotSpecified32); + i++; + } + + __ASSERT_DEBUG(iRequest, User::Invariant()); + iFramework.SendResponseL(iResponse, *iRequest, iConnection); + } + +/** +The current active request +@return A reference to the current request +*/ +EXPORT_C const TMTPTypeRequest& CMTPRequestProcessor::Request() const + { + __ASSERT_DEBUG(iRequest, User::Invariant()); + return *iRequest; + } + +/** +The connection from which the current request comes +@return A reference to the current connection +*/ +EXPORT_C MMTPConnection& CMTPRequestProcessor::Connection() const + { + return iConnection; + } +/** +The Session ID from the current request +@return the value of the session ID + */ +EXPORT_C TUint32 CMTPRequestProcessor::SessionId() + { + return iSessionId; + } +/** +Signal to the framework that the current request transaction has completed +*/ +EXPORT_C void CMTPRequestProcessor::CompleteRequestL() + { + __ASSERT_DEBUG(iRequest, User::Invariant()); + iFramework.TransactionCompleteL(*iRequest, iConnection); + } + +/** +Send data to the initiator +@param aData The data to send +*/ +EXPORT_C void CMTPRequestProcessor::SendDataL(const MMTPType& aData) + { + __ASSERT_DEBUG(iRequest, User::Invariant()); + iFramework.SendDataL(aData, *iRequest, iConnection); + } + +/** +Receive data from the initiator +@param aData The data to receive +*/ +EXPORT_C void CMTPRequestProcessor::ReceiveDataL(MMTPType& aData) + { + __ASSERT_DEBUG(iRequest, User::Invariant()); + iFramework.ReceiveDataL(aData, *iRequest, iConnection); + } + +/** +Handle the request +@param aRequest The request to be processed +@param aPhase The current transaction phase of the request +@return ETrue if the transaction has completed, otherwise, EFalse +*/ +EXPORT_C TBool CMTPRequestProcessor::HandleRequestL(const TMTPTypeRequest& aRequest, TMTPTransactionPhase aPhase) + { + iRequest = &aRequest; + __ASSERT_DEBUG(iRequest, User::Invariant()); + TBool result = EFalse; + switch(aPhase) + { + case ERequestPhase: + ExtractSessionTransactionId(); + result = DoHandleRequestPhaseL(); + break; + case EDataIToRPhase: + result = DoHandleDataIToRPhaseL(); + break; + case EDataRToIPhase: + result = DoHandleRToIPhaseL(); + break; + case EResponsePhase: + if (iResponseCode != EMTPRespCodeOK && HasDataphase()) + { + SendResponseL(TMTPResponseCode(iResponseCode)); + iNullBuffer.Close(); + } + else + { + result = DoHandleResponsePhaseL(); + } + break; + + case ECompletingPhase: + result = DoHandleCompletingPhaseL(); + break; + } + return result; + } + +/** +Handle the event +@param aEvent The event to be processed +*/ +EXPORT_C void CMTPRequestProcessor::HandleEventL(const TMTPTypeEvent& aEvent) + { + TUint16 eventCode = aEvent.Uint16(TMTPTypeEvent::EEventCode); + iCancelled = (eventCode == EMTPEventCodeCancelTransaction); + } + +/** +Check whether the processor can process the request +@param aRequest The request to be processed +@param aConnection The connection from which the request comes +@return ETrue if the processor can process the request, otherwise EFalse +*/ +EXPORT_C TBool CMTPRequestProcessor::Match(const TMTPTypeRequest& aRequest, MMTPConnection& aConnection) const + { + __ASSERT_DEBUG(iRequest, User::Invariant()); + TBool result = ((&aRequest == iRequest) && (&iConnection == &aConnection)); + return result; + } + +/** +Check whether the processor can process the event +@param aEvent The event to be processed +@param aConnection The connection from which the request comes +@return ETrue if the processor can process the request, otherwise EFalse +*/ +EXPORT_C TBool CMTPRequestProcessor::Match(const TMTPTypeEvent& aEvent, MMTPConnection& aConnection) const + { + + TUint32 eventSessionId = aEvent.Uint32(TMTPTypeEvent::EEventSessionID); + TUint32 eventTransactionCode = aEvent.Uint32(TMTPTypeEvent::EEventTransactionID); + + TBool result = EFalse; + if(iSessionId == eventSessionId && + iTransactionCode == eventTransactionCode && + &iConnection == &aConnection) + { + result = ETrue; + } + return result; + } + +/** +Handle the request phase of the current request +@return EFalse +*/ +EXPORT_C TBool CMTPRequestProcessor::DoHandleRequestPhaseL() + { + __FLOG(_L8("DoHandleRequestPhaseL - Entry.")); + TRAPD(err, iResponseCode = CheckRequestL()); + if ((err != KErrNone) || (iResponseCode != EMTPRespCodeOK)) + { + if (HasDataphase()) + { + // If we have a dataphase + // we need to read in the data and discard it + __FLOG(_L8("Response code is not OK, there is data phase.")); + iNullBuffer.Close(); + iNullBuffer.CreateMaxL(KNullBufferSize); + iNull.SetBuffer(iNullBuffer); + ReceiveDataL(iNull); + } + else + { + if(err != KErrNone) + { + User::Leave(err); + } + SendResponseL(TMTPResponseCode(iResponseCode)); + } + } + else + { + TRAP(err, ServiceL()); + if (err != KErrNone) + { + iResponseCode = EMTPRespCodeGeneralError; + if (HasDataphase()) + { + // If we have a dataphase + // we need to read in the data and discard it + iNullBuffer.Close(); + iNullBuffer.CreateMaxL(KNullBufferSize); + iNull.SetBuffer(iNullBuffer); + ReceiveDataL(iNull); + } + else + { + User::Leave(err); + } + } + } + __FLOG(_L8("DoHandleRequestPhaseL - Exit.")); + return EFalse; + } + +/** +Handle the receiving data phase of the current request +@return EFalse +*/ +EXPORT_C TBool CMTPRequestProcessor::DoHandleDataIToRPhaseL() + { + User::Invariant(); + return EFalse; + } + +/** +Handle the sending data phase of the current request +@return EFalse +*/ +EXPORT_C TBool CMTPRequestProcessor::DoHandleRToIPhaseL() + { + User::Invariant(); + return EFalse; + } + +/** +Handle the response phase of the current request +@return EFalse +*/ +EXPORT_C TBool CMTPRequestProcessor::DoHandleResponsePhaseL() + { + TMTPResponseCode responseCode = (iCancelled ? EMTPRespCodeIncompleteTransfer : EMTPRespCodeOK); + SendResponseL(responseCode); + return EFalse; + } + +/** +Handle the completing phase of the current request +@return ETrue +*/ +EXPORT_C TBool CMTPRequestProcessor::DoHandleCompletingPhaseL() + { + CompleteRequestL(); + return ETrue; + } + +/** +Check the current request +@return EMTPRespCodeOK if the reqeust is good, otherwise, one of the error response codes +*/ +EXPORT_C TMTPResponseCode CMTPRequestProcessor::CheckRequestL() + { + if(!iRequestChecker) + { + iRequestChecker = CMTPRequestChecker::NewL(iFramework, iConnection); + } + __ASSERT_DEBUG(iRequest, User::Invariant()); + return iRequestChecker->VerifyRequestL(*iRequest, iElementCount, iElements); + } + +/** +part of active object framework, provide default implementation +*/ +EXPORT_C void CMTPRequestProcessor::RunL() + { + } + +/** +part of active object framework, provide default implementation +*/ +EXPORT_C void CMTPRequestProcessor::DoCancel() + { + } + +/** +part of active object framework, provide default implementation +*/ +EXPORT_C TInt CMTPRequestProcessor::RunError(TInt /*aError*/) + { + TRAP_IGNORE(SendResponseL(EMTPRespCodeGeneralError)); + return KErrNone; + } + +EXPORT_C TBool CMTPRequestProcessor::HasDataphase() const + { + return EFalse; + } + +/** +retrieve the session id and transaction code from the current request +*/ +void CMTPRequestProcessor::ExtractSessionTransactionId() + { + iSessionId = iRequest->Uint32(TMTPTypeRequest::ERequestSessionID); + iTransactionCode = iRequest->Uint32(TMTPTypeRequest::ERequestTransactionID); + } + + + + + + + + +