diff -r 2c19c7cf5550 -r c20dd21d1eb4 mtpfws/mtpfw/dataproviders/dputility/src/cmtpknowledgehandler.cpp --- a/mtpfws/mtpfw/dataproviders/dputility/src/cmtpknowledgehandler.cpp Fri Aug 20 17:43:33 2010 +0800 +++ b/mtpfws/mtpfw/dataproviders/dputility/src/cmtpknowledgehandler.cpp Fri Sep 03 18:38:04 2010 +0800 @@ -25,9 +25,12 @@ #include #include "cmtpknowledgehandler.h" +#include "mtpdebug.h" +#include "OstTraceDefinitions.h" +#ifdef OST_TRACE_COMPILER_IN_USE +#include "cmtpknowledgehandlerTraces.h" +#endif -// Class constants. -__FLOG_STMT(_LIT8(KComponent,"KwgObjHdler");) const TInt KDateTimeMaxLength = 22; const TInt KNameMaxLength = 255; @@ -55,59 +58,61 @@ } CKnowledgeObject::~CKnowledgeObject() { - __FLOG(_L8("~CKnowledgeObject - Entry")); + OstTraceFunctionEntry0( CKNOWLEDGEOBJECT_CKNOWLEDGEOBJECT_DES_ENTRY ); iDateModified.Close(); iName.Close(); - __FLOG(_L8("~CKnowledgeObject - Exit")); - __FLOG_CLOSE; + OstTraceFunctionExit0( CKNOWLEDGEOBJECT_CKNOWLEDGEOBJECT_DES_EXIT ); } void CKnowledgeObject::ConstructL() { - __FLOG_OPEN(KMTPSubsystem, KComponent); - __FLOG(_L8("CKnowledgeObject Construct - Entry")); + OstTraceFunctionEntry0( CKNOWLEDGEOBJECT_CONSTRUCTL_ENTRY ); iKnowledgeObjectSize = KObjectSizeNotAvaiable; iDateModified.CreateL(KDateTimeMaxLength); iName.CreateL(KNameMaxLength); iLastAuthorProxyID.Set(KMTPUnInitialized64, KMTPUnInitialized64); iDirty = EBitFlagAll; - __FLOG(_L8("CKnowledgeObject Construct - Exit")); + OstTraceFunctionExit0( CKNOWLEDGEOBJECT_CONSTRUCTL_EXIT ); } void CKnowledgeObject::LoadL() { - __FLOG(_L8("CKnowledgeObject LoadL - Entry")); + OstTraceFunctionEntry0( CKNOWLEDGEOBJECT_LOADL_ENTRY ); // Load ObjectSize TInt objSize; - User::LeaveIfError(iRepository.Get(ESize, objSize)); + LEAVEIFERROR(iRepository.Get(ESize, objSize), + OstTrace0( TRACE_ERROR, CKNOWLEDGEOBJECT_LOADL, "Can't Load ObjectSize from iRepository!" )); iKnowledgeObjectSize = objSize; // Load DateModify iDateModified.Zero(); - User::LeaveIfError(iRepository.Get(EDateModified, iDateModified)); + LEAVEIFERROR(iRepository.Get(EDateModified, iDateModified), + OstTrace0( TRACE_ERROR, DUP1_CKNOWLEDGEOBJECT_LOADL, "Can't Load DateModify from iRepository!" )); // Load Name iName.Zero(); - User::LeaveIfError(iRepository.Get(EName, iName)); + LEAVEIFERROR(iRepository.Get(EName, iName), + OstTrace0( TRACE_ERROR, DUP2_CKNOWLEDGEOBJECT_LOADL, "Can't Load Name from iRepository!" )); // Load LastAuthorProxyID: TPtr8 writeBuf(NULL, 0); //walkaroud for the TMTPTypeUint128 iLastAuthorProxyID.FirstWriteChunk(writeBuf); - User::LeaveIfError(iRepository.Get(ELastAuthorProxyID, writeBuf)); + LEAVEIFERROR(iRepository.Get(ELastAuthorProxyID, writeBuf), + OstTrace0( TRACE_ERROR, DUP3_CKNOWLEDGEOBJECT_LOADL, "Can't Load LastAuthorProxyID from iRepository!" )); iDirty = EBitFlagNone; - __FLOG(_L8("CKnowledgeObject LoadL - Exit")); + OstTraceFunctionExit0( CKNOWLEDGEOBJECT_LOADL_EXIT ); return; } void CKnowledgeObject::Clear() { - __FLOG(_L8("CKnowledgeObject Clear - Entry")); + OstTraceFunctionEntry0( CKNOWLEDGEOBJECT_CLEAR_ENTRY ); iKnowledgeObjectSize = KObjectSizeNotAvaiable; iDateModified.Zero(); iName.Zero(); iLastAuthorProxyID.Set(KMTPUnInitialized64, KMTPUnInitialized64); iDirty = EBitFlagAll; - __FLOG(_L8("CKnowledgeObject Clear - Exit")); + OstTraceFunctionExit0( CKNOWLEDGEOBJECT_CLEAR_EXIT ); } void CKnowledgeObject::SetSize(TUint64 aSize) @@ -141,39 +146,43 @@ void CKnowledgeObject::CommitL() { - __FLOG(_L8("CKnowledgeObject CommitL - Entry")); + OstTraceFunctionEntry0( CKNOWLEDGEOBJECT_COMMITL_ENTRY ); if (EBitFlagSize == (iDirty & EBitFlagSize)) { // TUint64 -> TInt, some capability is lost, // anyway, it's enough for knowledge object. - User::LeaveIfError(iRepository.Set(ESize, (TInt)iKnowledgeObjectSize)); + LEAVEIFERROR(iRepository.Set(ESize, (TInt)iKnowledgeObjectSize), + OstTrace1( TRACE_ERROR, CKNOWLEDGEOBJECT_COMMITL, "set Size to %d failed against iRepository!", iKnowledgeObjectSize)); } if (EBitFlagName == (iDirty & EBitFlagName)) { - User::LeaveIfError(iRepository.Set(EName, iName)); + LEAVEIFERROR(iRepository.Set(EName, iName), + OstTraceExt1( TRACE_ERROR, DUP1_CKNOWLEDGEOBJECT_COMMITL, "set name to %S failed against iRepository!", iName)); } if (EBitFlagLastAuthorProxyID == (iDirty & EBitFlagLastAuthorProxyID)) { if (EMTPRespCodeOK != SetColumnType128Value(ELastAuthorProxyID, iLastAuthorProxyID)) { + OstTrace0( TRACE_ERROR, DUP2_CKNOWLEDGEOBJECT_COMMITL, "set LastAuthorProxyID failed!" ); User::Leave(KErrGeneral); } } // update DateModified to be the time of Commit RefreshDateModifed(); - User::LeaveIfError(iRepository.Set(EDateModified, iDateModified)); + LEAVEIFERROR(iRepository.Set(EDateModified, iDateModified), + OstTraceExt1( TRACE_ERROR, DUP3_CKNOWLEDGEOBJECT_COMMITL, "set DateModified to %S failed against iRepository!", iDateModified)); iDirty = EBitFlagNone; - __FLOG(_L8("CKnowledgeObject KnowledgeObject CommitL - Exit")); + OstTraceFunctionExit0( CKNOWLEDGEOBJECT_COMMITL_EXIT ); return; } TMTPResponseCode CKnowledgeObject::SetColumnType128Value(TMTPKnowledgeStoreKeyNum aColumnNum, TMTPTypeUint128& aNewData) { - __FLOG(_L8("CKnowledgeObject SetColumnType128ValueL - Entry")); + OstTraceFunctionEntry0( CKNOWLEDGEOBJECT_SETCOLUMNTYPE128VALUE_ENTRY ); TInt ret; TMTPResponseCode responseCode = EMTPRespCodeOK; TBuf8 data; @@ -198,21 +207,22 @@ { responseCode = EMTPRespCodeGeneralError; } - __FLOG_VA((_L8("CKnowledgeObject SetColumnType128ValueL - Exit with responseCode = 0x%04X"), responseCode)); + OstTraceFunctionExit0( CKNOWLEDGEOBJECT_SETCOLUMNTYPE128VALUE_EXIT ); + OstTrace1( TRACE_NORMAL, CKNOWLEDGEOBJECT_SETCOLUMNTYPE128VALUE, "responseCode = 0x%04X", responseCode ); return responseCode; } void CKnowledgeObject::RefreshDateModifed() { - __FLOG(_L8("CKnowledgeObject RefreshDateModifed - Entry")); + OstTraceFunctionEntry0( CKNOWLEDGEOBJECT_REFRESHDATEMODIFED_ENTRY ); //get current time TTime now; now.UniversalTime(); _LIT(KFormat,"%F%Y%M%DT%H%T%SZ"); iDateModified.Zero(); now.FormatL(iDateModified, KFormat); - __FLOG(_L8("CKnowledgeObject RefreshDateModifed - Exit")); + OstTraceFunctionExit0( CKNOWLEDGEOBJECT_REFRESHDATEMODIFED_EXIT ); return; } @@ -228,12 +238,11 @@ EXPORT_C CMTPKnowledgeHandler::~CMTPKnowledgeHandler() { - __FLOG(_L8("~CMTPKnowledgeHandler - Entry")); + OstTraceFunctionEntry0( CMTPKNOWLEDGEHANDLER_CMTPKNOWLEDGEHANDLER_DES_ENTRY ); delete iKnowledgeObj; delete iKnowledgeSwpBuffer; delete iCachedKnowledgeObject; - __FLOG(_L8("~CMTPKnowledgeHandler - Exit")); - __FLOG_CLOSE; + OstTraceFunctionExit0( CMTPKNOWLEDGEHANDLER_CMTPKNOWLEDGEHANDLER_DES_EXIT ); } CMTPKnowledgeHandler::CMTPKnowledgeHandler(MMTPDataProviderFramework& aFramework, TUint16 aFormatCode, @@ -244,8 +253,7 @@ void CMTPKnowledgeHandler::ConstructL() { - __FLOG_OPEN(KMTPSubsystem, KComponent); - __FLOG(_L8("Construct - Entry")); + OstTraceFunctionEntry0( CMTPKNOWLEDGEHANDLER_CONSTRUCTL_ENTRY ); iFramework.Fs().PrivatePath(iKnowObjFileName); iKnowObjFileName.Insert(0, KMTPKnowledgeObjDriveLocation); @@ -265,13 +273,14 @@ if(BaflUtils::FileExists(iFramework.Fs(), iKnowObjSwpFileName)) { // In case DP received some object content - User::LeaveIfError(iFramework.Fs().Delete(iKnowObjSwpFileName)); + LEAVEIFERROR(iFramework.Fs().Delete(iKnowObjSwpFileName), + OstTraceExt1( TRACE_ERROR, CMTPKNOWLEDGEHANDLER_CONSTRUCTL, "delete %S failed!", iKnowObjSwpFileName )); } // create and load knowledge object properties iCachedKnowledgeObject = CKnowledgeObject::NewL(iRepository); iCachedKnowledgeObject->LoadL(); - __FLOG(_L8("ConstructL - Exit")); + OstTraceFunctionExit0( CMTPKNOWLEDGEHANDLER_CONSTRUCTL_EXIT ); } EXPORT_C void CMTPKnowledgeHandler::SetStorageId(TUint32 aStorageId) @@ -281,8 +290,10 @@ void CMTPKnowledgeHandler::CommitL() { - __FLOG(_L8("CommitL - Entry")); - User::LeaveIfError(iRepository.StartTransaction(CRepository::EReadWriteTransaction)); + OstTraceFunctionEntry0( CMTPKNOWLEDGEHANDLER_COMMITL_ENTRY ); + LEAVEIFERROR(iRepository.StartTransaction(CRepository::EReadWriteTransaction), + OstTrace0( TRACE_ERROR, CMTPKNOWLEDGEHANDLER_COMMITL, "start readwrite transaction for iRepository failed!")); + iRepository.CleanupCancelTransactionPushL(); iCachedKnowledgeObject->CommitL(); @@ -300,47 +311,55 @@ iKnowledgeSwpBuffer = NULL; } - if(BaflUtils::FileExists(iFramework.Fs(), iKnowObjSwpFileName)) + if(BaflUtils::FileExists(iFramework.Fs(), iKnowObjSwpFileName) && iCachedKnowledgeObject->Size() > 0) { // In case DP received some object content - User::LeaveIfError(iFramework.Fs().Replace(iKnowObjSwpFileName, iKnowObjFileName)); + LEAVEIFERROR(iFramework.Fs().Replace(iKnowObjSwpFileName, iKnowObjFileName), + OstTraceExt2( TRACE_ERROR, DUP1_CMTPKNOWLEDGEHANDLER_COMMITL, + "replace %S with %S failed!", iKnowObjSwpFileName, iKnowObjFileName)); } // If swp file isn't exsited, that means 0 sized object received, need do nothing. TUint32 keyInfo; - User::LeaveIfError(iRepository.CommitTransaction(keyInfo)); + LEAVEIFERROR(iRepository.CommitTransaction(keyInfo), + OstTrace1( TRACE_ERROR, DUP2_CMTPKNOWLEDGEHANDLER_COMMITL, + "Commits transaction failed. The number of keys whose values were modified is %d", keyInfo)); + + CleanupStack::Pop(&iRepository); - __FLOG(_L8("CommitL - Exit")); + OstTraceFunctionExit0( CMTPKNOWLEDGEHANDLER_COMMITL_EXIT ); } void CMTPKnowledgeHandler::CommitForNewObjectL(TDes& aSuid) { + OstTraceFunctionEntry0( CMTPKNOWLEDGEHANDLER_COMMITFORNEWOBJECTL_ENTRY ); aSuid = iSuid; CommitL(); + OstTraceFunctionExit0( CMTPKNOWLEDGEHANDLER_COMMITFORNEWOBJECTL_EXIT ); } void CMTPKnowledgeHandler::RollBack() { - __FLOG(_L8("Rollback - Entry")); + OstTraceFunctionEntry0( CMTPKNOWLEDGEHANDLER_ROLLBACK_ENTRY ); iCachedKnowledgeObject->Clear(); TRAP_IGNORE(iCachedKnowledgeObject->LoadL()); - __FLOG(_L8("Rollback - Exit")); + OstTraceFunctionExit0( CMTPKNOWLEDGEHANDLER_ROLLBACK_EXIT ); } EXPORT_C void CMTPKnowledgeHandler::GetObjectSuidL(TDes& aSuid) const { - __FLOG(_L8("GetObjectSuidL - Entry")); + OstTraceFunctionEntry0( CMTPKNOWLEDGEHANDLER_GETOBJECTSUIDL_ENTRY ); if(iCachedKnowledgeObject->Size() != KObjectSizeNotAvaiable) { aSuid.Append(iSuid); } - __FLOG(_L8("GetObjectSuidL - Exit")); + OstTraceFunctionExit0( CMTPKNOWLEDGEHANDLER_GETOBJECTSUIDL_EXIT ); } TMTPResponseCode CMTPKnowledgeHandler::SendObjectInfoL(const CMTPTypeObjectInfo& aObjectInfo, TUint32& aParentHandle, TDes& aSuid) { - __FLOG(_L("SendObjectInfoL - Entry")); + OstTraceFunctionEntry0( CMTPKNOWLEDGEHANDLER_SENDOBJECTINFOL_ENTRY ); TMTPResponseCode responseCode = EMTPRespCodeOK; if (aParentHandle != KMTPHandleNone && aParentHandle != KMTPHandleNoParent) { @@ -351,7 +370,7 @@ //if there's a read error reread if(iCachedKnowledgeObject->IsDirty()) { - __FLOG(_L8("Warning: The cached knowledge is dirty")); + OstTrace0( TRACE_WARNING, CMTPKNOWLEDGEHANDLER_SENDOBJECTINFOL, "The cached knowledge is dirty" ); iCachedKnowledgeObject->Clear(); iCachedKnowledgeObject->LoadL(); } @@ -368,14 +387,14 @@ aSuid = iSuid; } } - __FLOG(_L("SendObjectInfoL - Exit")); + OstTraceFunctionExit0( CMTPKNOWLEDGEHANDLER_SENDOBJECTINFOL_EXIT ); return responseCode; } TMTPResponseCode CMTPKnowledgeHandler::SendObjectPropListL(TUint64 aObjectSize, const CMTPTypeObjectPropList& /*aObjectPropList*/, TUint32& aParentHandle, TDes& aSuid) { - __FLOG(_L8("SendObjectPropListL - Entry")); + OstTraceFunctionEntry0( CMTPKNOWLEDGEHANDLER_SENDOBJECTPROPLISTL_ENTRY ); TMTPResponseCode responseCode = EMTPRespCodeOK; if (aParentHandle != KMTPHandleNone && aParentHandle != KMTPHandleNoParent) { @@ -387,7 +406,7 @@ aParentHandle = KMTPHandleNoParent; if(iCachedKnowledgeObject->IsDirty()) { - __FLOG(_L8("Warning: The cached knowledge is dirty")); + OstTrace0( TRACE_WARNING, CMTPKNOWLEDGEHANDLER_SENDOBJECTPROPLISTL, "The cached knowledge is dirty" ); iCachedKnowledgeObject->Clear(); iCachedKnowledgeObject->LoadL(); } @@ -403,21 +422,21 @@ aSuid = iSuid; } } - __FLOG(_L8("SendObjectPropListL - Exit")); + OstTraceFunctionExit0( CMTPKNOWLEDGEHANDLER_SENDOBJECTPROPLISTL_EXIT ); return responseCode; } TMTPResponseCode CMTPKnowledgeHandler::GetObjectPropertyL(const CMTPObjectMetaData& aObjectMetaData, TUint16 aPropertyCode, CMTPTypeObjectPropList& aPropList) { - __FLOG(_L8("GetObjectPropertyL - Entry")); + OstTraceFunctionEntry0( CMTPKNOWLEDGEHANDLER_GETOBJECTPROPERTYL_ENTRY ); TMTPResponseCode responseCode = EMTPRespCodeOK; CMTPTypeObjectPropListElement* propertyElement = NULL; TUint32 aHandle = aObjectMetaData.Uint(CMTPObjectMetaData::EHandle); if(iCachedKnowledgeObject->IsDirty()) { - __FLOG(_L8("Warning: The cached knowledge is dirty")); + OstTrace0( TRACE_WARNING, CMTPKNOWLEDGEHANDLER_GETOBJECTPROPERTYL, "The cached knowledge is dirty" ); iCachedKnowledgeObject->LoadL(); } @@ -524,7 +543,7 @@ { aPropList.CommitPropElemL(*propertyElement); } - __FLOG(_L8("GetObjectPropertyL - Exit")); + OstTraceFunctionExit0( CMTPKNOWLEDGEHANDLER_GETOBJECTPROPERTYL_EXIT ); return responseCode; } @@ -532,7 +551,7 @@ const CMTPTypeObjectPropListElement& aElement, TMTPOperationCode aOperationCode) { - __FLOG(_L8("SetObjectPropertyL - Entry")); + OstTraceFunctionEntry0( CMTPKNOWLEDGEHANDLER_SETOBJECTPROPERTYL_ENTRY ); TMTPResponseCode responseCode = CheckGenObjectPropertyL(aElement, aOperationCode); if (responseCode == EMTPRespCodeOK) { @@ -569,16 +588,17 @@ break; } } - __FLOG(_L8("SetObjectPropertyL - Exit")); + OstTraceFunctionExit0( CMTPKNOWLEDGEHANDLER_SETOBJECTPROPERTYL_EXIT ); return responseCode; } // Remove the knowledge object TMTPResponseCode CMTPKnowledgeHandler::DeleteObjectL(const CMTPObjectMetaData& /*aObjectMetaData*/) { - __FLOG(_L8("DeleteObjectL - Entry")); + OstTraceFunctionEntry0( CMTPKNOWLEDGEHANDLER_DELETEOBJECTL_ENTRY ); - User::LeaveIfError(iRepository.StartTransaction(CRepository::EReadWriteTransaction)); + LEAVEIFERROR(iRepository.StartTransaction(CRepository::EReadWriteTransaction), + OstTrace0( TRACE_ERROR, CMTPKNOWLEDGEHANDLER_DELETEOBJECTL, "Start readwrite transaction failed!")); iRepository.CleanupCancelTransactionPushL(); // Delete obejct properties in transaction, if leave, mgr will rollback all properties. @@ -595,26 +615,31 @@ // Keep file delete is atomic. if (BaflUtils::FileExists(iFramework.Fs(), iKnowObjFileName)) { - User::LeaveIfError(iFramework.Fs().Delete(iKnowObjFileName)); + LEAVEIFERROR(iFramework.Fs().Delete(iKnowObjFileName), + OstTraceExt1( TRACE_ERROR, DUP1_CMTPKNOWLEDGEHANDLER_DELETEOBJECTL, "delete %S failed!", iKnowObjFileName)); } TUint32 keyInfo; - User::LeaveIfError(iRepository.CommitTransaction(keyInfo)); + LEAVEIFERROR(iRepository.CommitTransaction(keyInfo), + OstTrace1( TRACE_ERROR, DUP2_CMTPKNOWLEDGEHANDLER_DELETEOBJECTL, + "Commits transaction failed. The number of keys whose values were modified is %d", keyInfo)); + CleanupStack::Pop(&iRepository); - __FLOG(_L8("DeleteObjectL - Exit")); + OstTraceFunctionExit0( CMTPKNOWLEDGEHANDLER_DELETEOBJECTL_EXIT ); return EMTPRespCodeOK; } // Return the knowledge object content TMTPResponseCode CMTPKnowledgeHandler::GetObjectL(const CMTPObjectMetaData& /*aObjectMetaData*/, MMTPType** aBuffer) { - __FLOG(_L8("GetObjectL - Entry")); + OstTraceFunctionEntry0( CMTPKNOWLEDGEHANDLER_GETOBJECTL_ENTRY ); if (!BaflUtils::FileExists(iFramework.Fs(), iKnowObjFileName)) { RFile file; CleanupClosePushL(file); - User::LeaveIfError(file.Create(iFramework.Fs(), iKnowObjFileName, EFileRead)); + LEAVEIFERROR(file.Create(iFramework.Fs(), iKnowObjFileName, EFileRead), + OstTraceExt1( TRACE_ERROR, CMTPKNOWLEDGEHANDLER_GETOBJECTL, "Create readonly %S failed!", iKnowObjFileName)); CleanupStack::PopAndDestroy(&file); } @@ -625,13 +650,13 @@ iKnowledgeObj = CMTPTypeFile::NewL(iFramework.Fs(), iKnowObjFileName, EFileRead); } *aBuffer = iKnowledgeObj; - __FLOG(_L8("GetObjectL - Exit")); + OstTraceFunctionExit0( CMTPKNOWLEDGEHANDLER_GETOBJECTL_EXIT ); return EMTPRespCodeOK; } TMTPResponseCode CMTPKnowledgeHandler::DeleteObjectPropertyL(const CMTPObjectMetaData& /*aObjectMetaData*/, const TUint16 aPropertyCode) { - __FLOG(_L8("DeleteObjectPropertyL - Entry")); + OstTraceFunctionEntry0( CMTPKNOWLEDGEHANDLER_DELETEOBJECTPROPERTYL_ENTRY ); TMTPResponseCode responseCode = EMTPRespCodeOK; switch (aPropertyCode) { @@ -660,13 +685,13 @@ responseCode = EMTPRespCodeInvalidObjectPropCode; break; } - __FLOG(_L8("DeleteObjectPropertyL - Exit")); + OstTraceFunctionExit0( CMTPKNOWLEDGEHANDLER_DELETEOBJECTPROPERTYL_EXIT ); return responseCode; } TMTPResponseCode CMTPKnowledgeHandler::GetBufferForSendObjectL(const CMTPObjectMetaData& /*aObjectMetaData*/, MMTPType** aBuffer) { - __FLOG(_L8("GetBufferForSendObjectL - Entry")); + OstTraceFunctionEntry0( CMTPKNOWLEDGEHANDLER_GETBUFFERFORSENDOBJECTL_ENTRY ); if (iKnowledgeSwpBuffer) { delete iKnowledgeSwpBuffer; @@ -675,12 +700,13 @@ iKnowledgeSwpBuffer = CMTPTypeFile::NewL(iFramework.Fs(), iKnowObjSwpFileName, EFileWrite); iKnowledgeSwpBuffer->SetSizeL(0); *aBuffer = iKnowledgeSwpBuffer; - __FLOG(_L8("GetBufferForSendObjectL - Exit")); + OstTraceFunctionExit0( CMTPKNOWLEDGEHANDLER_GETBUFFERFORSENDOBJECTL_EXIT ); return EMTPRespCodeOK; } void CMTPKnowledgeHandler::BuildObjectInfoL(CMTPTypeObjectInfo& aObjectInfo) const { + OstTraceFunctionEntry0( CMTPKNOWLEDGEHANDLER_BUILDOBJECTINFOL_ENTRY ); aObjectInfo.SetUint32L(CMTPTypeObjectInfo::EStorageID, iStorageID); aObjectInfo.SetUint16L(CMTPTypeObjectInfo::EObjectFormat, iKnowledgeFormatCode); // Not use @@ -701,46 +727,48 @@ aObjectInfo.SetStringL(CMTPTypeObjectInfo::EDateModified, KNullDesC); aObjectInfo.SetStringL(CMTPTypeObjectInfo::EDateCreated, KNullDesC); aObjectInfo.SetStringL(CMTPTypeObjectInfo::EKeywords, KNullDesC); + OstTraceFunctionExit0( CMTPKNOWLEDGEHANDLER_BUILDOBJECTINFOL_EXIT ); } TMTPResponseCode CMTPKnowledgeHandler::GetObjectInfoL(const CMTPObjectMetaData& /*aObjectMetaData*/, CMTPTypeObjectInfo& aObjectInfo) { - __FLOG(_L8("GetObjectInfoL - Entry")); + OstTraceFunctionEntry0( CMTPKNOWLEDGEHANDLER_GETOBJECTINFOL_ENTRY ); if(iCachedKnowledgeObject->Size() != KObjectSizeNotAvaiable) { BuildObjectInfoL(aObjectInfo); } - __FLOG(_L8("GetObjectInfoL - Exit")); + OstTraceFunctionExit0( CMTPKNOWLEDGEHANDLER_GETOBJECTINFOL_EXIT ); return EMTPRespCodeOK; } void CMTPKnowledgeHandler::ReleaseObjectBuffer() { - __FLOG(_L8("ReleaseObjectBuffer - Entry")); + OstTraceFunctionEntry0( CMTPKNOWLEDGEHANDLER_RELEASEOBJECTBUFFER_ENTRY ); if (iKnowledgeObj) { delete iKnowledgeObj; iKnowledgeObj = NULL; } - __FLOG(_L8("ReleaseObjectBuffer - Exit")); + OstTraceFunctionExit0( CMTPKNOWLEDGEHANDLER_RELEASEOBJECTBUFFER_EXIT ); } TMTPResponseCode CMTPKnowledgeHandler::GetObjectSizeL(const TDesC& aSuid, TUint64& aObjectSize) { - __FLOG(_L8("GetObjectSizeL - Entry")); + OstTraceFunctionEntry0( CMTPKNOWLEDGEHANDLER_GETOBJECTSIZEL_ENTRY ); if (aSuid != iSuid) { + OstTraceFunctionExit0( CMTPKNOWLEDGEHANDLER_GETOBJECTSIZEL_EXIT ); return EMTPRespCodeGeneralError; } aObjectSize = iCachedKnowledgeObject->Size(); - __FLOG(_L8("GetObjectSizeL - Exit")); + OstTraceFunctionExit0( DUP1_CMTPKNOWLEDGEHANDLER_GETOBJECTSIZEL_EXIT ); return EMTPRespCodeOK; } TMTPResponseCode CMTPKnowledgeHandler::GetAllObjectPropCodeByGroupL(TUint32 aGroupId, RArray& aPropCodes) { - __FLOG(_L8("GetAllObjectPropCodeByGroupL - Entry")); + OstTraceFunctionEntry0( CMTPKNOWLEDGEHANDLER_GETALLOBJECTPROPCODEBYGROUPL_ENTRY ); TMTPResponseCode responseCode = EMTPRespCodeOK; if (0 == aGroupId) { @@ -770,7 +798,7 @@ { responseCode = (TMTPResponseCode)0xA805; } - __FLOG(_L8("GetAllObjectPropCodeByGroupL - Exit")); + OstTraceFunctionExit0( CMTPKNOWLEDGEHANDLER_GETALLOBJECTPROPCODEBYGROUPL_EXIT ); return responseCode; }