diff -r 2b4b06654caa -r 6257223ede8a imagehandlingutilities/thumbnailmanager/thumbnailserver/src/thumbnailstore.cpp --- a/imagehandlingutilities/thumbnailmanager/thumbnailserver/src/thumbnailstore.cpp Thu Aug 19 10:13:51 2010 +0300 +++ b/imagehandlingutilities/thumbnailmanager/thumbnailserver/src/thumbnailstore.cpp Tue Aug 31 15:30:59 2010 +0300 @@ -33,6 +33,11 @@ #include "thumbnailpanic.h" #include "thumbnailmanagerconstants.h" #include "thumbnailserver.h" +#include "OstTraceDefinitions.h" +#ifdef OST_TRACE_COMPILER_IN_USE +#include "thumbnailstoreTraces.h" +#endif + _LIT8( KThumbnailSqlConfig, "page_size=32768; cache_size=64;" ); @@ -44,8 +49,8 @@ const TInt KStoreUnrecoverableErr = KErrCorrupt; // Database path without drive letter -//Symbian^3 v4 -_LIT( KThumbnailDatabaseName, ":[102830AB]thumbnail_v4.db" ); +//Symbian^4 v5 +_LIT( KThumbnailDatabaseName, ":[102830AB]thumbnail_v5.db" ); // Allow access to database only for the server process @@ -72,6 +77,7 @@ if (iDatabase.InTransaction()) { TN_DEBUG1( "RThumbnailTransaction::BeginL() - error: old transaction open!" ); + OstTrace0( TRACE_NORMAL, RTHUMBNAILTRANSACTION_BEGINL, "RThumbnailTransaction::BeginL - error: old transaction open!" ); __ASSERT_DEBUG(( !iDatabase.InTransaction() ), ThumbnailPanic( EThumbnailSQLTransaction )); // old transaction already open, don't open another @@ -91,6 +97,7 @@ #ifdef _DEBUG TPtrC errorMsg = iDatabase.LastErrorMessage(); TN_DEBUG3( "RThumbnailTransaction::BeginL() lastError %S, ret = %d" , &errorMsg, err); + OstTraceExt2( TRACE_NORMAL, DUP1_RTHUMBNAILTRANSACTION_BEGINL, "RThumbnailTransaction::BeginL - lastError;errorMsg=%S;err=%d", errorMsg, err ); #endif User::Leave( err ); } @@ -121,6 +128,7 @@ #ifdef _DEBUG TPtrC errorMsg = iDatabase.LastErrorMessage(); TN_DEBUG3( "RThumbnailTransaction::CommitL() lastError %S, ret = %d" , &errorMsg, ret); + OstTraceExt2( TRACE_NORMAL, DUP2_RTHUMBNAILTRANSACTION_BEGINL, "RThumbnailTransaction::BeginL - lastError;errorMsg=%S;ret=%d", errorMsg, ret ); #endif User::LeaveIfError( ret ); } @@ -150,6 +158,7 @@ else { TN_DEBUG1( "RThumbnailTransaction::Rollback() - automatic rollback already done!" ); + OstTrace0( TRACE_NORMAL, RTHUMBNAILTRANSACTION_ROLLBACK, "RThumbnailTransaction::Rollback - automatic rollback already done!" ); } } @@ -184,6 +193,7 @@ CThumbnailStore::~CThumbnailStore() { TN_DEBUG2( "CThumbnailStore::~CThumbnailStore() drive: %d", iDrive ); + OstTrace1( TRACE_NORMAL, CTHUMBNAILSTORE_CTHUMBNAILSTORE, "CThumbnailStore::~CThumbnailStore;iDrive=%d", iDrive ); if(iActivityManager) { @@ -215,6 +225,7 @@ iDatabase.Close(); TN_DEBUG1( "CThumbnailStore::~CThumbnailStore() - database closed" ); + OstTrace0( TRACE_NORMAL, DUP1_CTHUMBNAILSTORE_CTHUMBNAILSTORE, "CThumbnailStore::~CThumbnailStore - database closed" ); } // --------------------------------------------------------------------------- @@ -237,6 +248,7 @@ void CThumbnailStore::ConstructL() { TN_DEBUG1( "CThumbnailStore::ConstructL()" ); + OstTrace0( TRACE_NORMAL, CTHUMBNAILSTORE_CONSTRUCTL, "CThumbnailStore::ConstructL" ); #ifdef _DEBUG iThumbCounter = 0; @@ -257,6 +269,7 @@ CleanupStack::PopAndDestroy( databasePath ); TN_DEBUG2( "CThumbnailStore::ConstructL() drive: %d", iDrive ); + OstTrace1( TRACE_NORMAL, DUP1_CTHUMBNAILSTORE_CONSTRUCTL, "CThumbnailStore::ConstructL;iDrive=%d", iDrive ); OpenDatabaseL(); @@ -270,6 +283,7 @@ else { TN_DEBUG1( "CThumbnailStore::ConstructL() - read only, dymmy mode..." ); + OstTrace0( TRACE_NORMAL, DUP2_CTHUMBNAILSTORE_CONSTRUCTL, "CThumbnailStore::ConstructL - read only, dymmy mode..." ); iDeleteThumbs = EFalse; iCheckFilesExist = EFalse; iLastCheckedRowID = -1; @@ -282,6 +296,7 @@ TInt CThumbnailStore::OpenDatabaseFileL() { TN_DEBUG1( "CThumbnailStore::OpenDatabaseFile()" ); + OstTrace0( TRACE_NORMAL, CTHUMBNAILSTORE_OPENDATABASEFILEL, "CThumbnailStore::OpenDatabaseFileL" ); HBufC* databasePath = HBufC::NewLC( KMaxFileName ); TPtr pathPtr = databasePath->Des(); @@ -301,6 +316,7 @@ TInt CThumbnailStore::OpenDatabaseL( TBool aNewDatabase ) { TN_DEBUG2( "CThumbnailStore::OpenDatabaseL() drive: %d", iDrive ); + OstTrace1( TRACE_NORMAL, CTHUMBNAILSTORE_OPENDATABASEL, "CThumbnailStore::OpenDatabaseL;iDrive=%d", iDrive ); CloseStatements(); iDatabase.Close(); @@ -325,6 +341,7 @@ err = OpenDatabaseFileL(); TN_DEBUG2( "CThumbnailStore::OpenDatabaseL() -- err = %d", err); + OstTrace1( TRACE_NORMAL, DUP1_CTHUMBNAILSTORE_OPENDATABASEL, "CThumbnailStore::OpenDatabaseL;err=%d", err ); if ( err == KErrNone) { @@ -395,6 +412,7 @@ void CThumbnailStore::PrepareDbL() { TN_DEBUG1( "CThumbnailStore::PrepareDbL()" ); + OstTrace0( TRACE_NORMAL, CTHUMBNAILSTORE_PREPAREDBL, "CThumbnailStore::PrepareDbL" ); // add persistent tables CreateTablesL(); @@ -412,18 +430,22 @@ void CThumbnailStore::CreateTablesL() { TN_DEBUG1( "CThumbnailStore::CreateTablesL()" ); + OstTrace0( TRACE_NORMAL, CTHUMBNAILSTORE_CREATETABLESL, "CThumbnailStore::CreateTablesL" ); TInt err = KErrNone; err = iDatabase.Exec( KThumbnailCreateInfoTable ); TN_DEBUG2( "CThumbnailStore::CreateTablesL() KThumbnailCreateInfoTable err=%d", err ); + OstTrace1( TRACE_NORMAL, DUP1_CTHUMBNAILSTORE_CREATETABLESL, "CThumbnailStore::CreateTablesL - KThumbnailCreateInfoTable;err=%d", err ); User::LeaveIfError( err ); err = iDatabase.Exec( KThumbnailCreateInfoDataTable ); TN_DEBUG2( "CThumbnailStore::CreateTablesL() KThumbnailCreateInfoDataTable err=%d", err ); + OstTrace1( TRACE_NORMAL, DUP2_CTHUMBNAILSTORE_CREATETABLESL, "CThumbnailStore::CreateTablesL - KThumbnailCreateInfoDataTable;err=%d", err ); User::LeaveIfError( err ); err = iDatabase.Exec(KThumbnailDeletedTable); TN_DEBUG2( "CThumbnailStore::CreateTablesL() KThumbnailDeletedTable err=%d", err ); + OstTrace1( TRACE_NORMAL, DUP3_CTHUMBNAILSTORE_CREATETABLESL, "CThumbnailStore::CreateTablesL - KThumbnailDeletedTable;err=%d", err ); User::LeaveIfError( err ); err = iDatabase.Exec( KThumbnailCreateInfoTableIndex1 ); @@ -432,6 +454,7 @@ err = iDatabase.Exec(KThumbnailVersionTable); TN_DEBUG2( "CThumbnailStore::CreateTablesL() KThumbnailVersionTable err=%d", err ); + OstTrace1( TRACE_NORMAL, DUP4_CTHUMBNAILSTORE_CREATETABLESL, "CThumbnailStore::CreateTablesL;err=%d", err ); User::LeaveIfError( err ); } @@ -442,6 +465,7 @@ void CThumbnailStore::CreateTempTablesL() { TN_DEBUG1( "CThumbnailStore::CreateTempTablesL()" ); + OstTrace0( TRACE_NORMAL, CTHUMBNAILSTORE_CREATETEMPTABLESL, "CThumbnailStore::CreateTempTablesL" ); TInt err = iDatabase.Exec( KThumbnailCreateTempInfoTable ); @@ -450,6 +474,7 @@ { TPtrC errorMsg = iDatabase.LastErrorMessage(); TN_DEBUG2( "CThumbnailStore::PrepareDbL() KThumbnailCreateTempInfoTable %S" , &errorMsg); + OstTraceExt1( TRACE_NORMAL, DUP1_CTHUMBNAILSTORE_CREATETEMPTABLESL, "CThumbnailStore::CreateTempTablesL - KThumbnailCreateTempInfoTable;errorMsg=%S", errorMsg ); } #endif @@ -462,6 +487,7 @@ { TPtrC errorMsg = iDatabase.LastErrorMessage(); TN_DEBUG2( "CThumbnailStore::PrepareDbL() KThumbnailCreateTempInfoDataTable %S" , &errorMsg); + OstTraceExt1( TRACE_NORMAL, DUP2_CTHUMBNAILSTORE_CREATETEMPTABLESL, "CThumbnailStore::CreateTempTablesL - KThumbnailCreateTempInfoDataTable;errorMsg=%S", errorMsg ); } #endif @@ -471,6 +497,7 @@ void CThumbnailStore::RecreateDatabaseL(const TBool aDelete) { TN_DEBUG2( "CThumbnailStore::RecreateDatabaseL() drive: %d", iDrive ); + OstTrace1( TRACE_NORMAL, CTHUMBNAILSTORE_RECREATEDATABASEL, "CThumbnailStore::RecreateDatabaseL;iDrive=%d", iDrive ); TVolumeInfo volumeinfo; User::LeaveIfError( iFs.Volume(volumeinfo, iDrive) ); @@ -483,6 +510,7 @@ iUnrecoverable = ETrue; TN_DEBUG1( "CThumbnailStore::RecreateDatabaseL() database closed" ); + OstTrace0( TRACE_NORMAL, DUP1_CTHUMBNAILSTORE_RECREATEDATABASEL, "CThumbnailStore::RecreateDatabaseL - database closed" ); HBufC* databasePath = HBufC::NewLC( KMaxFileName ); TPtr pathPtr = databasePath->Des(); @@ -496,8 +524,10 @@ if(aDelete) { TN_DEBUG1( "CThumbnailStore::RecreateDatabaseL() delete database" ); + OstTrace0( TRACE_NORMAL, DUP2_CTHUMBNAILSTORE_RECREATEDATABASEL, "CThumbnailStore::RecreateDatabaseL - delete database" ); TInt del = iDatabase.Delete(pathPtr); TN_DEBUG2( "CThumbnailStore::RecreateDatabaseL() deleted database, err: %d", del ); + OstTrace0( TRACE_NORMAL, DUP4_CTHUMBNAILSTORE_RECREATEDATABASEL, "CThumbnailStore::RecreateDatabaseL" ); } const TDesC8& config = KThumbnailSqlConfig; @@ -508,8 +538,10 @@ // create new TN_DEBUG1( "CThumbnailStore::RecreateDatabaseL() create new" ); + OstTrace0( TRACE_FATAL, DUP3_CTHUMBNAILSTORE_RECREATEDATABASEL, "CThumbnailStore::RecreateDatabaseL - create new" ); TRAP(err, iDatabase.CreateL( pathPtr, securityPolicy, &config )); TN_DEBUG2( "CThumbnailStore::RecreateDatabaseL() -- database created, err = %d", err ); + OstTrace1( TRACE_FATAL, DUP5_CTHUMBNAILSTORE_RECREATEDATABASEL, "CThumbnailStore::RecreateDatabaseL;err=%d", err ); User::LeaveIfError(err); CleanupStack::PopAndDestroy( &securityPolicy ); @@ -518,6 +550,7 @@ TRAPD(prepareErr, PrepareDbL() ); TN_DEBUG2( "CThumbnailStore::RecreateDatabaseL() -- prepare tables, err = %d", prepareErr ); + OstTrace1( TRACE_FATAL, DUP6_CTHUMBNAILSTORE_RECREATEDATABASEL, "CThumbnailStore::RecreateDatabaseL - prepare tables;prepareErr=%d", prepareErr ); TInt mediaidErr(KErrNone); @@ -529,6 +562,7 @@ file.Close(); TN_DEBUG2( "CThumbnailStore::RecreateDatabaseL() -- mediaID file created, err = %d", mediaidErr ); + OstTrace1( TRACE_FATAL, DUP7_CTHUMBNAILSTORE_RECREATEDATABASEL, "CThumbnailStore::RecreateDatabaseL;mediaidErr=%d", mediaidErr ); } // delete db if not fully complete @@ -537,8 +571,10 @@ CloseStatements(); iDatabase.Close(); TN_DEBUG1( "CThumbnailStore::RecreateDatabaseL() delete database" ); + OstTrace0( TRACE_FATAL, DUP8_CTHUMBNAILSTORE_RECREATEDATABASEL, "CThumbnailStore::RecreateDatabaseL - delete database" ); TInt del = iDatabase.Delete(pathPtr); TN_DEBUG2( "CThumbnailStore::RecreateDatabaseL() deleted database, err: %d", del ); + OstTrace1( TRACE_FATAL, DUP9_CTHUMBNAILSTORE_RECREATEDATABASEL, "CThumbnailStore::RecreateDatabaseL - delete database;del=%d", del ); } User::LeaveIfError( prepareErr ); @@ -550,6 +586,7 @@ TInt CThumbnailStore::CheckRowIDs() { TN_DEBUG1( "CThumbnailStore::CheckRowIDs()"); + OstTrace0( TRACE_FATAL, CTHUMBNAILSTORE_CHECKROWIDS, "CThumbnailStore::CheckRowIDs" ); RSqlStatement stmt; TInt column = 0; @@ -562,6 +599,7 @@ { stmt.Close(); TN_DEBUG1( "CThumbnailStore::CheckRowIDs() KGetInfoRowID failed %d"); + OstTrace1( TRACE_FATAL, DUP1_CTHUMBNAILSTORE_CHECKROWIDS, "CThumbnailStore::CheckRowIDs KGetInfoRowID failed;ret=%d", ret ); return KErrNotSupported; } rowStatus = stmt.Next(); @@ -578,6 +616,7 @@ #ifdef _DEBUG TPtrC errorMsg2 = iDatabase.LastErrorMessage(); TN_DEBUG2( "RThumbnailTransaction::ResetThumbnailIDs() lastError %S, ret = %d" , &errorMsg2); + OstTraceExt1( TRACE_FATAL, DUP2_CTHUMBNAILSTORE_CHECKROWIDS, "CThumbnailStore::CheckRowIDs - lastError;errorMsg2=%S", errorMsg2 ); #endif return KErrNotSupported; } @@ -587,6 +626,7 @@ { stmt.Close(); TN_DEBUG1( "CThumbnailStore::CheckRowIDs() KGetDataRowID failed"); + OstTrace0( TRACE_FATAL, DUP3_CTHUMBNAILSTORE_CHECKROWIDS, "CThumbnailStore::CheckRowIDs - KGetDataRowID failed" ); return KErrNotSupported; } rowStatus = stmt.Next(); @@ -603,12 +643,15 @@ #ifdef _DEBUG TPtrC errorMsg2 = iDatabase.LastErrorMessage(); TN_DEBUG2( "RThumbnailTransaction::ResetThumbnailIDs() lastError %S, ret = %d" , &errorMsg2); + OstTraceExt1( TRACE_FATAL, DUP4_CTHUMBNAILSTORE_CHECKROWIDS, "CThumbnailStore::CheckRowIDs - lastError;errorMsg2=%S", errorMsg2 ); #endif return KErrNotSupported; } TN_DEBUG2( "CThumbnailStore::CheckRowIDsL() - inforows %Ld", inforows ); + OstTraceExt1( TRACE_FATAL, DUP5_CTHUMBNAILSTORE_CHECKROWIDS, "CThumbnailStore::CheckRowIDs;inforows=%g", inforows ); TN_DEBUG2( "CThumbnailStore::CheckRowIDsL() - datarows %Ld", datarows ); + OstTraceExt1( TRACE_FATAL, DUP6_CTHUMBNAILSTORE_CHECKROWIDS, "CThumbnailStore::CheckRowIDs;datarows=%Ld", datarows ); if( inforows != datarows ) { @@ -628,6 +671,7 @@ TInt CThumbnailStore::CheckVersion() { TN_DEBUG1( "CThumbnailStore::CheckVersion()" ); + OstTrace0( TRACE_FATAL, CTHUMBNAILSTORE_CHECKVERSION, "CThumbnailStore::CheckVersion" ); RSqlStatement stmt; TInt rowStatus = 0; @@ -640,6 +684,7 @@ { stmt.Close(); TN_DEBUG1( "CThumbnailStore::CheckVersion() unknown version" ); + OstTrace0( TRACE_FATAL, DUP1_CTHUMBNAILSTORE_CHECKVERSION, "CThumbnailStore::CheckVersion - unknown version" ); return KErrNotSupported; } @@ -658,6 +703,7 @@ #ifdef _DEBUG TPtrC errorMsg = iDatabase.LastErrorMessage(); TN_DEBUG2( "RThumbnailTransaction::CheckVersion() lastError %S, ret = %d" , &errorMsg); + OstTrace0( TRACE_FATAL, DUP2_CTHUMBNAILSTORE_CHECKVERSION, "CThumbnailStore::CheckVersion" ); #endif return ret; } @@ -669,6 +715,7 @@ else { TN_DEBUG1( "CThumbnailStore::CheckVersion() - wrong DB version" ); + OstTrace0( TRACE_FATAL, DUP3_CTHUMBNAILSTORE_CHECKVERSION, "CThumbnailStore::CheckVersion" ); return KErrNotSupported; } } @@ -680,6 +727,7 @@ TInt CThumbnailStore::CheckImei() { TN_DEBUG1( "CThumbnailStore::CheckImei()" ); + OstTrace0( TRACE_FATAL, CTHUMBNAILSTORE_CHECKIMEI, "CThumbnailStore::CheckImei" ); RSqlStatement stmt; TInt rowStatus = 0; @@ -691,6 +739,7 @@ { stmt.Close(); TN_DEBUG1( "CThumbnailStore::CheckImei() failed" ); + OstTrace0( TRACE_FATAL, DUP1_CTHUMBNAILSTORE_CHECKIMEI, "CThumbnailStore::CheckImei - failed" ); return KErrNotSupported; } @@ -709,6 +758,7 @@ #ifdef _DEBUG TPtrC errorMsg = iDatabase.LastErrorMessage(); TN_DEBUG2( "RThumbnailTransaction::CheckImei() lastError %S, ret = %d" , &errorMsg); + OstTraceExt1( TRACE_FATAL, DUP2_CTHUMBNAILSTORE_CHECKIMEI, "CThumbnailStore::CheckImei - lastError;errorMsg=%S", errorMsg ); #endif return ret; } @@ -720,6 +770,7 @@ else { TN_DEBUG1( "CThumbnailStore::CheckImei() mismatch" ); + OstTrace0( TRACE_FATAL, DUP3_CTHUMBNAILSTORE_CHECKIMEI, "CThumbnailStore::CheckImei - mismatch" ); return KErrNotSupported; } } @@ -731,6 +782,7 @@ TInt CThumbnailStore::CheckMediaIDL() { TN_DEBUG1( "CThumbnailStore::CheckMediaIDL()" ); + OstTrace0( TRACE_FATAL, CTHUMBNAILSTORE_CHECKMEDIAIDL, "CThumbnailStore::CheckMediaIDL" ); TVolumeInfo volumeinfo; User::LeaveIfError( iFs.Volume(volumeinfo, iDrive) ); @@ -744,6 +796,7 @@ TInt err = file.Create(iFs, mediaid, EFileShareReadersOrWriters ); file.Close(); TN_DEBUG2( "CThumbnailStore::CheckMediaIDL() -- mediaID file created, err = %d", err ); + OstTrace1( TRACE_FATAL, DUP1_CTHUMBNAILSTORE_CHECKMEDIAIDL, "CThumbnailStore::CheckMediaIDL - mediaID file created;err=%d", err ); return KErrNotSupported; } @@ -758,6 +811,7 @@ void CThumbnailStore::AddVersionAndImeiL() { TN_DEBUG1( "CThumbnailStore::AddVersionAndImei()" ); + OstTrace0( TRACE_FATAL, CTHUMBNAILSTORE_ADDVERSIONANDIMEIL, "CThumbnailStore::AddVersionAndImeiL" ); RSqlStatement stmt; CleanupClosePushL( stmt ); @@ -787,6 +841,7 @@ void CThumbnailStore::UpdateImeiL() { TN_DEBUG1( "CThumbnailStore::UpdateImeiL()" ); + OstTrace0( TRACE_FATAL, CTHUMBNAILSTORE_UPDATEIMEIL, "CThumbnailStore::UpdateImeiL" ); RSqlStatement stmt; CleanupClosePushL( stmt ); @@ -803,6 +858,7 @@ #ifdef _DEBUG TPtrC errorMsg = iDatabase.LastErrorMessage(); TN_DEBUG2( "RThumbnailTransaction::UpdateImeiL() lastError %S" , &errorMsg); + OstTraceExt1( TRACE_FATAL, DUP1_CTHUMBNAILSTORE_UPDATEIMEIL, "CThumbnailStore::UpdateImeiL - lastError;errorMsg=%S", errorMsg ); #endif User::Leave(err); } @@ -817,6 +873,7 @@ void CThumbnailStore::PrepareStatementsL() { TN_DEBUG1("CThumbnailStore::PrepareStatementsL()"); + OstTrace0( TRACE_FATAL, CTHUMBNAILSTORE_PREPARESTATEMENTSL, "CThumbnailStore::PrepareStatementsL" ); TInt err = KErrNone; #ifdef _DEBUG @@ -827,6 +884,7 @@ #ifdef _DEBUG msg.Append( iDatabase.LastErrorMessage() ); TN_DEBUG2( "CThumbnailStore::PrepareStatementsL() KThumbnailSelectInfoByPath %S" , &msg ); + OstTraceExt1( TRACE_FATAL, DUP1_CTHUMBNAILSTORE_PREPARESTATEMENTSL, "CThumbnailStore::PrepareStatementsL - KThumbnailSelectInfoByPath;msg=%S", msg ); msg.Zero(); #endif User::LeaveIfError( err ); @@ -835,6 +893,7 @@ #ifdef _DEBUG msg.Append( iDatabase.LastErrorMessage() ); TN_DEBUG2( "CThumbnailStore::PrepareStatementsL() KThumbnailSelectTempInfoByPath %S" , &msg ); + OstTraceExt1( TRACE_FATAL, DUP2_CTHUMBNAILSTORE_PREPARESTATEMENTSL, "CThumbnailStore::PrepareStatementsL - KThumbnailSelectTempInfoByPath;msg=%S", msg ); msg.Zero(); #endif User::LeaveIfError( err ); @@ -843,6 +902,7 @@ #ifdef _DEBUG msg.Append( iDatabase.LastErrorMessage() ); TN_DEBUG2( "CThumbnailStore::PrepareStatementsL() KThumbnailInsertTempThumbnailInfo %S" , &msg ); + OstTraceExt1( TRACE_FATAL, DUP3_CTHUMBNAILSTORE_PREPARESTATEMENTSL, "CThumbnailStore::PrepareStatementsL - KThumbnailInsertTempThumbnailInfo ;msg=%S", msg ); msg.Zero(); #endif User::LeaveIfError( err ); @@ -851,6 +911,7 @@ #ifdef _DEBUG msg.Append( iDatabase.LastErrorMessage() ); TN_DEBUG2( "CThumbnailStore::PrepareStatementsL() KThumbnailInsertTempThumbnailInfoData %S" , &msg ); + OstTraceExt1( TRACE_FATAL, DUP4_CTHUMBNAILSTORE_PREPARESTATEMENTSL, "CThumbnailStore::PrepareStatementsL - KThumbnailInsertTempThumbnailInfoData;msg=%S", msg ); msg.Zero(); #endif User::LeaveIfError( err ); @@ -859,6 +920,7 @@ #ifdef _DEBUG msg.Append( iDatabase.LastErrorMessage() ); TN_DEBUG2( "CThumbnailStore::PrepareStatementsL() KThumbnailSelectModifiedByPath %S" , &msg ); + OstTraceExt1( TRACE_FATAL, DUP5_CTHUMBNAILSTORE_PREPARESTATEMENTSL, "CThumbnailStore::PrepareStatementsL;msg=%S", msg ); msg.Zero(); #endif User::LeaveIfError( err ); @@ -867,6 +929,7 @@ #ifdef _DEBUG msg.Append( iDatabase.LastErrorMessage() ); TN_DEBUG2( "CThumbnailStore::PrepareStatementsL() KThumbnailSelectTempModifiedByPath %S" , &msg ); + OstTraceExt1( TRACE_FATAL, DUP6_CTHUMBNAILSTORE_PREPARESTATEMENTSL, "CThumbnailStore::PrepareStatementsL - KThumbnailSelectTempModifiedByPath;msg=%S", msg ); msg.Zero(); #endif User::LeaveIfError( err ); @@ -875,6 +938,7 @@ #ifdef _DEBUG msg.Append( iDatabase.LastErrorMessage() ); TN_DEBUG2( "CThumbnailStore::PrepareStatementsL() KThumbnailFindDuplicate %S" , &msg ); + OstTraceExt1( TRACE_FATAL, DUP7_CTHUMBNAILSTORE_PREPARESTATEMENTSL, "CThumbnailStore::PrepareStatementsL - KThumbnailFindDuplicate;msg=%S", msg ); msg.Zero(); #endif User::LeaveIfError( err ); @@ -883,6 +947,7 @@ #ifdef _DEBUG msg.Append( iDatabase.LastErrorMessage() ); TN_DEBUG2( "CThumbnailStore::PrepareStatementsL() KThumbnailTempFindDuplicate %S" , &msg ); + OstTraceExt1( TRACE_FATAL, DUP8_CTHUMBNAILSTORE_PREPARESTATEMENTSL, "CThumbnailStore::PrepareStatementsL - KThumbnailTempFindDuplicate;msg=%S", msg ); msg.Zero(); #endif User::LeaveIfError( err ); @@ -891,6 +956,7 @@ #ifdef _DEBUG msg.Append( iDatabase.LastErrorMessage() ); TN_DEBUG2( "CThumbnailStore::PrepareStatementsL() KThumbnailSqlFindDeleted %S" , &msg ); + OstTraceExt1( TRACE_FATAL, DUP9_CTHUMBNAILSTORE_PREPARESTATEMENTSL, "CThumbnailStore::PrepareStatementsL - KThumbnailSqlFindDeleted;msg=%S", msg ); msg.Zero(); #endif User::LeaveIfError( err ); @@ -899,6 +965,7 @@ #ifdef _DEBUG msg.Append( iDatabase.LastErrorMessage() ); TN_DEBUG2( "CThumbnailStore::PrepareStatementsL() KThumbnailSelectSizeByPath %S" , &msg ); + OstTraceExt1( TRACE_FATAL, DUP10_CTHUMBNAILSTORE_PREPARESTATEMENTSL, "CThumbnailStore::PrepareStatementsL - KThumbnailSelectSizeByPath;msg=%S", msg ); msg.Zero(); #endif User::LeaveIfError( err ); @@ -907,6 +974,7 @@ #ifdef _DEBUG msg.Append( iDatabase.LastErrorMessage() ); TN_DEBUG2( "CThumbnailStore::PrepareStatementsL() KThumbnailSelectTempSizeByPath %S" , &msg ); + OstTraceExt1( TRACE_FATAL, DUP11_CTHUMBNAILSTORE_PREPARESTATEMENTSL, "CThumbnailStore::PrepareStatementsL - KThumbnailSelectTempSizeByPath;msg=%S", msg ); msg.Zero(); #endif User::LeaveIfError( err ); @@ -915,6 +983,7 @@ #ifdef _DEBUG msg.Append( iDatabase.LastErrorMessage() ); TN_DEBUG2( "CThumbnailStore::PrepareStatementsL() KThumbnailSqlSelectRowIDInfoByPath %S" , &msg ); + OstTraceExt1( TRACE_FATAL, DUP12_CTHUMBNAILSTORE_PREPARESTATEMENTSL, "CThumbnailStore::PrepareStatementsL - KThumbnailSqlSelectRowIDInfoByPath;msg=%S", msg ); msg.Zero(); #endif User::LeaveIfError( err ); @@ -923,6 +992,7 @@ #ifdef _DEBUG msg.Append( iDatabase.LastErrorMessage() ); TN_DEBUG2( "CThumbnailStore::PrepareStatementsL() KThumbnailSqlDeleteInfoByPath %S" , &msg ); + OstTraceExt1( TRACE_FATAL, DUP13_CTHUMBNAILSTORE_PREPARESTATEMENTSL, "CThumbnailStore::PrepareStatementsL - KThumbnailSqlDeleteInfoByPath;msg=%S", msg ); msg.Zero(); #endif User::LeaveIfError( err ); @@ -931,6 +1001,7 @@ #ifdef _DEBUG msg.Append( iDatabase.LastErrorMessage() ); TN_DEBUG2( "CThumbnailStore::PrepareStatementsL() KThumbnailSqlDeleteInfoDataByPath %S" , &msg ); + OstTraceExt1( TRACE_FATAL, DUP14_CTHUMBNAILSTORE_PREPARESTATEMENTSL, "CThumbnailStore::PrepareStatementsL - KThumbnailSqlDeleteInfoDataByPath;msg=%S", msg ); msg.Zero(); #endif User::LeaveIfError( err ); @@ -939,6 +1010,7 @@ #ifdef _DEBUG msg.Append( iDatabase.LastErrorMessage() ); TN_DEBUG2( "CThumbnailStore::PrepareStatementsL() KTempThumbnailSqlSelectRowIDInfoByPath %S" , &msg ); + OstTraceExt1( TRACE_FATAL, DUP15_CTHUMBNAILSTORE_PREPARESTATEMENTSL, "CThumbnailStore::PrepareStatementsL - KTempThumbnailSqlSelectRowIDInfoByPath;msg=%S", msg ); msg.Zero(); #endif User::LeaveIfError( err ); @@ -947,6 +1019,7 @@ #ifdef _DEBUG msg.Append( iDatabase.LastErrorMessage() ); TN_DEBUG2( "CThumbnailStore::PrepareStatementsL() KTempThumbnailSqlDeleteInfoByPath %S" , &msg ); + OstTraceExt1( TRACE_FATAL, DUP16_CTHUMBNAILSTORE_PREPARESTATEMENTSL, "CThumbnailStore::PrepareStatementsL - KTempThumbnailSqlDeleteInfoByPath;msg=%S", msg ); msg.Zero(); #endif User::LeaveIfError( err ); @@ -955,6 +1028,7 @@ #ifdef _DEBUG msg.Append( iDatabase.LastErrorMessage() ); TN_DEBUG2( "CThumbnailStore::PrepareStatementsL() KTempThumbnailSqlDeleteInfoDataByPath %S" , &msg ); + OstTraceExt1( TRACE_FATAL, DUP17_CTHUMBNAILSTORE_PREPARESTATEMENTSL, "CThumbnailStore::PrepareStatementsL - KTempThumbnailSqlDeleteInfoDataByPath;msg=%S", msg ); msg.Zero(); #endif User::LeaveIfError( err ); @@ -963,6 +1037,7 @@ #ifdef _DEBUG msg.Append( iDatabase.LastErrorMessage() ); TN_DEBUG2( "CThumbnailStore::PrepareStatementsL() KThumbnailSqlInsertDeleted %S" , &msg ); + OstTraceExt1( TRACE_FATAL, DUP18_CTHUMBNAILSTORE_PREPARESTATEMENTSL, "CThumbnailStore::PrepareStatementsL - KThumbnailSqlInsertDeleted;msg=%S", msg ); msg.Zero(); #endif User::LeaveIfError( err ); @@ -971,6 +1046,7 @@ #ifdef _DEBUG msg.Append( iDatabase.LastErrorMessage() ); TN_DEBUG2( "CThumbnailStore::PrepareStatementsL() KThumbnailSqlSelectMarked %S" , &msg ); + OstTraceExt1( TRACE_NORMAL, DUP19_CTHUMBNAILSTORE_PREPARESTATEMENTSL, "CThumbnailStore::PrepareStatementsL - KThumbnailSqlSelectMarked;msg=%S", msg ); msg.Zero(); #endif User::LeaveIfError( err ); @@ -979,6 +1055,7 @@ #ifdef _DEBUG msg.Append( iDatabase.LastErrorMessage() ); TN_DEBUG2( "CThumbnailStore::PrepareStatementsL() KThumbnailSqlDeleteInfoByRowID %S" , &msg ); + OstTraceExt1( TRACE_NORMAL, DUP20_CTHUMBNAILSTORE_PREPARESTATEMENTSL, "CThumbnailStore::PrepareStatementsL - KThumbnailSqlDeleteInfoByRowID;msg=%S", msg ); msg.Zero(); #endif User::LeaveIfError( err ); @@ -987,6 +1064,7 @@ #ifdef _DEBUG msg.Append( iDatabase.LastErrorMessage() ); TN_DEBUG2( "CThumbnailStore::PrepareStatementsL() KThumbnailSqlDeleteInfoDataByRowID %S" , &msg ); + OstTraceExt1( TRACE_NORMAL, DUP21_CTHUMBNAILSTORE_PREPARESTATEMENTSL, "CThumbnailStore::PrepareStatementsL - KThumbnailSqlDeleteInfoDataByRowID;msg=%S", msg ); msg.Zero(); #endif User::LeaveIfError( err ); @@ -995,6 +1073,7 @@ #ifdef _DEBUG msg.Append( iDatabase.LastErrorMessage() ); TN_DEBUG2( "CThumbnailStore::PrepareStatementsL() KThumbnailSelectAllPaths %S" , &msg ); + OstTraceExt1( TRACE_NORMAL, DUP22_CTHUMBNAILSTORE_PREPARESTATEMENTSL, "CThumbnailStore::PrepareStatementsL - KThumbnailSelectAllPaths;msg=%S", msg ); msg.Zero(); #endif User::LeaveIfError( err ); @@ -1003,6 +1082,7 @@ #ifdef _DEBUG msg.Append( iDatabase.LastErrorMessage() ); TN_DEBUG2( "CThumbnailStore::PrepareStatementsL() KThumbnailRename %S" , &msg ); + OstTraceExt1( TRACE_NORMAL, DUP23_CTHUMBNAILSTORE_PREPARESTATEMENTSL, "CThumbnailStore::PrepareStatementsL - KThumbnailRename;msg=%S", msg ); msg.Zero(); #endif User::LeaveIfError( err ); @@ -1011,11 +1091,13 @@ #ifdef _DEBUG msg.Append( iDatabase.LastErrorMessage() ); TN_DEBUG2( "CThumbnailStore::PrepareStatementsL() KThumbnailTempRename %S" , &msg ); + OstTraceExt1( TRACE_NORMAL, DUP24_CTHUMBNAILSTORE_PREPARESTATEMENTSL, "CThumbnailStore::PrepareStatementsL - KThumbnailTempRename;msg=%S", msg ); msg.Zero(); #endif User::LeaveIfError( err ); TN_DEBUG1("CThumbnailStore::PrepareStatementsL() end"); + OstTrace0( TRACE_NORMAL, DUP25_CTHUMBNAILSTORE_PREPARESTATEMENTSL, "CThumbnailStore::PrepareStatementsL - end" ); } // --------------------------------------------------------------------------- @@ -1036,6 +1118,7 @@ void CThumbnailStore::CloseStatements() { TN_DEBUG1("CThumbnailStore::CloseStatements()"); + OstTrace0( TRACE_NORMAL, CTHUMBNAILSTORE_CLOSESTATEMENTS, "CThumbnailStore::CloseStatements" ); iStmt_KThumbnailSelectInfoByPath.Close(); iStmt_KThumbnailSelectTempInfoByPath.Close(); @@ -1063,6 +1146,7 @@ iStmt_KThumbnailTempRename.Close(); TN_DEBUG1("CThumbnailStore::CloseStatements() end"); + OstTrace0( TRACE_NORMAL, DUP1_CTHUMBNAILSTORE_CLOSESTATEMENTS, "CThumbnailStore::CloseStatements - end" ); } // --------------------------------------------------------------------------- @@ -1144,6 +1228,7 @@ TTime timeStamp; TN_DEBUG2( "CThumbnailStore::StoreThumbnailL( private ) timeStamp aModified %Ld", aModified ); + OstTraceExt1( TRACE_NORMAL, DUP2_CTHUMBNAILSTORE_STORETHUMBNAILL, "CThumbnailStore::StoreThumbnailL - timeStamp aModified;aModified=%Ld", aModified ); if( aModified ) { @@ -1166,10 +1251,12 @@ if (timeErr != KErrNone) { TN_DEBUG2( "CThumbnailStore::StoreThumbnailL( private ) error getting timeStamp: %d", timeErr ); + OstTrace1( TRACE_NORMAL, DUP1_CTHUMBNAILSTORE_STORETHUMBNAILL, "CThumbnailStore::StoreThumbnailL - error getting timeStamp;timeErr=%d", timeErr ); } else { TN_DEBUG2( "CThumbnailStore::StoreThumbnailL( private ) timeStamp iFs %Ld", timeStamp.Int64() ); + OstTraceExt1( TRACE_NORMAL, DUP3_CTHUMBNAILSTORE_STORETHUMBNAILL, "CThumbnailStore::StoreThumbnailL - timeStamp;timeStamp.Int64()=%Ld", timeStamp.Int64() ); } } @@ -1178,10 +1265,12 @@ // otherwise current time timeStamp.UniversalTime(); TN_DEBUG2( "CThumbnailStore::StoreThumbnailL( private ) timeStamp current %Ld", timeStamp.Int64() ); + OstTraceExt1( TRACE_NORMAL, DUP4_CTHUMBNAILSTORE_STORETHUMBNAILL, "CThumbnailStore::StoreThumbnailL - timeStamp current;timeStamp.Int64()=%Ld", timeStamp.Int64() ); } } TN_DEBUG2( "CThumbnailStore::StoreThumbnailL( private ) timeStamp set %Ld", timeStamp.Int64()); + OstTraceExt1( TRACE_NORMAL, DUP5_CTHUMBNAILSTORE_STORETHUMBNAILL, "CThumbnailStore::StoreThumbnailL - timeStamp set;timeStamp.Int64()=%Ld", timeStamp.Int64() ); paramIndex = stmt->ParameterIndex( KThumbnailSqlParamModified ); User::LeaveIfError( paramIndex ); @@ -1213,11 +1302,15 @@ #ifdef _DEBUG iThumbCounter++; TN_DEBUG2( "CThumbnailStore::THUMBSTORE-COUNTER----------, Thumbs = %d", iThumbCounter ); + OstTrace1( TRACE_NORMAL, DUP6_CTHUMBNAILSTORE_STORETHUMBNAILL, "CThumbnailStore::THUMBSTORE-COUNTER----------, Thumbs =;iThumbCounter=%d", iThumbCounter ); aStop.UniversalTime(); + TInt tookTime = aStop.MicroSecondsFrom(aStart).Int64()/1000; TN_DEBUG2( "CThumbnailStore::StoreThumbnailL( private ) insert to table %d ms", (TInt)aStop.MicroSecondsFrom(aStart).Int64()/1000); + OstTrace1( TRACE_NORMAL, DUP7_CTHUMBNAILSTORE_STORETHUMBNAILL, "CThumbnailStore::StoreThumbnailL - insert to table;tookTime=%d", tookTime ); #endif TN_DEBUG1( "CThumbnailStore::StoreThumbnailL( private ) out" ); + OstTrace0( TRACE_NORMAL, DUP8_CTHUMBNAILSTORE_STORETHUMBNAILL, "CThumbnailStore::StoreThumbnailL - out" ); } @@ -1232,7 +1325,7 @@ { TSize thumbSize = aThumbnail->SizeInPixels(); TN_DEBUG4( "CThumbnailStore::StoreThumbnailL( public ) aThumbnailSize = %d, aThumbnailSize(%d,%d) IN", aThumbnailSize, thumbSize.iWidth, thumbSize.iHeight ); - + OstTraceExt3( TRACE_NORMAL, DUP9_CTHUMBNAILSTORE_STORETHUMBNAILL, "CThumbnailStore::StoreThumbnailL - IN;aThumbnailSize=%u;thumbSize.iWidth=%d;thumbSize.iHeight=%d", aThumbnailSize, thumbSize.iWidth, thumbSize.iHeight ); if(iReadOnly) { TN_DEBUG1( "CThumbnailStore::StoreThumbnailL() read only, skip..." ); @@ -1248,6 +1341,7 @@ || thumbSize.iWidth <= 0 || thumbSize.iHeight <= 0 ) { TN_DEBUG1( "CThumbnailStore::StoreThumbnailL( public ) not stored"); + OstTrace0( TRACE_NORMAL, DUP10_CTHUMBNAILSTORE_STORETHUMBNAILL, "CThumbnailStore::StoreThumbnailL - not stored" ); return; } @@ -1280,6 +1374,7 @@ aThumbnailSize == EAudioFullScreenThumbnailSize) && !aBlackListed ) { TN_DEBUG1( "CThumbnailStore::StoreThumbnailL( public ) - encode jpg" ); + OstTrace0( TRACE_NORMAL, DUP11_CTHUMBNAILSTORE_STORETHUMBNAILL, "CThumbnailStore::StoreThumbnailL - encode jpg" ); HBufC8* data = NULL; CleanupStack::PushL( data ); @@ -1292,32 +1387,38 @@ if ( decErr != KErrNone ) { TN_DEBUG2( "CThumbnailStore::StoreThumbnailL( public ) - HW CExtJpegEncoder failed %d", decErr); + OstTrace1( TRACE_NORMAL, DUP12_CTHUMBNAILSTORE_STORETHUMBNAILL, "CThumbnailStore::StoreThumbnailL - HW CExtJpegEncoder failed;decErr=%d", decErr ); TRAPD( decErr, encoder = CExtJpegEncoder::DataNewL( CExtJpegEncoder::ESwImplementation, data, options ) ); if ( decErr != KErrNone ) { TN_DEBUG2( "CThumbnailStore::StoreThumbnailL( public ) - SW CExtJpegEncoder failed %d", decErr); + OstTrace1( TRACE_NORMAL, DUP13_CTHUMBNAILSTORE_STORETHUMBNAILL, "CThumbnailStore::StoreThumbnailL - SW CExtJpegEncoder failed;decErr=%d", decErr ); TRAPD( decErr, encoder = CImageEncoder::DataNewL( data, KJpegMime(), options ) ); if ( decErr != KErrNone ) { TN_DEBUG2( "CThumbnailStore::StoreThumbnailL( public ) - CImageEncoder failed %d", decErr); + OstTrace1( TRACE_NORMAL, DUP14_CTHUMBNAILSTORE_STORETHUMBNAILL, "CThumbnailStore::StoreThumbnailL - CImageEncoder failed;decErr=%d", decErr ); User::Leave(decErr); } else { TN_DEBUG1( "CThumbnailStore::StoreThumbnailL( public ) - CImageEncoder created" ); + OstTrace0( TRACE_NORMAL, DUP15_CTHUMBNAILSTORE_STORETHUMBNAILL, "CThumbnailStore::StoreThumbnailL - CImageEncoder created" ); } } else { TN_DEBUG1( "CThumbnailStore::StoreThumbnailL( public ) - SW CExtJpegEncoder created" ); + OstTrace0( TRACE_NORMAL, DUP16_CTHUMBNAILSTORE_STORETHUMBNAILL, "CThumbnailStore::StoreThumbnailL - SW CExtJpegEncoder created" ); } } else { TN_DEBUG1( "CThumbnailStore::StoreThumbnailL( public ) - HW CExtJpegEncoder created" ); + OstTrace0( TRACE_NORMAL, DUP17_CTHUMBNAILSTORE_STORETHUMBNAILL, "CThumbnailStore::StoreThumbnailL - HW CExtJpegEncoder created" ); } CleanupStack::Pop( data ); @@ -1354,6 +1455,7 @@ if(request == KErrNone) { TN_DEBUG1( "CThumbnailStore::StoreThumbnailL( public ) - encoding ok" ); + OstTrace0( TRACE_NORMAL, DUP18_CTHUMBNAILSTORE_STORETHUMBNAILL, "CThumbnailStore::StoreThumbnailL - encoding ok" ); CleanupStack::PushL( data ); TPtr8 ptr = data->Des(); @@ -1365,6 +1467,7 @@ else { TN_DEBUG2( "CThumbnailStore::StoreThumbnailL( public ) - encoding failed: %d", request.Int() ); + OstTrace1( TRACE_NORMAL, DUP19_CTHUMBNAILSTORE_STORETHUMBNAILL, "CThumbnailStore::StoreThumbnailL - encoding failed;request.Int()=%d", request.Int() ); } delete data; @@ -1392,6 +1495,7 @@ CleanupStack::PopAndDestroy( path ); TN_DEBUG1( "CThumbnailStore::StoreThumbnailL( public ) out" ); + OstTrace0( TRACE_NORMAL, DUP20_CTHUMBNAILSTORE_STORETHUMBNAILL, "CThumbnailStore::StoreThumbnailL - out" ); } // --------------------------------------------------------------------------- @@ -1401,7 +1505,7 @@ TBool CThumbnailStore::FindDuplicateL( const TDesC& aPath, const TThumbnailSize& aThumbnailSize ) { TN_DEBUG1( "CThumbnailStore::FindDuplicateL()" ); - + OstTrace0( TRACE_NORMAL, CTHUMBNAILSTORE_FINDDUPLICATEL, "CThumbnailStore::FindDuplicateL" ); if(iReadOnly) { TN_DEBUG1( "CThumbnailStore::FindDuplicateL() read only, skip..." ); @@ -1448,17 +1552,20 @@ if(rowStatus == KSqlAtRow) { TN_DEBUG1( "CThumbnailStore::FindDuplicateL() - duplicate in main table" ); + OstTrace0( TRACE_NORMAL, DUP1_CTHUMBNAILSTORE_FINDDUPLICATEL, "CThumbnailStore::FindDuplicateL - duplicate in main table" ); found = ETrue; } else { TN_DEBUG1( "CThumbnailStore::FindDuplicateL() - no duplicate" ); + OstTrace0( TRACE_NORMAL, DUP2_CTHUMBNAILSTORE_FINDDUPLICATEL, "CThumbnailStore::FindDuplicateL - no duplicate" ); } } else { TN_DEBUG1( "CThumbnailStore::FindDuplicateL() - duplicate in temp table" ); + OstTrace0( TRACE_NORMAL, DUP3_CTHUMBNAILSTORE_FINDDUPLICATEL, "CThumbnailStore::FindDuplicateL - duplicate in temp table" ); found = ETrue; } @@ -1482,10 +1589,12 @@ if(rowStatus == KSqlAtRow) { TN_DEBUG1( "CThumbnailStore::FindDuplicateL() - duplicate marked deleted" ); + OstTrace0( TRACE_NORMAL, DUP4_CTHUMBNAILSTORE_FINDDUPLICATEL, "CThumbnailStore::FindDuplicateL - duplicate marked deleted" ); DeleteThumbnailsL(aPath, ETrue); TN_DEBUG1( "CThumbnailStore::FindDuplicateL() - duplicate force-deleted" ); + OstTrace0( TRACE_NORMAL, DUP5_CTHUMBNAILSTORE_FINDDUPLICATEL, "CThumbnailStore::FindDuplicateL - duplicate force-deleted" ); found = EFalse; } @@ -1502,7 +1611,7 @@ TThumbnailPersistentSize > & aMissingSizes, TBool aCheckGridSizeOnly ) { TN_DEBUG2( "CThumbnailStore::GetMissingSizesL() aSourceType == %d", aSourceType ); - + OstTrace1( TRACE_NORMAL, CTHUMBNAILSTORE_GETMISSINGSIZESL, "CThumbnailStore::GetMissingSizesL;aSourceType=%d", aSourceType ); if(iReadOnly) { TN_DEBUG1( "CThumbnailStore::GetMissingSizesL() read only, skip..." ); @@ -1530,6 +1639,7 @@ { TN_DEBUG4( "CThumbnailStore::GetMissingSizesL() skip, aCheckGridSizeOnly = %d and iPersistentSizes[%d].iSizeType == %d", aCheckGridSizeOnly, i, iPersistentSizes[i].iSizeType ); + OstTrace1( TRACE_NORMAL, DUP1_CTHUMBNAILSTORE_GETMISSINGSIZESL, "CThumbnailStore::GetMissingSizesL;aCheckGridSizeOnly=%u", aCheckGridSizeOnly ); } else { @@ -1546,6 +1656,7 @@ TInt missingSizeCount = aMissingSizes.Count(); TN_DEBUG2( "CThumbnailStore::GetMissingSizesL() missingSizeCount == %d", missingSizeCount ); + OstTrace1( TRACE_NORMAL, DUP2_CTHUMBNAILSTORE_GETMISSINGSIZESL, "CThumbnailStore::GetMissingSizesL;missingSizeCount=%d", missingSizeCount ); // check temp table first RSqlStatement* stmt = NULL; @@ -1573,6 +1684,7 @@ if ( aMissingSizes[ i ].iType == size ) { TN_DEBUG1( "CThumbnailStore::GetMissingSizesL() -- thumbnail found" ); + OstTrace0( TRACE_NORMAL, DUP3_CTHUMBNAILSTORE_GETMISSINGSIZESL, "CThumbnailStore::GetMissingSizesL - thumbnail found" ); aMissingSizes.Remove( i ); missingSizeCount--; break; @@ -1617,7 +1729,7 @@ aThumbnail, TDesC8* & aData, const TThumbnailSize aThumbnailSize, TSize &aThumbnailRealSize ) { TN_DEBUG3( "CThumbnailStore::FetchThumbnailL(%S) aThumbnailSize==%d", &aPath, aThumbnailSize ); - + OstTraceExt2( TRACE_NORMAL, CTHUMBNAILSTORE_FETCHTHUMBNAILL, "CThumbnailStore::FetchThumbnailL;aPath=%S;aThumbnailSize=%u", aPath, aThumbnailSize ); if(iReadOnly) { TN_DEBUG1( "CThumbnailStore::FetchThumbnailL() read only, skip..." ); @@ -1636,6 +1748,7 @@ TInt column = 0; TN_DEBUG1( "CThumbnailStore::FetchThumbnailL() -- TEMP TABLE lookup" ); + OstTrace0( TRACE_NORMAL, DUP1_CTHUMBNAILSTORE_FETCHTHUMBNAILL, "CThumbnailStore::FetchThumbnailL - TEMP TABLE lookup" ); RSqlStatement* stmt = NULL; stmt = &iStmt_KThumbnailSelectTempInfoByPath; @@ -1655,6 +1768,7 @@ if(rowStatus != KSqlAtRow) { TN_DEBUG1( "CThumbnailStore::FetchThumbnailL() -- MAIN TABLE lookup" ); + OstTrace0( TRACE_NORMAL, DUP2_CTHUMBNAILSTORE_FETCHTHUMBNAILL, "CThumbnailStore::FetchThumbnailL - MAIN TABLE lookup" ); CleanupStack::PopAndDestroy( stmt ); stmt = &iStmt_KThumbnailSelectInfoByPath; @@ -1674,6 +1788,7 @@ if(rowStatus == KSqlAtRow) { TN_DEBUG1( "CThumbnailStore::FetchThumbnailL() -- thumbnail found" ); + OstTrace0( TRACE_NORMAL, DUP3_CTHUMBNAILSTORE_FETCHTHUMBNAILL, "CThumbnailStore::FetchThumbnailL - thumbnail found" ); // Check whether blacklisted thumbnail entry modified. // If thumbnail is marked as blacklisted and timestamp has @@ -1731,6 +1846,7 @@ else { TN_DEBUG1( "CThumbnailStore::FetchThumbnailL() -- thumbnail NOT found" ); + OstTrace0( TRACE_NORMAL, DUP4_CTHUMBNAILSTORE_FETCHTHUMBNAILL, "CThumbnailStore::FetchThumbnailL - thumbnail NOT found" ); } CleanupStack::PopAndDestroy( stmt ); @@ -1747,6 +1863,7 @@ TBool aTransaction ) { TN_DEBUG2( "CThumbnailStore::DeleteThumbnailsL(%S)", &aPath ); + OstTraceExt1( TRACE_NORMAL, CTHUMBNAILSTORE_DELETETHUMBNAILSL, "CThumbnailStore::DeleteThumbnailsL;aPath=%S", aPath ); if(iReadOnly) { @@ -1781,6 +1898,7 @@ } TN_DEBUG1( "CThumbnailStore::DeleteThumbnailsByPathL() -- TEMP TABLE lookup" ); + OstTrace0( TRACE_NORMAL, DUP1_CTHUMBNAILSTORE_DELETETHUMBNAILSL, "CThumbnailStore::DeleteThumbnailsL - TEMP TABLE lookup" ); RSqlStatement* stmt = NULL; RSqlStatement* stmt_info = NULL; @@ -1819,6 +1937,7 @@ User::LeaveIfError( err ); TN_DEBUG1( "CThumbnailStore::DeleteThumbnailsByPathL() -- TEMP TABLE lookup - thumbnail deleted" ); + OstTrace0( TRACE_NORMAL, DUP2_CTHUMBNAILSTORE_DELETETHUMBNAILSL, "CThumbnailStore::DeleteThumbnailsL - TEMP TABLE lookup - thumbnail deleted" ); // fetch another row (temp table rowIDs are updated immediately) stmt->Reset(); @@ -1839,6 +1958,7 @@ { //look from real table TN_DEBUG1( "CThumbnailStore::DeleteThumbnailByPathL() -- MAIN TABLE lookup" ); + OstTrace0( TRACE_NORMAL, DUP3_CTHUMBNAILSTORE_DELETETHUMBNAILSL, "CThumbnailStore::DeleteThumbnailsL - MAIN TABLE lookup" ); stmt = &iStmt_KThumbnailSqlSelectRowIDInfoByPath; CleanupStack::PushL(TCleanupItem(ResetStatement, stmt)); @@ -1873,6 +1993,7 @@ User::LeaveIfError( err ); TN_DEBUG1( "CThumbnailStore::DeleteThumbnailByPathL() -- MAIN TABLE lookup - thumbnail deleted" ); + OstTrace0( TRACE_NORMAL, DUP4_CTHUMBNAILSTORE_DELETETHUMBNAILSL, "CThumbnailStore::DeleteThumbnailsL - MAIN TABLE lookup - thumbnail deleted" ); rowStatus = stmt->Next(); } @@ -1887,6 +2008,7 @@ else { TN_DEBUG1( "CThumbnailStore::DeleteThumbnailByPathL() -- MAIN TABLE lookup" ); + OstTrace0( TRACE_NORMAL, DUP5_CTHUMBNAILSTORE_DELETETHUMBNAILSL, "CThumbnailStore::DeleteThumbnailsL - MAIN TABLE lookup" ); stmt = &iStmt_KThumbnailSqlSelectRowIDInfoByPath; CleanupStack::PushL(TCleanupItem(ResetStatement, stmt)); @@ -1903,6 +2025,7 @@ if (rowStatus == KSqlAtRow) { TN_DEBUG1( "CThumbnailStore::DeleteThumbnailByPathL() -- add to Deleted" ); + OstTrace0( TRACE_NORMAL, DUP6_CTHUMBNAILSTORE_DELETETHUMBNAILSL, "CThumbnailStore::DeleteThumbnailsL - add to Deleted" ); // only add path to deleted table stmt = &iStmt_KThumbnailSqlInsertDeleted; @@ -1919,6 +2042,7 @@ else { TN_DEBUG1( "CThumbnailStore::DeleteThumbnailByPathL() -- no thumbs in MAIN" ); + OstTrace0( TRACE_NORMAL, DUP7_CTHUMBNAILSTORE_DELETETHUMBNAILSL, "CThumbnailStore::DeleteThumbnailsL - no thumbs in MAIN" ); } } @@ -1930,13 +2054,16 @@ #ifdef _DEBUG aStop.UniversalTime(); + TInt tookTime = (TInt)aStop.MicroSecondsFrom(aStart).Int64()/1000; TN_DEBUG2( "CThumbnailStore::DeleteThumbnailByPathL() took %d ms", (TInt)aStop.MicroSecondsFrom(aStart).Int64()/1000); + OstTrace1( TRACE_NORMAL, DUP8_CTHUMBNAILSTORE_DELETETHUMBNAILSL, "CThumbnailStore::DeleteThumbnailsL - took;tookTime=%d", tookTime ); #endif // start maintenance if rows in main table were marked if (!aForce && count > 0) { TN_DEBUG2( "CThumbnailStore::DeleteThumbnailByPathL() -- MAIN TABLE lookup - %d rows marked deleted", count); + OstTrace1( TRACE_NORMAL, DUP9_CTHUMBNAILSTORE_DELETETHUMBNAILSL, "CThumbnailStore::DeleteThumbnailsL -- MAIN TABLE lookup - rows marked deleted;count=%d", count ); iDeleteThumbs = ETrue; iActivityManager->Start(); @@ -1952,7 +2079,7 @@ void CThumbnailStore::RenameThumbnailsL( const TDesC& aCurrentPath, const TDesC& aNewPath ) { TN_DEBUG2( "CThumbnailStore::RenameThumbnailsL(%S)", &aCurrentPath ); - + OstTraceExt1( TRACE_NORMAL, CTHUMBNAILSTORE_RENAMETHUMBNAILSL, "CThumbnailStore::RenameThumbnailsL;aCurrentPath=%S", aCurrentPath ); if(iReadOnly) { TN_DEBUG1( "CThumbnailStore::RenameThumbnailsL() read only, skip..." ); @@ -1981,6 +2108,7 @@ transaction.BeginL(); TN_DEBUG1( "CThumbnailStore::RenameThumbnailsL() -- TEMP TABLE" ); + OstTrace0( TRACE_NORMAL, DUP1_CTHUMBNAILSTORE_RENAMETHUMBNAILSL, "CThumbnailStore::RenameThumbnailsL - TEMP TABLE" ); RSqlStatement* stmt = NULL; stmt = &iStmt_KThumbnailTempRename; @@ -1997,6 +2125,7 @@ User::LeaveIfError( stmt->Exec() ); TN_DEBUG1( "CThumbnailStore::RenameThumbnailsL() -- MAIN TABLE" ); + OstTrace0( TRACE_NORMAL, DUP2_CTHUMBNAILSTORE_RENAMETHUMBNAILSL, "CThumbnailStore::RenameThumbnailsL - MAIN TABLE" ); CleanupStack::PopAndDestroy( stmt ); stmt = &iStmt_KThumbnailRename; @@ -2025,7 +2154,9 @@ #ifdef _DEBUG aStop.UniversalTime(); + TInt tookTime = (TInt)aStop.MicroSecondsFrom(aStart).Int64()/1000; TN_DEBUG2( "CThumbnailStore::RenameThumbnailsL() took %d ms", (TInt)aStop.MicroSecondsFrom(aStart).Int64()/1000); + OstTrace1( TRACE_NORMAL, DUP3_CTHUMBNAILSTORE_RENAMETHUMBNAILSL, "CThumbnailStore::RenameThumbnailsL;tookTime=%d", tookTime ); #endif } @@ -2045,6 +2176,7 @@ void CThumbnailStore::FlushCacheTable( TBool aForce ) { TN_DEBUG1("CThumbnailStore::FlushCacheTable() in"); + OstTrace0( TRACE_NORMAL, CTHUMBNAILSTORE_FLUSHCACHETABLE, "CThumbnailStore::FlushCacheTable - in" ); StopAutoFlush(); @@ -2058,6 +2190,7 @@ { // cache empty or db unusable TN_DEBUG1( "CThumbnailStore::FlushCacheTable() error "); + OstTrace0( TRACE_NORMAL, DUP1_CTHUMBNAILSTORE_FLUSHCACHETABLE, "CThumbnailStore::FlushCacheTable - error" ); return; } @@ -2067,6 +2200,7 @@ if(ret != KErrNone) { TN_DEBUG2( "CThumbnailStore::FlushCacheTable() error checking MTP sync: %d", ret); + OstTrace1( TRACE_NORMAL, DUP2_CTHUMBNAILSTORE_FLUSHCACHETABLE, "CThumbnailStore::FlushCacheTable - error checking MTP sync;ret=%d", ret ); } //set init max flush delay @@ -2078,6 +2212,7 @@ { //MTP or MPX harvesting active, allow longer flush -> bigger batch size TN_DEBUG1("CThumbnailStore::FlushCacheTable() MTP sync, longer flush.."); + OstTrace0( TRACE_NORMAL, DUP3_CTHUMBNAILSTORE_FLUSHCACHETABLE, "CThumbnailStore::FlushCacheTable - MTP sync, longer flush.." ); aMaxFlushDelay = KMaxMTPFlushDelay; } @@ -2085,6 +2220,7 @@ if( iBatchItemCount == 1) { TN_DEBUG2("CThumbnailStore::FlushCacheTable() calculate new batch size iPreviousFlushDelay = %d", iPreviousFlushDelay); + OstTrace1( TRACE_NORMAL, DUP4_CTHUMBNAILSTORE_FLUSHCACHETABLE, "CThumbnailStore::FlushCacheTable;iPreviousFlushDelay=%d", iPreviousFlushDelay ); //adjust batch size dynamically between min and max based on previous flush speed if( iPreviousFlushDelay > 0 ) { @@ -2092,10 +2228,15 @@ iBatchFlushItemCount = (TInt)aNewBatchFlushItemCount; TN_DEBUG2("CThumbnailStore::FlushCacheTable() aMaxFlushDelay %e", aMaxFlushDelay); + OstTrace1( TRACE_NORMAL, DUP5_CTHUMBNAILSTORE_FLUSHCACHETABLE, "CThumbnailStore::FlushCacheTable;aMaxFlushDelay=%d", aMaxFlushDelay ); TN_DEBUG2("CThumbnailStore::FlushCacheTable() aPreviousFlushDelay %e", aPreviousFlushDelay); + OstTrace1( TRACE_NORMAL, DUP6_CTHUMBNAILSTORE_FLUSHCACHETABLE, "CThumbnailStore::FlushCacheTable;aPreviousFlushDelay=%d", aPreviousFlushDelay ); TN_DEBUG2("CThumbnailStore::FlushCacheTable() aBatchFlushItemCount %e", aBatchFlushItemCount); + OstTrace1( TRACE_NORMAL, DUP7_CTHUMBNAILSTORE_FLUSHCACHETABLE, "CThumbnailStore::FlushCacheTable;aBatchFlushItemCount=%d", aBatchFlushItemCount ); TN_DEBUG2("CThumbnailStore::FlushCacheTable() aNewBatchFlushItemCount %e", aNewBatchFlushItemCount); + OstTrace1( TRACE_NORMAL, DUP8_CTHUMBNAILSTORE_FLUSHCACHETABLE, "CThumbnailStore::FlushCacheTable;aNewBatchFlushItemCount=%d", aNewBatchFlushItemCount ); TN_DEBUG2("CThumbnailStore::FlushCacheTable() iBatchFlushItemCount %d", iBatchFlushItemCount); + OstTrace1( TRACE_NORMAL, DUP9_CTHUMBNAILSTORE_FLUSHCACHETABLE, "CThumbnailStore::FlushCacheTable;iBatchFlushItemCount=%d", iBatchFlushItemCount ); if( iBatchFlushItemCount < KMInBatchItems ) { @@ -2114,6 +2255,7 @@ } TN_DEBUG3("CThumbnailStore::FlushCacheTable() iBatchFlushItemCount = %d, iBatchItemCount = %d", iBatchFlushItemCount, iBatchItemCount); + OstTrace0( TRACE_NORMAL, DUP10_CTHUMBNAILSTORE_FLUSHCACHETABLE, "CThumbnailStore::FlushCacheTable" ); if( iBatchItemCount < iBatchFlushItemCount && !aForce) { @@ -2127,15 +2269,18 @@ // Move data from temp table to main.... TInt err_begin = iDatabase.Exec( KThumbnailBeginTransaction ); TN_DEBUG2("CThumbnailStore::FlushCacheTable() KThumbnailBeginTransaction %d", err_begin); + OstTrace1( TRACE_NORMAL, DUP11_CTHUMBNAILSTORE_FLUSHCACHETABLE, "CThumbnailStore::FlushCacheTable - KThumbnailBeginTransaction;err_begin=%d", err_begin ); TInt err_tempinfo = iDatabase.Exec( KThumbnailMoveFromTempInfoToMainTable ); TN_DEBUG2("CThumbnailStore::FlushCacheTable() KThumbnailMoveFromTempInfoToMainTable %d", err_tempinfo); + OstTrace1( TRACE_NORMAL, DUP12_CTHUMBNAILSTORE_FLUSHCACHETABLE, "CThumbnailStore::FlushCacheTable - KThumbnailMoveFromTempInfoToMainTable;err_tempinfo=%d", err_tempinfo ); #ifdef _DEBUG if(err_tempinfo < 0) { TPtrC errorMsg = iDatabase.LastErrorMessage(); TN_DEBUG2( "CThumbnailStore::FlushCacheTable() lastError %S", &errorMsg); + OstTraceExt1( TRACE_NORMAL, DUP13_CTHUMBNAILSTORE_FLUSHCACHETABLE, "CThumbnailStore::FlushCacheTable - lastError;errorMsg=%S", errorMsg ); } #endif @@ -2146,24 +2291,29 @@ { TPtrC errorMsg2 = iDatabase.LastErrorMessage(); TN_DEBUG2( "CThumbnailStore::FlushCacheTable() KThumbnailMoveFromTempDataToMainTable %S", &errorMsg2); + OstTraceExt1( TRACE_NORMAL, DUP14_CTHUMBNAILSTORE_FLUSHCACHETABLE, "CThumbnailStore::FlushCacheTable - KThumbnailMoveFromTempDataToMainTable;errorMsg2=%S", errorMsg2 ); } #endif TInt err_delinfo = iDatabase.Exec( KThumbnailDeleteFromTempInfoTable ); TN_DEBUG2("CThumbnailStore::FlushCacheTable() KThumbnailDeleteFromTempInfoTable %d", err_delinfo); + OstTrace1( TRACE_NORMAL, DUP15_CTHUMBNAILSTORE_FLUSHCACHETABLE, "CThumbnailStore::FlushCacheTable - KThumbnailDeleteFromTempInfoTable;err_delinfo=%d", err_delinfo ); TInt err_deldata = iDatabase.Exec( KThumbnailDeleteFromTempDataTable ); TN_DEBUG2("CThumbnailStore::FlushCacheTable() KThumbnailDeleteFromTempDataTable %d", err_deldata); + OstTrace1( TRACE_NORMAL, DUP16_CTHUMBNAILSTORE_FLUSHCACHETABLE, "CThumbnailStore::FlushCacheTable;err_deldata=%d", err_deldata ); if( err_tempinfo < 0 || err_tempdata < 0 || err_delinfo < 0 || err_deldata < 0 ) { TInt err = iDatabase.Exec( KThumbnailRollbackTransaction ); TN_DEBUG2("CThumbnailStore::FlushCacheTable() KThumbnailRollbackTransaction %d", err); + OstTrace1( TRACE_NORMAL, DUP17_CTHUMBNAILSTORE_FLUSHCACHETABLE, "CThumbnailStore::FlushCacheTable - KThumbnailRollbackTransaction;err=%d", err ); } else { TInt err_commit = iDatabase.Exec( KThumbnailCommitTransaction ); TN_DEBUG2("CThumbnailStore::FlushCacheTable() KThumbnailCommitTransaction %d", err_commit); + OstTrace0( TRACE_NORMAL, DUP18_CTHUMBNAILSTORE_FLUSHCACHETABLE, "CThumbnailStore::FlushCacheTable" ); } // db got corrupted @@ -2171,6 +2321,7 @@ err_tempdata == KSqlErrCorrupt || err_tempdata == KErrCorrupt) { TN_DEBUG1("CThumbnailStore::FlushCacheTable() db corrupted"); + OstTrace0( TRACE_NORMAL, DUP19_CTHUMBNAILSTORE_FLUSHCACHETABLE, "CThumbnailStore::FlushCacheTable - db corrupted" ); // open new TRAP_IGNORE(OpenDatabaseL(ETrue)); @@ -2180,11 +2331,13 @@ iPreviousFlushDelay = (TInt)iStopFlush.MicroSecondsFrom(iStartFlush).Int64()/1000; TN_DEBUG2( "CThumbnailStore::FlushCacheTable() took %d ms", iPreviousFlushDelay); + OstTrace1( TRACE_NORMAL, DUP20_CTHUMBNAILSTORE_FLUSHCACHETABLE, "CThumbnailStore::FlushCacheTable - took ms ;iPreviousFlushDelay=%d", iPreviousFlushDelay ); //cache flushed iBatchItemCount = 0; TN_DEBUG1("CThumbnailStore::FlushCacheTable() out"); + OstTrace0( TRACE_NORMAL, DUP21_CTHUMBNAILSTORE_FLUSHCACHETABLE, "CThumbnailStore::FlushCacheTable - out" ); } // ----------------------------------------------------------------------------- @@ -2194,7 +2347,7 @@ void CThumbnailStore::StartAutoFlush() { TN_DEBUG1( "CThumbnailStore::StartAutoFlush()" ); - + OstTrace0( TRACE_NORMAL, CTHUMBNAILSTORE_STARTAUTOFLUSH, "CThumbnailStore::StartAutoFlush" ); if(iReadOnly) { TN_DEBUG1( "CThumbnailStore::StartAutoFlush() read only, skip..." ); @@ -2215,6 +2368,7 @@ if (err != KErrNone) { TN_DEBUG2( "CThumbnailStore::StartAutoFlush() - Error creating timer (%d)", err ); + OstTrace1( TRACE_NORMAL, DUP1_CTHUMBNAILSTORE_STARTAUTOFLUSH, "CThumbnailStore::StartAutoFlush - - Error creating timer;err=%d", err ); } else { @@ -2230,6 +2384,7 @@ void CThumbnailStore::StopAutoFlush() { TN_DEBUG1( "CThumbnailStore::StopAutoFlush()" ); + OstTrace0( TRACE_NORMAL, CTHUMBNAILSTORE_STOPAUTOFLUSH, "CThumbnailStore::StopAutoFlush" ); if( iAutoFlushTimer ) { iAutoFlushTimer->Cancel(); @@ -2243,6 +2398,7 @@ void CThumbnailStore::StartMaintenance() { TN_DEBUG1( "CThumbnailStore::StartMaintenance()"); + OstTrace0( TRACE_NORMAL, CTHUMBNAILSTORE_STARTMAINTENANCE, "CThumbnailStore::StartMaintenance" ); TInt err = KErrNone; if( iMaintenanceTimer && iMaintenanceTimer->IsActive() ) @@ -2257,6 +2413,7 @@ if (err != KErrNone && !iMaintenanceTimer) { TN_DEBUG2( "CThumbnailStore::StartMaintenanceTimer() - Error creating timer (%d)", err ); + OstTrace1( TRACE_NORMAL, DUP1_CTHUMBNAILSTORE_STARTMAINTENANCE, "CThumbnailStore::StartMaintenance - Error creating timer ;err=%d", err ); } else { @@ -2272,6 +2429,7 @@ TInt CThumbnailStore::AutoFlushTimerCallBack(TAny* aAny) { TN_DEBUG1( "CThumbnailStore::AutoFlushTimerCallBack()"); + OstTrace0( TRACE_NORMAL, CTHUMBNAILSTORE_AUTOFLUSHTIMERCALLBACK, "CThumbnailStore::AutoFlushTimerCallBack" ); CThumbnailStore* self = static_cast( aAny ); self->FlushCacheTable(ETrue); @@ -2295,26 +2453,32 @@ if(ret != KErrNone || MPXHarvesting) { TN_DEBUG3( "CThumbnailStore::MaintenanceTimerCallBack() KMPXHarvesting err == %d, MPXHarvesting == %d", ret, MPXHarvesting); + OstTraceExt2( TRACE_NORMAL, CTHUMBNAILSTORE_MAINTENANCETIMERCALLBACK, "CThumbnailStore::MaintenanceTimerCallBack;ret=%d;MPXHarvesting=%d", ret, MPXHarvesting ); self->iIdle = EFalse; } TN_DEBUG2( "CThumbnailStore::MaintenanceTimerCallBack() KMPXHarvesting == %d", MPXHarvesting); + OstTrace1( TRACE_NORMAL, DUP1_CTHUMBNAILSTORE_MAINTENANCETIMERCALLBACK, "CThumbnailStore::MaintenanceTimerCallBack;MPXHarvesting=%d", MPXHarvesting ); ret = RProperty::Get(KTAGDPSNotification, KDaemonProcessing, DaemonProcessing); if(ret != KErrNone || DaemonProcessing) { TN_DEBUG3( "CThumbnailStore::MaintenanceTimerCallBack() KDaemonProcessing err == %d, DaemonProcessing == %d", ret, DaemonProcessing); + OstTraceExt2( TRACE_NORMAL, DUP2_CTHUMBNAILSTORE_MAINTENANCETIMERCALLBACK, "CThumbnailStore::MaintenanceTimerCallBack;ret=%d;DaemonProcessing=%d", ret, DaemonProcessing ); self->iIdle = EFalse; } TN_DEBUG2( "CThumbnailStore::MaintenanceTimerCallBack() DaemonProcessing == %d", DaemonProcessing); + OstTrace1( TRACE_NORMAL, DUP3_CTHUMBNAILSTORE_MAINTENANCETIMERCALLBACK, "CThumbnailStore::MaintenanceTimerCallBack;DaemonProcessing=%d", DaemonProcessing ); if (self->iIdle) { TN_DEBUG2( "CThumbnailStore::MaintenanceTimerCallBack() - maintenance, store %d", self->iDrive); + OstTrace1( TRACE_NORMAL, DUP4_CTHUMBNAILSTORE_MAINTENANCETIMERCALLBACK, "CThumbnailStore::MaintenanceTimerCallBack - maintenance, store;self->iDrive=%d", self->iDrive ); // thumbmnail deletion if (self->iDeleteThumbs) { TN_DEBUG1( "CThumbnailStore::MaintenanceTimerCallBack() - cleanup"); + OstTrace0( TRACE_NORMAL, DUP5_CTHUMBNAILSTORE_MAINTENANCETIMERCALLBACK, "CThumbnailStore::MaintenanceTimerCallBack - cleanup" ); TInt deleteCount = 0; @@ -2323,6 +2487,7 @@ if (err != KErrNone) { TN_DEBUG2( "CThumbnailStore::MaintenanceTimerCallBack() - cleanup failed, err %d", err); + OstTrace1( TRACE_NORMAL, DUP6_CTHUMBNAILSTORE_MAINTENANCETIMERCALLBACK, "CThumbnailStore::MaintenanceTimerCallBack - cleanup failed;err=%d", err ); return err; } @@ -2330,6 +2495,7 @@ if (deleteCount < KStoreMaintenanceDeleteLimit || deleteCount == 0) { TN_DEBUG2( "CThumbnailStore::MaintenanceTimerCallBack() - cleanup finished, store %d", self->iDrive); + OstTrace1( TRACE_NORMAL, DUP7_CTHUMBNAILSTORE_MAINTENANCETIMERCALLBACK, "CThumbnailStore::MaintenanceTimerCallBack - cleanup finished, store;self->iDrive=%d", self->iDrive ); self->iDeleteThumbs = EFalse; } } @@ -2338,6 +2504,7 @@ else if (self->iCheckFilesExist) { TN_DEBUG1( "CThumbnailStore::MaintenanceTimerCallBack() - file existence check"); + OstTrace0( TRACE_NORMAL, DUP8_CTHUMBNAILSTORE_MAINTENANCETIMERCALLBACK, "CThumbnailStore::MaintenanceTimerCallBack - file existence check" ); TBool finished = EFalse; @@ -2345,6 +2512,7 @@ if (err != KErrNone) { TN_DEBUG2( "CThumbnailStore::MaintenanceTimerCallBack() - file existence check failed, err %d", err); + OstTrace1( TRACE_NORMAL, DUP9_CTHUMBNAILSTORE_MAINTENANCETIMERCALLBACK, "CThumbnailStore::MaintenanceTimerCallBack - file existence check failed;err=%d", err ); return err; } @@ -2352,6 +2520,7 @@ if (finished) { TN_DEBUG2( "CThumbnailStore::MaintenanceTimerCallBack() - file existence check finished, store %d", self->iDrive); + OstTrace1( TRACE_NORMAL, DUP10_CTHUMBNAILSTORE_MAINTENANCETIMERCALLBACK, "CThumbnailStore::MaintenanceTimerCallBack - file existence check finished, store;self->iDrive=%d", self->iDrive ); self->iCheckFilesExist = EFalse; } } @@ -2360,11 +2529,13 @@ if (self->iIdle && ( self->iDeleteThumbs || self->iCheckFilesExist) ) { TN_DEBUG1( "CThumbnailStore::MaintenanceTimerCallBack() - continue maintenance"); + OstTrace0( TRACE_NORMAL, DUP11_CTHUMBNAILSTORE_MAINTENANCETIMERCALLBACK, "CThumbnailStore::MaintenanceTimerCallBack - continue maintenance" ); self->StartMaintenance(); } else if (!self->iDeleteThumbs && !self->iCheckFilesExist) { TN_DEBUG1( "CThumbnailStore::MaintenanceTimerCallBack() - no more maintenance"); + OstTrace0( TRACE_NORMAL, DUP12_CTHUMBNAILSTORE_MAINTENANCETIMERCALLBACK, "CThumbnailStore::MaintenanceTimerCallBack - no more maintenance" ); // no need to monitor activity anymore self->iActivityManager->Cancel(); @@ -2373,6 +2544,7 @@ else { TN_DEBUG1( "CThumbnailStore::MaintenanceTimerCallBack() - device not idle"); + OstTrace0( TRACE_NORMAL, DUP13_CTHUMBNAILSTORE_MAINTENANCETIMERCALLBACK, "CThumbnailStore::MaintenanceTimerCallBack - device not idle" ); } return KErrNone; // Return value ignored by CPeriodic @@ -2381,6 +2553,7 @@ TBool CThumbnailStore::CheckModifiedByPathL( const TDesC& aPath, const TInt64 aModified, TBool& modifiedChanged ) { TN_DEBUG2( "CThumbnailStore::CheckModifiedByPathL() %S", &aPath); + OstTraceExt1( TRACE_NORMAL, CTHUMBNAILSTORE_CHECKMODIFIEDBYPATHL, "CThumbnailStore::CheckModifiedByPathL;aPath=%S", aPath ); if(iReadOnly) { @@ -2414,6 +2587,7 @@ TBool checkMain = EFalse; TN_DEBUG1( "CThumbnailStore::CheckModifiedL() -- temp" ); + OstTrace0( TRACE_NORMAL, DUP1_CTHUMBNAILSTORE_CHECKMODIFIEDBYPATHL, "CThumbnailStore::CheckModifiedByPathL -- temp" ); while(rowStatus == KSqlAtRow || !checkMain) { @@ -2423,21 +2597,26 @@ TInt64 oldModified = stmt->ColumnInt64( column ); TN_DEBUG2( "CThumbnailStore::CheckModifiedL() -- timestamp old %Ld", oldModified); + OstTraceExt1( TRACE_NORMAL, DUP2_CTHUMBNAILSTORE_CHECKMODIFIEDBYPATHL, "CThumbnailStore::CheckModifiedByPathL -- timestamp old;oldModified=%Ld", oldModified ); TN_DEBUG2( "CThumbnailStore::CheckModifiedL() -- timestamp mds %Ld", aModified); + OstTraceExt1( TRACE_NORMAL, DUP3_CTHUMBNAILSTORE_CHECKMODIFIEDBYPATHL, "CThumbnailStore::CheckModifiedByPathL -- timestamp mds;aModified=%Ld", aModified ); if (oldModified < aModified) { TN_DEBUG1( "CThumbnailStore::CheckModifiedL() -- timestamp is newer than original" ); + OstTrace0( TRACE_NORMAL, DUP4_CTHUMBNAILSTORE_CHECKMODIFIEDBYPATHL, "CThumbnailStore::CheckModifiedByPathL -- timestamp is newer than original" ); modifiedChanged = ETrue; break; } else if (oldModified > aModified) { TN_DEBUG1( "CThumbnailStore::CheckModifiedL() -- timestamp is older than original" ); + OstTrace0( TRACE_NORMAL, DUP5_CTHUMBNAILSTORE_CHECKMODIFIEDBYPATHL, "CThumbnailStore::CheckModifiedByPathL -- timestamp is older than original" ); } else if (oldModified == aModified) { TN_DEBUG1( "CThumbnailStore::CheckModifiedL() -- timestamp is the same as original" ); + OstTrace0( TRACE_NORMAL, DUP6_CTHUMBNAILSTORE_CHECKMODIFIEDBYPATHL, "CThumbnailStore::CheckModifiedByPathL -- timestamp is the same as original" ); } rowStatus = stmt->Next(); @@ -2447,6 +2626,7 @@ if(rowStatus != KSqlAtRow && !checkMain && !modifiedChanged) { TN_DEBUG1( "CThumbnailStore::CheckModifiedL() -- main" ); + OstTrace0( TRACE_NORMAL, DUP7_CTHUMBNAILSTORE_CHECKMODIFIEDBYPATHL, "CThumbnailStore::CheckModifiedByPathL -- main" ); //come here only once checkMain = ETrue; @@ -2485,6 +2665,7 @@ void CThumbnailStore::PrepareBlacklistedItemsForRetryL() { TN_DEBUG1( "CThumbnailStore::PrepareBlacklistedItemsForRetry()" ); + OstTrace0( TRACE_NORMAL, CTHUMBNAILSTORE_PREPAREBLACKLISTEDITEMSFORRETRYL, "CThumbnailStore::PrepareBlacklistedItemsForRetryL" ); RSqlStatement stmt; CleanupClosePushL( stmt ); @@ -2497,6 +2678,7 @@ TInt err = stmt.Exec(); TN_DEBUG2( "CThumbnailStore::PrepareBlacklistedItemsForRetryL() - main table, err=%d", err ); + OstTrace1( TRACE_NORMAL, DUP1_CTHUMBNAILSTORE_PREPAREBLACKLISTEDITEMSFORRETRYL, "CThumbnailStore::PrepareBlacklistedItemsForRetryL - main table;err=%d", err ); CleanupStack::PopAndDestroy( &stmt ); } @@ -2508,7 +2690,7 @@ TInt CThumbnailStore::DeleteMarkedL() { TN_DEBUG1( "CThumbnailStore::DeleteMarkedL()" ); - + OstTrace0( TRACE_NORMAL, CTHUMBNAILSTORE_DELETEMARKEDL, "CThumbnailStore::DeleteMarkedL" ); if(iReadOnly) { TN_DEBUG1( "CThumbnailStore::DeleteMarkedL() read only, skip..." ); @@ -2573,6 +2755,7 @@ deleteCount++; TN_DEBUG1( "CThumbnailStore::DeleteMarkedL() - thumbnail deleted" ); + OstTrace0( TRACE_NORMAL, DUP1_CTHUMBNAILSTORE_DELETEMARKEDL, "CThumbnailStore::DeleteMarkedL - thumbnail deleted" ); rowStatus = stmt->Next(); } @@ -2592,7 +2775,9 @@ #ifdef _DEBUG aStop.UniversalTime(); + TInt tookTime = (TInt)aStop.MicroSecondsFrom(aStart).Int64()/1000; TN_DEBUG2( "CThumbnailStore::DeleteMarkedL() took %d ms", (TInt)aStop.MicroSecondsFrom(aStart).Int64()/1000); + OstTrace1( TRACE_NORMAL, DUP2_CTHUMBNAILSTORE_DELETEMARKEDL, "CThumbnailStore::DeleteMarkedL - took ms;tookTime=%d", tookTime ); #endif return deleteCount; @@ -2605,7 +2790,7 @@ TInt CThumbnailStore::FileExistenceCheckL() { TN_DEBUG1( "CThumbnailStore::FileExistenceCheckL()" ); - + OstTrace0( TRACE_NORMAL, CTHUMBNAILSTORE_FILEEXISTENCECHECKL, "CThumbnailStore::FileExistenceCheckL" ); if(iReadOnly) { TN_DEBUG1( "CThumbnailStore::FileExistenceCheckL() read only, skip..." ); @@ -2696,7 +2881,9 @@ #ifdef _DEBUG aStop.UniversalTime(); + TInt tookTime = (TInt)aStop.MicroSecondsFrom(aStart).Int64()/1000; TN_DEBUG2( "CThumbnailStore::FileExistenceCheckL() took %d ms", (TInt)aStop.MicroSecondsFrom(aStart).Int64()/1000); + OstTrace1( TRACE_NORMAL, DUP1_CTHUMBNAILSTORE_FILEEXISTENCECHECKL, "CThumbnailStore::FileExistenceCheckL - took ms;tookTime=%d", tookTime ); #endif return finished; @@ -2736,6 +2923,7 @@ if (iUnrecoverable && !iReadOnly) { TN_DEBUG1( "CThumbnailStore::CheckDbState() - database in unrecoverable state" ); + OstTrace0( TRACE_NORMAL, CTHUMBNAILSTORE_CHECKDBSTATE, "CThumbnailStore::CheckDbState" ); __ASSERT_DEBUG( !iUnrecoverable, ThumbnailPanic( EThumbnailDatabaseUnrecoverable )); return KStoreUnrecoverableErr; @@ -2749,6 +2937,7 @@ void CThumbnailStore::HandleDiskSpaceNotificationL( TBool aDiskFull ) { TN_DEBUG2( "CThumbnailStore::HandleDiskSpaceNotificationL() aDiskFull = %d", aDiskFull ); + OstTrace1( TRACE_NORMAL, CTHUMBNAILSTORE_HANDLEDISKSPACENOTIFICATIONL, "CThumbnailStore::HandleDiskSpaceNotificationL;aDiskFull=%u", aDiskFull ); iDiskFull = aDiskFull; } @@ -2759,6 +2948,9 @@ #endif { TN_DEBUG2( "CThumbnailStore::HandleDiskSpaceError() aError = %d", aError ); +#ifdef _DEBUG + OstTrace1( TRACE_NORMAL, CTHUMBNAILSTORE_HANDLEDISKSPACEERROR, "CThumbnailStore::HandleDiskSpaceError;aError=%d", aError ); +#endif } TBool CThumbnailStore::IsDiskFull() @@ -2778,7 +2970,7 @@ void CThumbnailStore::ActivityChanged(const TBool aActive) { TN_DEBUG2( "CThumbnailStore::ActivityChanged() aActive == %d", aActive); - + OstTrace1( TRACE_NORMAL, CTHUMBNAILSTORE_ACTIVITYCHANGED, "CThumbnailStore::ActivityChanged;aActive=%u", aActive ); if( iReadOnly ) { TN_DEBUG1( "CThumbnailStore::ActivityChanged() read only, skip..." ); @@ -2798,6 +2990,7 @@ if(ret != KErrNone || MPXHarvesting) { TN_DEBUG3( "CThumbnailStore::ActivityChanged() KMPXHarvesting err == %d, MPXHarvesting == %d", ret, MPXHarvesting); + OstTraceExt2( TRACE_NORMAL, DUP1_CTHUMBNAILSTORE_ACTIVITYCHANGED, "CThumbnailStore::ActivityChanged;ret=%d;MPXHarvesting=%d", ret, MPXHarvesting ); iIdle = EFalse; return; } @@ -2806,11 +2999,13 @@ if(ret != KErrNone || DaemonProcessing) { TN_DEBUG3( "CThumbnailStore::ActivityChanged() KDaemonProcessing err == %d DaemonProcessing == %d", ret, DaemonProcessing ); + OstTraceExt2( TRACE_NORMAL, DUP2_CTHUMBNAILSTORE_ACTIVITYCHANGED, "CThumbnailStore::ActivityChanged - KDaemonProcessing;ret=%d;DaemonProcessing=%d", ret, DaemonProcessing ); iIdle = EFalse; return; } TN_DEBUG1( "CThumbnailStore::ActivityChanged() - starting maintenance"); + OstTrace0( TRACE_NORMAL, DUP3_CTHUMBNAILSTORE_ACTIVITYCHANGED, "CThumbnailStore::ActivityChanged - starting maintenance" ); iIdle = ETrue; StartMaintenance(); } @@ -2845,6 +3040,7 @@ TDriveNumber CThumbnailStoreDiskSpaceNotifierAO::GetDriveNumberL( const TDesC& aFilename ) { TN_DEBUG1( "CThumbnailStoreDiskSpaceNotifierAO::GetDriveNumberL()"); + OstTrace0( TRACE_NORMAL, CTHUMBNAILSTOREDISKSPACENOTIFIERAO_GETDRIVENUMBERL, "CThumbnailStoreDiskSpaceNotifierAO::GetDriveNumberL" ); TLex driveParser( aFilename ); TChar driveChar = driveParser.Get(); @@ -2852,6 +3048,7 @@ if( 0 == driveChar || TChar( ':' ) != driveParser.Peek() ) { TN_DEBUG1( "CThumbnailStoreDiskSpaceNotifierAO::GetDriveNumberL() KErrArgument"); + OstTrace0( TRACE_NORMAL, DUP1_CTHUMBNAILSTOREDISKSPACENOTIFIERAO_GETDRIVENUMBERL, "CThumbnailStoreDiskSpaceNotifierAO::GetDriveNumberL - KErrArgument" ); User::Leave( KErrArgument ); } @@ -2865,6 +3062,7 @@ CThumbnailStoreDiskSpaceNotifierAO::~CThumbnailStoreDiskSpaceNotifierAO() { TN_DEBUG1( "CThumbnailStoreDiskSpaceNotifierAO::~CThumbnailStoreDiskSpaceNotifierAO()"); + OstTrace0( TRACE_NORMAL, CTHUMBNAILSTOREDISKSPACENOTIFIERAO_CTHUMBNAILSTOREDISKSPACENOTIFIERAO, "CThumbnailStoreDiskSpaceNotifierAO::~CThumbnailStoreDiskSpaceNotifierAO" ); Cancel(); iFileServerSession.Close(); @@ -2873,6 +3071,7 @@ void CThumbnailStoreDiskSpaceNotifierAO::RunL() { TN_DEBUG1( "CThumbnailStoreDiskSpaceNotifierAO::RunL()"); + OstTrace0( TRACE_NORMAL, CTHUMBNAILSTOREDISKSPACENOTIFIERAO_RUNL, "CThumbnailStoreDiskSpaceNotifierAO::RunL" ); TVolumeInfo volumeInfo; if ( iState == CThumbnailStoreDiskSpaceNotifierAO::ENormal ) @@ -2892,6 +3091,7 @@ if( volumeInfo.iFree < iThreshold ) { TN_DEBUG1( "CThumbnailStoreDiskSpaceNotifierAO::RunL() FULL"); + OstTrace0( TRACE_NORMAL, DUP1_CTHUMBNAILSTOREDISKSPACENOTIFIERAO_RUNL, "CThumbnailStoreDiskSpaceNotifierAO::RunL - FULL" ); iDiskFull = ETrue; iObserver.HandleDiskSpaceNotificationL( iDiskFull ); iState = EIterate; @@ -2904,6 +3104,7 @@ else { TN_DEBUG1( "CThumbnailStoreDiskSpaceNotifierAO::RunL() NOT FULL"); + OstTrace0( TRACE_NORMAL, DUP2_CTHUMBNAILSTOREDISKSPACENOTIFIERAO_RUNL, "CThumbnailStoreDiskSpaceNotifierAO::RunL - NOT FULL" ); iDiskFull = EFalse; iObserver.HandleDiskSpaceNotificationL( iDiskFull ); } @@ -2911,6 +3112,7 @@ else { TN_DEBUG2( "CThumbnailStoreDiskSpaceNotifierAO::RunL() error %d NOT FULL", ret); + OstTrace1( TRACE_NORMAL, DUP3_CTHUMBNAILSTOREDISKSPACENOTIFIERAO_RUNL, "CThumbnailStoreDiskSpaceNotifierAO::RunL - NOT FULL;ret=%d", ret ); iDiskFull = EFalse; iObserver.HandleDiskSpaceNotificationL( iDiskFull ); User::Leave( ret ); @@ -2921,6 +3123,7 @@ case KErrArgument: TN_DEBUG1( "CThumbnailStoreDiskSpaceNotifierAO::RunL() KErrArgument"); + OstTrace0( TRACE_NORMAL, DUP4_CTHUMBNAILSTOREDISKSPACENOTIFIERAO_RUNL, "CThumbnailStoreDiskSpaceNotifierAO::RunL - KErrArgument" ); User::Leave( status ); break; default: @@ -2949,6 +3152,7 @@ if ( volumeInfo.iFree >= iThreshold ) { TN_DEBUG1( "CThumbnailStoreDiskSpaceNotifierAO::RunL() NOT FULL"); + OstTrace0( TRACE_NORMAL, DUP5_CTHUMBNAILSTOREDISKSPACENOTIFIERAO_RUNL, "CThumbnailStoreDiskSpaceNotifierAO::RunL - NOT FULL" ); iDiskFull = EFalse; } } @@ -2956,6 +3160,7 @@ else { TN_DEBUG1( "CThumbnailStoreDiskSpaceNotifierAO::RunL() NOT FULL"); + OstTrace0( TRACE_NORMAL, DUP6_CTHUMBNAILSTOREDISKSPACENOTIFIERAO_RUNL, "CThumbnailStoreDiskSpaceNotifierAO::RunL - NOT FULL" ); iDiskFull = EFalse; } iState = ENormal; @@ -2965,6 +3170,7 @@ else { TN_DEBUG1( "CThumbnailStoreDiskSpaceNotifierAO::RunL() KErrGeneral"); + OstTrace0( TRACE_NORMAL, DUP7_CTHUMBNAILSTOREDISKSPACENOTIFIERAO_RUNL, "CThumbnailStoreDiskSpaceNotifierAO::RunL - KErrGeneral" ); User::Leave( KErrGeneral ); } } @@ -2972,6 +3178,7 @@ TInt CThumbnailStoreDiskSpaceNotifierAO::RunError(TInt aError) { TN_DEBUG2( "CThumbnailStoreDiskSpaceNotifierAO::RunError() %d", aError); + OstTrace1( TRACE_NORMAL, CTHUMBNAILSTOREDISKSPACENOTIFIERAO_RUNERROR, "CThumbnailStoreDiskSpaceNotifierAO::RunError;aError=%d", aError ); iObserver.HandleDiskSpaceError( aError ); @@ -2981,6 +3188,7 @@ void CThumbnailStoreDiskSpaceNotifierAO::DoCancel() { TN_DEBUG1( "CThumbnailStoreDiskSpaceNotifierAO::DoCancel()"); + OstTrace0( TRACE_NORMAL, CTHUMBNAILSTOREDISKSPACENOTIFIERAO_DOCANCEL, "CThumbnailStoreDiskSpaceNotifierAO::DoCancel" ); if( IsActive() ) { @@ -2994,12 +3202,14 @@ iObserver( aObserver ), iThreshold( aThreshold ), iDrive( aDrive ), iState( CThumbnailStoreDiskSpaceNotifierAO::ENormal ), iDiskFull( EFalse ) { TN_DEBUG1( "CThumbnailStoreDiskSpaceNotifierAO::CThumbnailStoreDiskSpaceNotifierAO()"); + OstTrace0( TRACE_NORMAL, DUP1_CTHUMBNAILSTOREDISKSPACENOTIFIERAO_CTHUMBNAILSTOREDISKSPACENOTIFIERAO, "CThumbnailStoreDiskSpaceNotifierAO::CThumbnailStoreDiskSpaceNotifierAO" ); CActiveScheduler::Add( this ); } void CThumbnailStoreDiskSpaceNotifierAO::ConstructL() { TN_DEBUG1( "CThumbnailStoreDiskSpaceNotifierAO::ConstructL()"); + OstTrace0( TRACE_NORMAL, CTHUMBNAILSTOREDISKSPACENOTIFIERAO_CONSTRUCTL, "CThumbnailStoreDiskSpaceNotifierAO::ConstructL" ); TInt KMessageSlotCount = 2; // slots for NotifyDiskSpace and NotifyDiskSpaceCancel User::LeaveIfError( iFileServerSession.Connect( KMessageSlotCount ) ); @@ -3012,12 +3222,14 @@ if ( volumeInfo.iFree < iThreshold ) { TN_DEBUG1( "CThumbnailStoreDiskSpaceNotifierAO::ConstructL() FULL"); + OstTrace0( TRACE_NORMAL, DUP1_CTHUMBNAILSTOREDISKSPACENOTIFIERAO_CONSTRUCTL, "CThumbnailStoreDiskSpaceNotifierAO::ConstructL - FULL" ); iDiskFull = ETrue; } } else { TN_DEBUG2( "CThumbnailStoreDiskSpaceNotifierAO::ConstructL() error %d NOT FULL", ret); + OstTrace1( TRACE_NORMAL, DUP2_CTHUMBNAILSTOREDISKSPACENOTIFIERAO_CONSTRUCTL, "CThumbnailStoreDiskSpaceNotifierAO::ConstructL - NOT FULL;ret=%d", ret ); iDiskFull = EFalse; User::Leave( ret ); } @@ -3030,6 +3242,7 @@ void CThumbnailStoreDiskSpaceNotifierAO::StartNotifier() { TN_DEBUG2( "CThumbnailStoreDiskSpaceNotifierAO::StartNotifier() iDrive == %d", iDrive); + OstTrace1( TRACE_NORMAL, CTHUMBNAILSTOREDISKSPACENOTIFIERAO_STARTNOTIFIER, "CThumbnailStoreDiskSpaceNotifierAO::StartNotifier;iDrive=%d", iDrive ); iFileServerSession.NotifyDiskSpace( iThreshold, iDrive, iStatus ); SetActive();