// 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/cmtpknowledgehandler.cpp

#include <bautils.h> 

#include <centralrepository.h>

#include <mtp/cmtptypestring.h>

#include <mtp/cmtpobjectmetadata.h>

#include <mtp/cmtptypeobjectinfo.h>

#include <mtp/cmtptypeobjectproplist.h>

#include <mtp/mmtpdataproviderframework.h>

#include <mtp/mmtpobjectmgr.h>

#include <mtp/cmtptypefile.h>

#include <mtp/mtpdatatypeconstants.h>

#include "cmtpknowledgehandler.h"

// Class constants.

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

const TInt KDateTimeMaxLength = 22;

const TInt KNameMaxLength = 255;

_LIT16(KEmptyContent16, "");

_LIT(KMTPKnowledgeObjDriveLocation, "c:");

_LIT(KMTPNoBackupFolder, "nobackup\\");	

_LIT(KMTPSlash, "\\");

_LIT(KMTPKnowledgeObjFileName, "mtp_knowledgeobj.dat");

_LIT(KMTPKnowledgeObjSwpFileName, "mtp_knowledgeobj.swp");

EXPORT_C CMTPKnowledgeHandler* CMTPKnowledgeHandler::NewL(MMTPDataProviderFramework& aFramework, TUint16 aFormatCode, 

												CRepository& aReposotry, const TDesC& aKwgSuid)

	{

	CMTPKnowledgeHandler *self = new (ELeave) CMTPKnowledgeHandler(aFramework, aFormatCode, aReposotry, aKwgSuid);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

EXPORT_C CMTPKnowledgeHandler::~CMTPKnowledgeHandler()

	{

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

	delete iDateModified;

	delete iName;

	delete iKnowledgeObj;

	delete iKnowledgeSwpBuffer;

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

	__FLOG_CLOSE;

	}

CMTPKnowledgeHandler::CMTPKnowledgeHandler(MMTPDataProviderFramework& aFramework, TUint16 aFormatCode, 

										CRepository& aReposotry, const TDesC& aKwgSuid) :

	iFramework(aFramework), iRepository(aReposotry), iKnowledgeFormatCode(aFormatCode),

	iKnowledgeObjectSize(KObjectSizeNotAvaiable), iCacheStatus(EOK), iSuid(aKwgSuid)

	{

	}

void CMTPKnowledgeHandler::ConstructL()

	{

	__FLOG_OPEN(KMTPSubsystem, KComponent);

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

	iFramework.Fs().PrivatePath(iKnowObjFileName);

	iKnowObjFileName.Insert(0, KMTPKnowledgeObjDriveLocation);

	iKnowObjFileName.Append(KMTPNoBackupFolder);

	iKnowObjFileName.Append(iSuid);

	iKnowObjFileName.Append(KMTPSlash);

	iKnowObjSwpFileName.Append(iKnowObjFileName);

	iKnowObjSwpFileName.Append(KMTPKnowledgeObjSwpFileName);

	iKnowObjFileName.Append(KMTPKnowledgeObjFileName);

	// Create knowledge object file directory if not exist.

	BaflUtils::EnsurePathExistsL(iFramework.Fs(), iKnowObjFileName);

	// Recover for previous failed transaction

	if(BaflUtils::FileExists(iFramework.Fs(), iKnowObjSwpFileName))

		{

		// In case DP received some object content

		User::LeaveIfError(iFramework.Fs().Delete(iKnowObjSwpFileName));

		}

	LoadKnowledgeObjPropertiesL();

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

	}

EXPORT_C void CMTPKnowledgeHandler::SetStorageId(TUint32 aStorageId)

	{

	iStorageID = aStorageId;

	}

void CMTPKnowledgeHandler::CommitL()

	{

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

	User::LeaveIfError(iRepository.StartTransaction(CRepository::EReadWriteTransaction));

	iRepository.CleanupCancelTransactionPushL();

	if(iKnowledgeObjectSize != KObjectSizeNotAvaiable)

		{

		User::LeaveIfError(iRepository.Set(ESize, (TInt)iKnowledgeObjectSize));

		}

	if(iDateModified)

		{

		User::LeaveIfError(iRepository.Set(EDateModified, *iDateModified));

		}

	if(iName)

		{

		User::LeaveIfError(iRepository.Set(EName, *iName));

		}

	if (EMTPRespCodeOK != SetColumnType128Value(ELastAuthorProxyID, iLastAuthorProxyID))

		{

		User::Leave(KErrGeneral);

		}

	// Close all knowledge file and reset pointer.

	if (iKnowledgeObj)

		{

		delete iKnowledgeObj;

		iKnowledgeObj = NULL;

		}

	if (iKnowledgeSwpBuffer)

		{

		delete iKnowledgeSwpBuffer;

		iKnowledgeSwpBuffer = NULL;

		}

	if(BaflUtils::FileExists(iFramework.Fs(), iKnowObjSwpFileName))

		{

		// In case DP received some object content

		User::LeaveIfError(iFramework.Fs().Replace(iKnowObjSwpFileName, iKnowObjFileName));

		}

	// If swp file isn't exsited, that means 0 sized object received, need do nothing.

	TUint32 keyInfo;

	User::LeaveIfError(iRepository.CommitTransaction(keyInfo));

	CleanupStack::Pop(&iRepository);

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

	}

void CMTPKnowledgeHandler::CommitForNewObjectL(TDes& aSuid)

	{

	aSuid = iSuid;

	CommitL();

	}

void CMTPKnowledgeHandler::RollBack()

	{

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

	TRAP_IGNORE(LoadKnowledgeObjPropertiesL());

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

	}

EXPORT_C void CMTPKnowledgeHandler::GetObjectSuidL(TDes& aSuid) const

	{

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

	if(iKnowledgeObjectSize != KObjectSizeNotAvaiable)

		{

		aSuid.Append(iSuid);

		}

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

	}

void CMTPKnowledgeHandler::LoadKnowledgeObjPropertiesL()

	{

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

	iCacheStatus = EOK;

	iCacheStatusFlag = EDirty;

	TCleanupItem cacheDroper(DropCacheWrapper, this);

	CleanupStack::PushL(cacheDroper);

	TInt objSize;

	User::LeaveIfError(iRepository.Get(ESize, objSize));

	iKnowledgeObjectSize = objSize;

	// Load DateModify

	delete iDateModified;

	iDateModified = NULL;

	iDateModified = HBufC::NewL(KDateTimeMaxLength);

	TPtr ptrDate(iDateModified->Des());

	User::LeaveIfError(iRepository.Get(EDateModified, ptrDate));

	// Load Name

	delete iName;

	iName = NULL;

	iName = HBufC::NewL(KNameMaxLength);

	TPtr ptrName(iName->Des());

	User::LeaveIfError(iRepository.Get(EName, ptrName));

	// Load LastAuthorProxyID:

	TPtr8 writeBuf(NULL, 0); //walkaroud for the TMTPTypeUint128

	iLastAuthorProxyID.FirstWriteChunk(writeBuf);

	User::LeaveIfError(iRepository.Get(ELastAuthorProxyID, writeBuf));

	CleanupStack::Pop(this);

	// Doesn't load object content to cache beacause it can grow up to 100KB

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

	}

void CMTPKnowledgeHandler::DropCacheWrapper(TAny* aObject)

	{

	reinterpret_cast<CMTPKnowledgeHandler*>(aObject)->DropKnowledgeObjPropertiesCache();

	}

void CMTPKnowledgeHandler::DropKnowledgeObjPropertiesCache()

	{

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

	iCacheStatus = iCacheStatusFlag;

	iKnowledgeObjectSize = KObjectSizeNotAvaiable;

	// Load DateModify

	delete iDateModified;

	iDateModified = NULL;

	// Load Name

	delete iName;

	iName = NULL;

	// Reset LastAuthorProxyID

	TMTPTypeUint128 tmp(MAKE_TINT64(KMTPUnInitialized32, KMTPUnInitialized32), 

						MAKE_TINT64(KMTPUnInitialized32, KMTPUnInitialized32));

	iLastAuthorProxyID.Set(tmp.UpperValue(), tmp.LowerValue());

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

	}

TMTPResponseCode CMTPKnowledgeHandler::SendObjectInfoL(const CMTPTypeObjectInfo& aObjectInfo, TUint32& aParentHandle, TDes& aSuid)

	{

	__FLOG(_L("SendObjectInfoL - Entry"));

	TMTPResponseCode responseCode = EMTPRespCodeOK;

	if (aParentHandle != KMTPHandleNone && aParentHandle != KMTPHandleNoParent)

		{

		responseCode = EMTPRespCodeInvalidParentObject;

		}

	else

		{

		//if there's a read error reread

		if(EDirty == iCacheStatus)

			{

			LoadKnowledgeObjPropertiesL();

			}

		//already has a knowledge object

		if(iKnowledgeObjectSize != KObjectSizeNotAvaiable)

			{

			responseCode = EMTPRespCodeAccessDenied;

			}

		else

			{

			iKnowledgeObjectSize = aObjectInfo.Uint32L(CMTPTypeObjectInfo::EObjectCompressedSize);

			delete iDateModified;

			iDateModified = NULL;

			iDateModified = aObjectInfo.StringCharsL(CMTPTypeObjectInfo::EDateModified).AllocL();

			aSuid = iSuid;

			}

		}

	__FLOG(_L("SendObjectInfoL - Exit"));

	return responseCode;

	}

TMTPResponseCode CMTPKnowledgeHandler::SendObjectPropListL(TUint64 aObjectSize, const CMTPTypeObjectPropList& /*aObjectPropList*/, 

															TUint32& aParentHandle, TDes& aSuid)

	{

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

	TMTPResponseCode responseCode = EMTPRespCodeOK;

	if (aParentHandle != KMTPHandleNone && aParentHandle != KMTPHandleNoParent)

		{

		responseCode = EMTPRespCodeInvalidParentObject;

		}

	else

		{

		//if there's a read error reread

		aParentHandle = KMTPHandleNoParent;

		if(EDirty == iCacheStatus)

			{

			LoadKnowledgeObjPropertiesL();

			}

		//already has a knowledge object

		if(iKnowledgeObjectSize != KObjectSizeNotAvaiable)

			{

			responseCode = EMTPRespCodeAccessDenied;

			}

		else

			{

			iKnowledgeObjectSize = aObjectSize;

			aSuid = iSuid;

			}

		}

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

	return responseCode;

	}

TMTPResponseCode CMTPKnowledgeHandler::GetObjectPropertyL(const CMTPObjectMetaData& aObjectMetaData, 

																TUint16 aPropertyCode, CMTPTypeObjectPropList& aPropList)

	{

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

	TMTPResponseCode responseCode = EMTPRespCodeOK;

	CMTPTypeObjectPropListElement* propertyElement = NULL;

	TUint32 aHandle = aObjectMetaData.Uint(CMTPObjectMetaData::EHandle);

	switch (aPropertyCode)

		{

		case EMTPGenObjPropCodeParentID:

			{

			propertyElement = &(aPropList.ReservePropElemL(aHandle, aPropertyCode));

			propertyElement->SetUint32L(CMTPTypeObjectPropListElement::EValue, 0x0000);

			break;

			}

		case EMTPGenObjPropCodeName:

			{

			propertyElement = &(aPropList.ReservePropElemL(aHandle, aPropertyCode));

			if (iName && iName->Length() > 0)

				{

				propertyElement->SetStringL(CMTPTypeObjectPropListElement::EValue, *iName);			

				}

			else

				{

				_LIT(KDefaultKwgObjName, "GenericObject01");

				propertyElement->SetStringL(CMTPTypeObjectPropListElement::EValue, KDefaultKwgObjName());	

				}

			break;

			}

		case EMTPGenObjPropCodePersistentUniqueObjectIdentifier:

			{

			propertyElement = &(aPropList.ReservePropElemL(aHandle, aPropertyCode));

			propertyElement->SetUint128L(CMTPTypeObjectPropListElement::EValue,

								iFramework.ObjectMgr().PuidL(aHandle).UpperValue(),

								iFramework.ObjectMgr().PuidL(aHandle).LowerValue());

			break;

			}

		case EMTPGenObjPropCodeObjectFormat:

			{

			propertyElement = &(aPropList.ReservePropElemL(aHandle, aPropertyCode));

			propertyElement->SetUint16L(CMTPTypeObjectPropListElement::EValue, iKnowledgeFormatCode);

			break;

			}

		case EMTPGenObjPropCodeObjectSize:

			{

			if (iKnowledgeObjectSize != ~0)

				{

				propertyElement = &(aPropList.ReservePropElemL(aHandle, aPropertyCode));

				propertyElement->SetUint64L(CMTPTypeObjectPropListElement::EValue,iKnowledgeObjectSize);

				}

			break;

			}

		case EMTPGenObjPropCodeStorageID:

			{

			propertyElement = &(aPropList.ReservePropElemL(aHandle, aPropertyCode));

			propertyElement->SetUint32L(CMTPTypeObjectPropListElement::EValue, iStorageID);

			break;

			}

		case EMTPGenObjPropCodeObjectHidden:

			{

			propertyElement = &(aPropList.ReservePropElemL(aHandle, aPropertyCode));

			propertyElement->SetUint16L(CMTPTypeObjectPropListElement::EValue, 0x0001);

			break;

			}

		case EMTPGenObjPropCodeNonConsumable:

			{

			propertyElement = &(aPropList.ReservePropElemL(aHandle, aPropertyCode));

			propertyElement->SetUint8L(CMTPTypeObjectPropListElement::EValue, 0x01);

			break;

			}

		case EMTPGenObjPropCodeDateModified:

			{

			propertyElement = &(aPropList.ReservePropElemL(aHandle, aPropertyCode));

			if(iDateModified && iDateModified->Length() > 0)

				{

				propertyElement->SetStringL(CMTPTypeObjectPropListElement::EValue, *iDateModified);	

				}

			else

				{

				TTime now;	

				now.UniversalTime();

				const TInt KMaxTimeStringSize = 50;

				TBuf<KMaxTimeStringSize> dateTimeBuf;

				_LIT(KFormat,"%F%Y%M%DT%H%T%S");

				now.FormatL(dateTimeBuf, KFormat);

				propertyElement->SetStringL(CMTPTypeObjectPropListElement::EValue, dateTimeBuf);	

				}

			break;

			}

		case EMTPSvcObjPropCodeLastAuthorProxyID:

			{

			const TMTPTypeUint128 unInitValue(MAKE_TUINT64(KMTPUnInitialized32, KMTPUnInitialized32), 

										MAKE_TUINT64(KMTPUnInitialized32, KMTPUnInitialized32));

			if(!unInitValue.Equal(iLastAuthorProxyID))

				{

				propertyElement = &(aPropList.ReservePropElemL(aHandle, aPropertyCode));

				propertyElement->SetUint128L(CMTPTypeObjectPropListElement::EValue,

											iLastAuthorProxyID.UpperValue(),

											iLastAuthorProxyID.LowerValue());

				}

			break;	

			}

		default:

			responseCode = EMTPRespCodeInvalidObjectPropCode;

			break;

		}

	if(propertyElement)

		{

		aPropList.CommitPropElemL(*propertyElement);

		}

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

	return responseCode;

	}

TMTPResponseCode CMTPKnowledgeHandler::SetObjectPropertyL(const TDesC& /*aSuid*/, 

															const CMTPTypeObjectPropListElement& aElement, 

															TMTPOperationCode aOperationCode)

	{

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

	TMTPResponseCode responseCode = CheckGenObjectPropertyL(aElement, aOperationCode);

	if (responseCode == EMTPRespCodeOK)

		{

		TInt ret = KErrNone;

		TUint16 propertyCode(aElement.Uint16L(CMTPTypeObjectPropListElement::EPropertyCode));

		switch (propertyCode)

			{

			case EMTPGenObjPropCodeObjectSize:

				if(aOperationCode == EMTPOpCodeSetObjectPropList)

					{

					ret = iRepository.Set(ESize, (TInt)aElement.Uint64L(CMTPTypeObjectPropListElement::EValue));

					}

				iKnowledgeObjectSize = aElement.Uint64L(CMTPTypeObjectPropListElement::EValue);

				break;

			case EMTPGenObjPropCodeDateModified:

				if(aOperationCode == EMTPOpCodeSetObjectPropList)

					{

					ret = iRepository.Set(EDateModified, aElement.StringL(CMTPTypeObjectPropListElement::EValue));

					}

				delete iDateModified;

				iDateModified = NULL;

				iDateModified = aElement.StringL(CMTPTypeObjectPropListElement::EValue).AllocL();

				break;

			case EMTPGenObjPropCodeName:

				if(aOperationCode == EMTPOpCodeSetObjectPropList)

					{

					ret = iRepository.Set(EName, aElement.StringL(CMTPTypeObjectPropListElement::EValue));

					}

				delete iName;

				iName = NULL;

				iName = aElement.StringL(CMTPTypeObjectPropListElement::EValue).AllocL();

				break;

			case EMTPSvcObjPropCodeLastAuthorProxyID:

				{

				TUint64 high_value = 0;

				TUint64 low_value  = 0;

				aElement.Uint128L(CMTPTypeObjectPropListElement::EValue, high_value, low_value);

				if(aOperationCode == EMTPOpCodeSetObjectPropList)

					{

					responseCode = SetColumnType128Value(ELastAuthorProxyID, iLastAuthorProxyID);

					}

				iLastAuthorProxyID.Set(high_value, low_value);

				break;

				}

			default:

				responseCode = EMTPRespCodeObjectPropNotSupported;

				break;

			}

		if (KErrNone != ret)

			{

			responseCode = EMTPRespCodeGeneralError;

			}

		}

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

	return responseCode;

	}

// Remove the knowledge object

TMTPResponseCode CMTPKnowledgeHandler::DeleteObjectL(const CMTPObjectMetaData& /*aObjectMetaData*/)

	{

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

	iCacheStatusFlag = EDirty;

	TCleanupItem cacheDroper(DropCacheWrapper, this);

	CleanupStack::PushL(cacheDroper);

	// Delete obejct properties in transaction, if leave, mgr will rollback all properties.

	DeleteAllObjectPropertiesL();

	CleanupStack::Pop(this);

	// Drop all cached properties.

	iCacheStatusFlag = EDeleted;

	CMTPKnowledgeHandler::DropCacheWrapper(this);

	LoadKnowledgeObjPropertiesL();

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

	return EMTPRespCodeOK;

	}

// Return the knowledge object content

TMTPResponseCode CMTPKnowledgeHandler::GetObjectL(const CMTPObjectMetaData& /*aObjectMetaData*/, MMTPType** aBuffer)

	{

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

	if (!BaflUtils::FileExists(iFramework.Fs(), iKnowObjFileName))

		{

		RFile file;

		CleanupClosePushL(file);

		User::LeaveIfError(file.Create(iFramework.Fs(), iKnowObjFileName, EFileRead));

		CleanupStack::PopAndDestroy(&file);

		}

	// iKnowledgeObj will be NULL in four cases: 1. Initialize; 2. The Object has been deleted.

	// 3. it has been commited by SendObject. 4 released by GetObject.

	if (!iKnowledgeObj)

		{

		iKnowledgeObj = CMTPTypeFile::NewL(iFramework.Fs(), iKnowObjFileName, EFileRead);

		}