diff -r 000000000000 -r d0791faffa3f mtpfws/mtpfw/dataproviders/dputility/src/cmtpknowledgehandler.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/mtpfws/mtpfw/dataproviders/dputility/src/cmtpknowledgehandler.cpp Tue Feb 02 01:11:40 2010 +0200 @@ -0,0 +1,751 @@ +// 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#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(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 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); + } + *aBuffer = iKnowledgeObj; + __FLOG(_L8("GetObjectL - Exit")); + return EMTPRespCodeOK; + } + +TMTPResponseCode CMTPKnowledgeHandler::DeleteObjectPropertyL(const CMTPObjectMetaData& /*aObjectMetaData*/, const TUint16 aPropertyCode) + { + __FLOG(_L8("DeleteObjectPropertyL - Entry")); + TMTPResponseCode responseCode = EMTPRespCodeOK; + switch (aPropertyCode) + { + case EMTPGenObjPropCodeDateModified: + delete iDateModified; + iDateModified = NULL; + if (KErrNone != iRepository.Set(EDateModified, KEmptyContent16)) + { + responseCode = EMTPRespCodeGeneralError; + } + break; + case EMTPSvcObjPropCodeLastAuthorProxyID: + { + TMTPTypeUint128 tmp(MAKE_TINT64(KMTPUnInitialized32, KMTPUnInitialized32), + MAKE_TINT64(KMTPUnInitialized32, KMTPUnInitialized32)); + iLastAuthorProxyID.Set(tmp.UpperValue(), tmp.LowerValue()); + responseCode = SetColumnType128Value(ELastAuthorProxyID, iLastAuthorProxyID); + break; + } + + case EMTPObjectPropCodeParentObject: + case EMTPObjectPropCodeName: + case EMTPObjectPropCodePersistentUniqueObjectIdentifier: + case EMTPObjectPropCodeObjectFormat: + case EMTPObjectPropCodeObjectSize: + case EMTPObjectPropCodeStorageID: + case EMTPObjectPropCodeHidden: + case EMTPObjectPropCodeNonConsumable: + responseCode = EMTPRespCodeAccessDenied; + break; + + default: + responseCode = EMTPRespCodeInvalidObjectPropCode; + break; + } + __FLOG(_L8("DeleteObjectPropertyL - Exit")); + return responseCode; + } + +TMTPResponseCode CMTPKnowledgeHandler::GetBufferForSendObjectL(const CMTPObjectMetaData& /*aObjectMetaData*/, MMTPType** aBuffer) + { + __FLOG(_L8("GetBufferForSendObjectL - Entry")); + if (iKnowledgeSwpBuffer) + { + delete iKnowledgeSwpBuffer; + iKnowledgeSwpBuffer = NULL; + } + iKnowledgeSwpBuffer = CMTPTypeFile::NewL(iFramework.Fs(), iKnowObjSwpFileName, EFileWrite); + iKnowledgeSwpBuffer->SetSizeL(0); + *aBuffer = iKnowledgeSwpBuffer; + __FLOG(_L8("GetBufferForSendObjectL - Exit")); + return EMTPRespCodeOK; + } + +void CMTPKnowledgeHandler::BuildObjectInfoL(CMTPTypeObjectInfo& aObjectInfo) const + { + aObjectInfo.SetUint32L(CMTPTypeObjectInfo::EStorageID, iStorageID); + aObjectInfo.SetUint16L(CMTPTypeObjectInfo::EObjectFormat, iKnowledgeFormatCode); + // Not use + aObjectInfo.SetUint16L(CMTPTypeObjectInfo::EProtectionStatus, 0x0000); + aObjectInfo.SetUint32L(CMTPTypeObjectInfo::EObjectCompressedSize, iKnowledgeObjectSize); + aObjectInfo.SetUint16L(CMTPTypeObjectInfo::EThumbFormat, 0); + aObjectInfo.SetUint32L(CMTPTypeObjectInfo::EThumbCompressedSize, 0); + aObjectInfo.SetUint32L(CMTPTypeObjectInfo::EThumbPixWidth, 0); + aObjectInfo.SetUint32L(CMTPTypeObjectInfo::EThumbPixHeight, 0); + aObjectInfo.SetUint32L(CMTPTypeObjectInfo::EImagePixWidth, 0); + aObjectInfo.SetUint32L(CMTPTypeObjectInfo::EImagePixHeight, 0); + aObjectInfo.SetUint32L(CMTPTypeObjectInfo::EImageBitDepth, 0); + aObjectInfo.SetUint32L(CMTPTypeObjectInfo::EParentObject, KMTPHandleNoParent); + aObjectInfo.SetUint16L(CMTPTypeObjectInfo::EAssociationType, 0x0000); + aObjectInfo.SetUint32L(CMTPTypeObjectInfo::EAssociationDescription, 0); + aObjectInfo.SetUint32L(CMTPTypeObjectInfo::ESequenceNumber, 0); + aObjectInfo.SetStringL(CMTPTypeObjectInfo::EFilename, KNullDesC); + aObjectInfo.SetStringL(CMTPTypeObjectInfo::EDateModified, KNullDesC); + aObjectInfo.SetStringL(CMTPTypeObjectInfo::EDateCreated, KNullDesC); + aObjectInfo.SetStringL(CMTPTypeObjectInfo::EKeywords, KNullDesC); + } + +TMTPResponseCode CMTPKnowledgeHandler::GetObjectInfoL(const CMTPObjectMetaData& /*aObjectMetaData*/, CMTPTypeObjectInfo& aObjectInfo) + { + __FLOG(_L8("GetObjectInfoL - Entry")); + if(iKnowledgeObjectSize != KObjectSizeNotAvaiable) + { + BuildObjectInfoL(aObjectInfo); + } + __FLOG(_L8("GetObjectInfoL - Exit")); + return EMTPRespCodeOK; + } + + +void CMTPKnowledgeHandler::DeleteAllObjectPropertiesL() + { + __FLOG(_L8("DeleteAllObjectPropertiesL - Entry")); + User::LeaveIfError(iRepository.StartTransaction(CRepository::EReadWriteTransaction)); + iRepository.CleanupCancelTransactionPushL(); + User::LeaveIfError(iRepository.Set(EDateModified, KEmptyContent16)); + User::LeaveIfError(iRepository.Set(EName, KEmptyContent16)); + User::LeaveIfError(iRepository.Set(ESize, static_cast(KObjectSizeNotAvaiable))); + + TMTPTypeUint128 tmp(MAKE_TINT64(KMTPUnInitialized32, KMTPUnInitialized32), + MAKE_TINT64(KMTPUnInitialized32, KMTPUnInitialized32)); + if (EMTPRespCodeOK != SetColumnType128Value(ELastAuthorProxyID, tmp)) + { + User::Leave(KErrGeneral); + } + // Reset knowledgeobject pointer and close the file. + if (iKnowledgeObj) + { + delete iKnowledgeObj; + iKnowledgeObj = NULL; + } + + // Keep file delete is atomic. + if (BaflUtils::FileExists(iFramework.Fs(), iKnowObjFileName)) + { + User::LeaveIfError(iFramework.Fs().Delete(iKnowObjFileName)); + } + + TUint32 keyInfo; + User::LeaveIfError(iRepository.CommitTransaction(keyInfo)); + CleanupStack::Pop(&iRepository); + + __FLOG(_L8("DeleteAllObjectPropertiesL - Exit")); + return; + } + +void CMTPKnowledgeHandler::ReleaseObjectBuffer() + { + __FLOG(_L8("ReleaseObjectBuffer - Entry")); + if (iKnowledgeObj) + { + delete iKnowledgeObj; + iKnowledgeObj = NULL; + } + __FLOG(_L8("ReleaseObjectBuffer - Exit")); + } + +TMTPResponseCode CMTPKnowledgeHandler::GetObjectSizeL(const TDesC& aSuid, TUint64& aObjectSize) + { + __FLOG(_L8("GetObjectSizeL - Entry")); + if (aSuid != iSuid) + { + return EMTPRespCodeGeneralError; + } + aObjectSize = iKnowledgeObjectSize; + __FLOG(_L8("GetObjectSizeL - Exit")); + return EMTPRespCodeOK; + } + +TMTPResponseCode CMTPKnowledgeHandler::SetColumnType128Value(TMTPKnowledgeStoreKeyNum aColumnNum, TMTPTypeUint128& aNewData) + { + __FLOG(_L8("SetColumnType128ValueL - Entry")); + TInt ret; + TMTPResponseCode responseCode = EMTPRespCodeOK; + TBuf8 data; + data.FillZ(data.MaxLength()); + TUint64 upperValue = aNewData.UpperValue(); + TUint64 lowerValue = aNewData.LowerValue(); + + /** + Least significant 64-bit buffer offset. + */ + const TInt KMTPTypeUint128OffsetLS = 0; + /** + Most significant 64-bit buffer offset. + */ + const TInt KMTPTypeUint128OffsetMS = 8; + + memcpy(&data[KMTPTypeUint128OffsetMS], &upperValue, sizeof(upperValue)); + memcpy(&data[KMTPTypeUint128OffsetLS], &lowerValue, sizeof(lowerValue)); + + ret = iRepository.Set(aColumnNum, data); + if (KErrNone != ret) + { + responseCode = EMTPRespCodeGeneralError; + } + __FLOG_VA((_L8("SetColumnType128ValueL - Exit with responseCode = 0x%04X"), responseCode)); + return responseCode; + } + +TMTPResponseCode CMTPKnowledgeHandler::GetAllObjectPropCodeByGroupL(TUint32 aGroupId, RArray& aPropCodes) + { + __FLOG(_L8("GetAllObjectPropCodeByGroupL - Entry")); + TMTPResponseCode responseCode = EMTPRespCodeOK; + if (0 == aGroupId) + { + TInt count = sizeof(KMTPFullEnumSyncKnowledgeObjectProperties) / sizeof(KMTPFullEnumSyncKnowledgeObjectProperties[0]); + for (TInt i = 0; i < count; i++) + { + aPropCodes.Append(KMTPFullEnumSyncKnowledgeObjectProperties[i]); + } + } + else if(2 == aGroupId) + { + TInt count = sizeof(KMTPKnowledgeObjectPropertiesGroup2) / sizeof(KMTPKnowledgeObjectPropertiesGroup2[0]); + for (TInt i = 0; i < count; i++) + { + aPropCodes.Append(KMTPKnowledgeObjectPropertiesGroup2[i]); + } + } + else if(5 == aGroupId) + { + TInt count = sizeof(KMTPKnowledgeObjectPropertiesGroup5) / sizeof(KMTPKnowledgeObjectPropertiesGroup5[0]); + for (TInt i = 0; i < count; i++) + { + aPropCodes.Append(KMTPKnowledgeObjectPropertiesGroup5[i]); + } + } + else + { + responseCode = (TMTPResponseCode)0xA805; + } + __FLOG(_L8("GetAllObjectPropCodeByGroupL - Exit")); + return responseCode; + }