// Copyright (c) 2008-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:

// mw/remoteconn/mtpfws/mtpfw/dataproviders/dputility/src/cmtpsvccompoundprocessor.cpp

#include <mtp/mmtpdataproviderframework.h>

#include <mtp/cmtpobjectmetadata.h>

#include <mtp/cmtptypefile.h>

#include <mtp/cmtptypeobjectinfo.h>

#include <mtp/cmtptypeobjectproplist.h>

#include <mtp/cmtptypestring.h>

#include <mtp/mmtpobjectmgr.h>

#include <mtp/mmtpstoragemgr.h>

#include <mtp/mtpprotocolconstants.h> 

#include <mtp/tmtptypeint128.h>

#include "cmtpsvccompoundprocessor.h"

#include "mmtpservicedataprovider.h"

#include "mmtpsvcobjecthandler.h"

#include "cmtpconnection.h"

#include "cmtpconnectionmgr.h"

#include "mtpsvcdpconst.h"

// Class constants.

__FLOG_STMT(_LIT8(KComponent,"SvcCompound");)

EXPORT_C MMTPRequestProcessor* CMTPSvcCompoundProcessor::NewL(MMTPDataProviderFramework& aFramework, MMTPConnection& aConnection, MMTPServiceDataProvider& aDataProvider)

	{

	CMTPSvcCompoundProcessor* self = new (ELeave) CMTPSvcCompoundProcessor(aFramework, aConnection, aDataProvider);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

EXPORT_C CMTPSvcCompoundProcessor::~CMTPSvcCompoundProcessor()

	{

	__FLOG(_L8("~CMTPSvcCompoundProcessor - Entry"));

	delete iReceivedObjectMetaData;

	delete iObjectInfo;

	delete iObjectPropList;

	__FLOG(_L8("~CMTPSvcCompoundProcessor - Exit"));

	__FLOG_CLOSE; 

	}

CMTPSvcCompoundProcessor::CMTPSvcCompoundProcessor(MMTPDataProviderFramework& aFramework, MMTPConnection& aConnection, MMTPServiceDataProvider& aDataProvider) :

	CMTPRequestProcessor(aFramework, aConnection, 0, NULL),

	iDataProvider(aDataProvider), iState(EIdle), iIsCommited(EFalse), iIsRollBackHandlerObject(EFalse)

	{

	}

void CMTPSvcCompoundProcessor::ConstructL()

	{

	__FLOG_OPEN(KMTPSubsystem, KComponent);

	__FLOG(_L8("ConstructL - Entry"));

	iExpectedSendObjectRequest.SetUint16(TMTPTypeRequest::ERequestOperationCode, EMTPOpCodeSendObject);

	iReceivedObjectMetaData = CMTPObjectMetaData::NewL();

	iReceivedObjectMetaData->SetUint(CMTPObjectMetaData::EDataProviderId, iFramework.DataProviderId());

	__FLOG(_L8("ConstructL - Exit"));

	}

/**

Override to match both the SendObjectInfo/SendObjectPropList/UpdateObjectPropList and SendObject requests

@param aRequest    The request to match

@param aConnection The connection from which the request comes

@return ETrue if the processor can handle the request, otherwise EFalse

*/

TBool CMTPSvcCompoundProcessor::Match(const TMTPTypeRequest& aRequest, MMTPConnection& aConnection) const

	{

	__FLOG(_L8("Match - Entry"));

	TBool result = EFalse;

	TUint16 operationCode = aRequest.Uint16(TMTPTypeRequest::ERequestOperationCode);

	if ((&iConnection == &aConnection) && 

		(operationCode == EMTPOpCodeSendObjectInfo || 

		operationCode == EMTPOpCodeSendObject ||

		operationCode == EMTPOpCodeUpdateObjectPropList ||

		operationCode == EMTPOpCodeSendObjectPropList))

		{

		result = ETrue;

		}

	__FLOG(_L8("Match - Exit"));

	return result;

	}

TBool CMTPSvcCompoundProcessor::HasDataphase() const

	{

	return ETrue;

	}

/**

Verify the request

@return EMTPRespCodeOK if request is verified, otherwise one of the error response codes

*/

TMTPResponseCode CMTPSvcCompoundProcessor::CheckRequestL()

	{

	__FLOG(_L8("CheckRequestL - Entry"));

	TMTPResponseCode responseCode = CMTPRequestProcessor::CheckRequestL();

	if (EMTPRespCodeOK == responseCode)

		{

		responseCode = CheckSendingStateL();

		if (EMTPRespCodeOK == responseCode)

			{

			responseCode = CheckRequestParametersL();

			}

		}

	__FLOG_VA((_L8("CheckRequestL - Exit with code: 0x%04X"), responseCode));

	return responseCode;

	}

/**

Verify if the SendObject request comes after SendObjectInfo/SendObjectPropList request

@return EMTPRespCodeOK if SendObject request comes after a valid SendObjectInfo request, otherwise

EMTPRespCodeNoValidObjectInfo

*/

TMTPResponseCode CMTPSvcCompoundProcessor::CheckSendingStateL()

	{

	__FLOG(_L8("CheckSendingStateL - Entry"));

	TMTPResponseCode responseCode = EMTPRespCodeOK;

	iOperationCode = Request().Uint16(TMTPTypeRequest::ERequestOperationCode);

	if (iOperationCode == EMTPOpCodeSendObject)

		{

		//In ParseRouter everytime SendObject gets resolved then will be removed from Registry

		//Right away therefore we need reRegister it here again in case possible cancelRequest

		//Against this SendObject being raised.

		iExpectedSendObjectRequest.SetUint32(TMTPTypeRequest::ERequestSessionID, iSessionId);

		iFramework.RouteRequestRegisterL(iExpectedSendObjectRequest, iConnection);

		}

	switch (iState)

		{

		case EIdle:

			// Received an orphan SendObject

			if (iOperationCode == EMTPOpCodeSendObject)

				{

				responseCode = EMTPRespCodeNoValidObjectInfo;

				__FLOG(_L8("EIdle: Received an orphan SendObject request"));

				}

			break;

		case EObjectInfoSucceed:

			// If another SendObjectInfo or SendObjectPropList operation occurs before a SendObject

			// operation, the new ObjectInfo or ObjectPropList shall replace the previously held one. 

			// If this occurs, any storage or memory space reserved for the object described in the 

			// overwritten ObjectInfo or ObjectPropList dataset should be freed before overwriting and 

			// allocating the resources for the new data. 

			// Here is for the processor received another SendObjectInfo or SendObjectPropList 

			// before a SendObject or process SendObject failed,

			if (iOperationCode == EMTPOpCodeSendObjectInfo ||

				iOperationCode == EMTPOpCodeSendObjectPropList ||

				iOperationCode == EMTPOpCodeUpdateObjectPropList)

				{

				iFramework.RouteRequestUnregisterL(iExpectedSendObjectRequest, iConnection);

				if (!iIsCommited)

					{

					// Object Size != 0, need roll back all resource for the new SendInfo request

					CMTPSvcCompoundProcessor::RollBackObject(this);

					iFramework.ObjectMgr().UnreserveObjectHandleL(*iReceivedObjectMetaData);

					}

				delete iObjectInfo;

				iObjectInfo = NULL;

				delete iObjectPropList;

				iObjectPropList = NULL;

				delete iReceivedObjectMetaData;

				iReceivedObjectMetaData = NULL;

				iReceivedObjectMetaData = CMTPObjectMetaData::NewL();

				iReceivedObjectMetaData->SetUint(CMTPObjectMetaData::EDataProviderId, iFramework.DataProviderId());

				iObjectHandler = NULL;

				iState = EIdle;

				// Reset commit state to false

				iIsCommited = EFalse;

				__FLOG(_L8("EObjectInfoSucceed: Receive send obj info request again, return to EIdle"));

				}

			break;

		default:

			User::Leave(KErrGeneral);

		}

	__FLOG_VA((_L8("CheckSendingStateL - Exit with code: 0x%04X, state: %u"), responseCode, iState));

	return responseCode;

	}

/**

Validates the data type for a given property code.

@return EMTPRespCodeOK if the parent handle matches the store id, or another MTP response code if not

*/

TMTPResponseCode CMTPSvcCompoundProcessor::CheckRequestParametersL()

	{

	__FLOG(_L8("CheckRequestParametersL - Entry"));

	TMTPResponseCode responseCode = EMTPRespCodeOK;

	switch (iOperationCode)

		{

		case EMTPOpCodeSendObject:

			{

			__FLOG(_L8("Check SendObject request parameters"));

			// Check SendObject's session ID

			if (iSessionId != iLastSessionID)

				{

				responseCode = EMTPRespCodeNoValidObjectInfo;

				}

			else if ((iLastTransactionID + 1) != iTransactionCode)

				{

				// Check SendObject's transaction ID

				responseCode = EMTPRespCodeInvalidTransactionID;

				}

			break;

			}

		case EMTPOpCodeSendObjectInfo:

			{

			__FLOG(_L8("Check SendObjectInfo request parameters"));

			responseCode = CheckStoreAndParent();

			break;

			}

		case EMTPOpCodeSendObjectPropList:

			{

			__FLOG(_L8("Check SendObjectPropList request parameters"));

			responseCode = CheckStoreAndParent();

			if (EMTPRespCodeOK == responseCode)

				{

				// SendObjectPropList need check format code and size in the request

				TUint32 objectSizeHigh = Request().Uint32(TMTPTypeRequest::ERequestParameter4);

				TUint32 objectSizeLow  = Request().Uint32(TMTPTypeRequest::ERequestParameter5);

				iObjectSize = MAKE_TUINT64(objectSizeHigh, objectSizeLow);

				iFormatCode = Request().Uint32(TMTPTypeRequest::ERequestParameter3);

				responseCode = CheckFmtAndSetHandler(iFormatCode);

				iReceivedObjectMetaData->SetUint(CMTPObjectMetaData::EFormatCode, iFormatCode);

				}

			break;

			}

		case EMTPOpCodeUpdateObjectPropList:

			{

			__FLOG(_L8("Check UpdateObjectPropList request parameters"));

			TUint32 objectHandle = Request().Uint32(TMTPTypeRequest::ERequestParameter1);

			if (objectHandle != KMTPHandleNone)

				{

				// Find the updating object information

				MMTPObjectMgr& objects(iFramework.ObjectMgr());

				if (objects.ObjectL(objectHandle, *iReceivedObjectMetaData))

					{

					iFormatCode = iReceivedObjectMetaData->Uint(CMTPObjectMetaData::EFormatCode);

					if (iReceivedObjectMetaData->Uint(CMTPObjectMetaData::EDataProviderId) != iFramework.DataProviderId())

						{

						responseCode = EMTPRespCodeInvalidObjectHandle;

						}

					else

						{

						responseCode = CheckFmtAndSetHandler(iFormatCode);

						}

					}

				else

					{

					responseCode = EMTPRespCodeInvalidObjectHandle;

					}

				}

			else

				{

				responseCode = EMTPRespCodeInvalidObjectHandle;

				}

			break;

			}

		default:

			// Unexpected operation code

			responseCode = EMTPRespCodeOperationNotSupported;

			break;

		}

	__FLOG_VA((_L8("CheckRequestParametersL exit with code: 0x%x"), responseCode));

	return responseCode;

	}

/**

Validates the data type for a given property code.

@return EMTPRespCodeOK if the parent handle matches the store id, or another MTP response code if not

*/

TMTPResponseCode CMTPSvcCompoundProcessor::CheckStoreAndParent()

	{

	__FLOG(_L8("CheckStoreAndParent - Entry"));

	TMTPResponseCode responseCode = EMTPRespCodeOK;

	iStorageId = Request().Uint32(TMTPTypeRequest::ERequestParameter1);

	iParentHandle = Request().Uint32(TMTPTypeRequest::ERequestParameter2);

	// If the first parameter is unused, it should be set to 0x00000000, and the responder should decide

	// in which store to place the object

	if (iStorageId == KMTPStorageDefault)

		{

		// If the second parameter is used, the first parameter must also be used.

		// If the second parameter is unused, it should be set to 0x00000000

		if (iParentHandle != KMTPHandleNone)

			{

			responseCode = EMTPRespCodeInvalidParentObject;

			}

		else

			{

			// Set storage id as service dp's logical storage id.

			iStorageId = iDataProvider.StorageId();

			}

		}

	else

		{

		// Check logical storage id.

		if (iStorageId != iDataProvider.StorageId())

			{

			responseCode = EMTPRespCodeInvalidStorageID;

			}

		}

	__FLOG_VA((_L8("CheckStoreAndParent - Exit with code: 0x%x"), responseCode));

	return responseCode;

	}

/**

SendObjectInfo/SendObjectPropList/UpdateObjectPropList/SendObject request handler

To maintain the state information between the two requests, the two requests are 

combined together in one request processor.

*/

void CMTPSvcCompoundProcessor::ServiceL()

	{

	__FLOG(_L8("ServiceL - Entry"));

	switch (iState)

		{

		case EIdle:

			ServiceObjectPropertiesL();

			break;

		case EObjectInfoSucceed:

			ServiceSendObjectL();

			break;

		default:

			__FLOG(_L8("Wrong state in ServiceL"));

			break;

		}

	__FLOG(_L8("ServiceL - Exit"));

	}

void CMTPSvcCompoundProcessor::ServiceObjectPropertiesL()

	{

	__FLOG(_L8("ServiceObjectPropertiesL - Entry"));

	switch (iOperationCode)

		{

		case EMTPOpCodeSendObjectInfo:

			ServiceSendObjectInfoL();

			break;

		case EMTPOpCodeSendObjectPropList:

		case EMTPOpCodeUpdateObjectPropList:

			ServiceSendObjectPropListL();

			break;

		default:

			break;

		}

	__FLOG(_L8("ServiceObjectPropertiesL - Exit"));

	}

/**

SendObject request handler

*/

void CMTPSvcCompoundProcessor::ServiceSendObjectL()

	{

	__FLOG(_L8("ServiceSendObjectL - Entry"));

	MMTPSvcObjectHandler* pHandler = iDataProvider.ObjectHandler(iFormatCode);

	if (pHandler)

		{

		pHandler->GetBufferForSendObjectL(*iReceivedObjectMetaData, &iObjectContent);

		}

	else

		{

		User::Leave(KErrGeneral);

		}

	ReceiveDataL(*iObjectContent);

	iState = EObjectSendProcessing;

	__FLOG(_L8("ServiceSendObjectL - Exit"));

	}

/**

SendObjectInfo request handler

*/

void CMTPSvcCompoundProcessor::ServiceSendObjectInfoL()

	{

	__FLOG(_L8("ServiceSendObjectInfoL - Entry"));

	delete iObjectInfo;

	iObjectInfo = NULL;

	iObjectInfo = CMTPTypeObjectInfo::NewL();

	ReceiveDataL(*iObjectInfo);

	iState = EObjectInfoProcessing;

	__FLOG(_L8("ServiceSendObjectInfoL - Exit"));

	}

/**

SendObjectPropList request handler

*/

void CMTPSvcCompoundProcessor::ServiceSendObjectPropListL()

	{

	__FLOG(_L8("ServiceSendObjectPropListL - Entry"));

	delete iObjectPropList;

	iObjectPropList = NULL;

	iObjectPropList = CMTPTypeObjectPropList::NewL();

	ReceiveDataL(*iObjectPropList);

	iState = EObjectInfoProcessing;

	__FLOG(_L8("ServiceSendObjectPropListL - Exit"));

	}

/**

Override to handle the response phase of SendObjectInfo/SendObjectPropList and SendObject requests

@return EFalse

*/

TBool CMTPSvcCompoundProcessor::DoHandleResponsePhaseL()

	{

	__FLOG(_L8("DoHandleResponsePhaseL - Entry"));

	TBool successful = !iCancelled;

	switch (iState)

		{

		case EObjectInfoProcessing:

			{

			if (iOperationCode == EMTPOpCodeSendObjectInfo)

				{

				successful = DoHandleResponseSendObjectInfoL();

				}

			else if (iOperationCode == EMTPOpCodeSendObjectPropList)

				{

				successful = DoHandleResponseSendObjectPropListL();

				}

			else if (iOperationCode == EMTPOpCodeUpdateObjectPropList)

				{

				successful = DoHandleResponseUpdateObjectPropListL();

				}

			iState = (successful ? EObjectInfoSucceed : EIdle);

			break;

			}

		case EObjectSendProcessing:

			{

			successful = DoHandleResponseSendObjectL();

			iState = (successful ? EObjectSendSucceed : EObjectSendFail);

			break;

			}

		default:

			// Wrong State value.

			__FLOG_VA((_L8("DoHandleResponsePhaseL enter an abnormal state %d"), iState));

			break;

		}

	__FLOG(_L8("DoHandleResponsePhaseL - Exit"));

	return EFalse;

	}

/**

Override to handle the completing phase of SendObjectInfo/SendObjectPropList and SendObject requests

@return ETrue if succesfully received the object content, otherwise EFalse

*/

TBool CMTPSvcCompoundProcessor::DoHandleCompletingPhaseL()

	{

	__FLOG(_L8("DoHandleCompletingPhaseL - Entry"));

	TBool result = ETrue;

	CMTPRequestProcessor::DoHandleCompletingPhaseL();

	__FLOG_VA((_L8("DoHandleCompletingPhaseL - Progress State: %u"), iState));

	switch (iState)

		{

		case EObjectInfoSucceed:

			{

			// Two cases will come here:

			// 1. SendObjInfo OK, Store ID for next SendObject checking;

			// 2. SendObject check request fail, such as wrong transaction id or wrong session id.

			//    needn't change transaction id.

			if (iOperationCode == EMTPOpCodeSendObjectInfo || 

				iOperationCode == EMTPOpCodeUpdateObjectPropList ||

				iOperationCode == EMTPOpCodeSendObjectPropList)

				{

				// Reset transaction id for new SendObjInfo request, but ignore wrong SendObject.

				iLastTransactionID = iTransactionCode;

				iLastSessionID = iSessionId;

				iLastInfoOperationCode = iOperationCode;

				}

			result = EFalse;

			__FLOG_VA((_L8("EObjectInfoSucceed: Save send info transaction id: %u, operation: 0x%x"), iLastTransactionID, iOperationCode));

			break;

			}

		case EObjectSendFail:

			{

			// When process SendObject fail, such as received size is wrong.

			iLastTransactionID++;

			iState = EObjectInfoSucceed;

			result = EFalse;

			break;

			}

		default:

			// The other cases will delete the processor:

			// 1. SendObject OK

			// 2. Framework error and call complete with error state.

			// 3. SendObjInfo fail

			// 4. First request is orphan SendObject, state is Idle

			break;

		}

	__FLOG(_L8("DoHandleCompletingPhaseL - Exit"));

	return result;

	}

/**

Handling the completing phase of SendObjectInfo request

@return ETrue if the specified object can be saved on the specified location, otherwise, EFalse

*/

TBool CMTPSvcCompoundProcessor::DoHandleResponseSendObjectInfoL()

	{

	__FLOG(_L8("DoHandleResponseSendObjectInfoL - Entry"));

	TMTPResponseCode responseCode = EMTPRespCodeOK;

	TBool result(ETrue);

	iFormatCode = iObjectInfo->Uint16L(CMTPTypeObjectInfo::EObjectFormat);

	// Check format code and set object handler

	responseCode = CheckFmtAndSetHandler(iFormatCode);

	if (responseCode != EMTPRespCodeOK)

		{

		SendResponseL(responseCode);

		}

	else

		{

		iReceivedObjectMetaData->SetUint(CMTPObjectMetaData::EFormatCode, iFormatCode);