diff -r 2e2a89493e2b -r 48dd0f169f0d imagehandlingutilities/thumbnailmanager/thumbnailserver/src/thumbnailstore.cpp --- a/imagehandlingutilities/thumbnailmanager/thumbnailserver/src/thumbnailstore.cpp Fri Sep 03 10:29:37 2010 +0300 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,3258 +0,0 @@ -/* -* Copyright (c) 2006-2007 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: Store for thumbnails. - * -*/ - - -#include -#include -#include -#include -#include -#include -#include -#include - -#include "thumbnailstore.h" -#include "thumbnailsql.h" -#include "thumbnaillog.h" -#include "thumbnailmanageruids.hrh" -#include "thumbnailcenrep.h" -#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;" ); - -const TInt KStreamBufferSize = 1024 * 8; -const TInt KMajor = 3; -const TInt KMinor = 2; - -const TInt KStoreUnrecoverableErr = KErrCorrupt; - -// Database path without drive letter -//Symbian^4 v5 -_LIT( KThumbnailDatabaseName, ":[102830AB]thumbnail_v5.db" ); - - -// Allow access to database only for the server process -const TSecurityPolicy KThumbnailDatabaseSecurityPolicy( TSecureId( - THUMBNAIL_MANAGER_SERVER_UID )); - - -// --------------------------------------------------------------------------- -// RThumbnailTransaction::RThumbnailTransaction::TThumbnailPersistentSize -// --------------------------------------------------------------------------- -// -RThumbnailTransaction::RThumbnailTransaction( RSqlDatabase& aDatabase ): - iDatabase( aDatabase ), iState( EClosed ) - { - // No implementation required - } - -// --------------------------------------------------------------------------- -// RThumbnailTransaction::BeginL() -// --------------------------------------------------------------------------- -// -void RThumbnailTransaction::BeginL() - { - 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 - iState = EOldOpen; - - return; - } - - const TInt err = iDatabase.Exec( KThumbnailBeginTransaction ); - if ( err >= 0 ) - { - iState = EOpen; - } - else - { - iState = EError; -#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 ); - } - } - -// --------------------------------------------------------------------------- -// RThumbnailTransaction::Close() -// --------------------------------------------------------------------------- -// -void RThumbnailTransaction::Close() - { - if ( iState != EClosed && iState != EOldOpen ) - { - Rollback(); - } - } - -// --------------------------------------------------------------------------- -// RThumbnailTransaction::CommitL() -// --------------------------------------------------------------------------- -// -void RThumbnailTransaction::CommitL() - { - if ( iState != EOldOpen ) - { - TInt ret = iDatabase.Exec( KThumbnailCommitTransaction ); - -#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 ); - } - - iState = EClosed; - } - -// --------------------------------------------------------------------------- -// RThumbnailTransaction::Rollback() -// --------------------------------------------------------------------------- -// -TInt RThumbnailTransaction::Rollback() - { - if ( iState != EOldOpen ) - { - // in some cases there could have been automatic rollback - if (iDatabase.InTransaction()) - { - const TInt err = iDatabase.Exec( KThumbnailRollbackTransaction ); - if ( err >= 0 ) - { - iState = EClosed; - } - - return err; - } - else - { - TN_DEBUG1( "RThumbnailTransaction::Rollback() - automatic rollback already done!" ); - OstTrace0( TRACE_NORMAL, RTHUMBNAILTRANSACTION_ROLLBACK, "RThumbnailTransaction::Rollback - automatic rollback already done!" ); - } - } - - iState = EClosed; - - return KErrNone; - } - - -// ======== MEMBER FUNCTIONS ======== - -// --------------------------------------------------------------------------- -// CThumbnailStore::NewL() -// Two-phased constructor. -// --------------------------------------------------------------------------- -// -CThumbnailStore* CThumbnailStore::NewL( RFs& aFs, TInt aDrive, TDesC& aImei, CThumbnailServer* aServer, const TBool aReadOnly ) - { - CThumbnailStore* self = new( ELeave )CThumbnailStore( aFs, aDrive, aImei, aServer, aReadOnly ); - CleanupStack::PushL( self ); - self->ConstructL(); - CleanupStack::Pop( self ); - return self; - } - - -// --------------------------------------------------------------------------- -// CThumbnailStore::~CThumbnailStore() -// Destructor. -// --------------------------------------------------------------------------- -// -CThumbnailStore::~CThumbnailStore() - { - TN_DEBUG2( "CThumbnailStore::~CThumbnailStore() drive: %d", iDrive ); - OstTrace1( TRACE_NORMAL, CTHUMBNAILSTORE_CTHUMBNAILSTORE, "CThumbnailStore::~CThumbnailStore;iDrive=%d", iDrive ); - - if(iActivityManager) - { - delete iActivityManager; - iActivityManager = NULL; - } - - if(iDiskFullNotifier) - { - delete iDiskFullNotifier; - iDiskFullNotifier = NULL; - } - - if( iAutoFlushTimer ) - { - iAutoFlushTimer->Cancel(); - delete iAutoFlushTimer; - iAutoFlushTimer = NULL; - } - - if( iMaintenanceTimer ) - { - iMaintenanceTimer->Cancel(); - delete iMaintenanceTimer; - iMaintenanceTimer = NULL; - } - - CloseStatements(); - iDatabase.Close(); - - TN_DEBUG1( "CThumbnailStore::~CThumbnailStore() - database closed" ); - OstTrace0( TRACE_NORMAL, DUP1_CTHUMBNAILSTORE_CTHUMBNAILSTORE, "CThumbnailStore::~CThumbnailStore - database closed" ); - } - -// --------------------------------------------------------------------------- -// CThumbnailStore::CThumbnailStore() -// C++ default constructor can NOT contain any code, that might leave. -// --------------------------------------------------------------------------- -// -CThumbnailStore::CThumbnailStore( RFs& aFs, TInt aDrive, TDesC& aImei, CThumbnailServer* aServer, const TBool aReadOnly ): - iFs( aFs ), iDrive( aDrive ), iDriveChar( 0 ), iBatchItemCount(0), iImei(aImei), iServer(aServer), iDiskFullNotifier(NULL), - iDiskFull(EFalse), iActivityManager(NULL), iUnrecoverable(ETrue), iBatchFlushItemCount(KMInBatchItems), iReadOnly(aReadOnly) - { - // no implementation required - } - -// --------------------------------------------------------------------------- -// CThumbnailStore::ConstructL() -// Symbian 2nd phase constructor can leave. -// --------------------------------------------------------------------------- -// -void CThumbnailStore::ConstructL() - { - TN_DEBUG1( "CThumbnailStore::ConstructL()" ); - OstTrace0( TRACE_NORMAL, CTHUMBNAILSTORE_CONSTRUCTL, "CThumbnailStore::ConstructL" ); - -#ifdef _DEBUG - iThumbCounter = 0; -#endif - if(!iReadOnly) - { - HBufC* databasePath = HBufC::NewLC( KMaxFileName ); - TPtr pathPtr = databasePath->Des(); - User::LeaveIfError( RFs::DriveToChar( iDrive, iDriveChar )); - pathPtr.Append( iDriveChar ); - pathPtr.Append( KThumbnailDatabaseName ); - - //start disk space monitor - iDiskFullNotifier = CThumbnailStoreDiskSpaceNotifierAO::NewL( *this, - KDiskFullThreshold, - pathPtr ); - - CleanupStack::PopAndDestroy( databasePath ); - - TN_DEBUG2( "CThumbnailStore::ConstructL() drive: %d", iDrive ); - OstTrace1( TRACE_NORMAL, DUP1_CTHUMBNAILSTORE_CONSTRUCTL, "CThumbnailStore::ConstructL;iDrive=%d", iDrive ); - - OpenDatabaseL(); - - // to monitor device activity - iActivityManager = CTMActivityManager::NewL( this, KStoreMaintenanceIdle); - iActivityManager->Start(); - - iDeleteThumbs = ETrue; - iCheckFilesExist = ETrue; - } - 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; - } - } - -// --------------------------------------------------------------------------- -// OpenDatabaseL database file -// --------------------------------------------------------------------------- -TInt CThumbnailStore::OpenDatabaseFileL() - { - TN_DEBUG1( "CThumbnailStore::OpenDatabaseFile()" ); - OstTrace0( TRACE_NORMAL, CTHUMBNAILSTORE_OPENDATABASEFILEL, "CThumbnailStore::OpenDatabaseFileL" ); - - HBufC* databasePath = HBufC::NewLC( KMaxFileName ); - TPtr pathPtr = databasePath->Des(); - TChar driveChar = 0; - User::LeaveIfError( RFs::DriveToChar( iDrive, driveChar )); - pathPtr.Append( driveChar ); - pathPtr.Append( KThumbnailDatabaseName ); - - TInt ret = iDatabase.Open( pathPtr ); - CleanupStack::PopAndDestroy( databasePath ); - return ret; - } - -// --------------------------------------------------------------------------- -// OpenDatabaseL database -// --------------------------------------------------------------------------- -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(); - iUnrecoverable = ETrue; - - TInt checkError = KErrNone; - TInt blistError = KErrNone; - TInt blistError2 = KErrNone; - TInt imeiError = KErrNone; - TInt err = KErrNone; - - if (aNewDatabase) - { - // delete existing and create new - CleanupClosePushL(iDatabase); - RecreateDatabaseL(ETrue); - CleanupStack::Pop(&iDatabase); - } - else - { - // just open old - err = OpenDatabaseFileL(); - - TN_DEBUG2( "CThumbnailStore::OpenDatabaseL() -- err = %d", err); - OstTrace1( TRACE_NORMAL, DUP1_CTHUMBNAILSTORE_OPENDATABASEL, "CThumbnailStore::OpenDatabaseL;err=%d", err ); - - if ( err == KErrNone) - { - // db found, check version and rowids - checkError = CheckVersion(); - if(checkError == KErrNone) - { - checkError = CheckRowIDs(); - } - } - - // if db file not found, wrong version, corrupted database or other error opening db - if ( err != KErrNone || checkError == KErrNotSupported ) - { - CleanupClosePushL(iDatabase); - RecreateDatabaseL(ETrue); - CleanupStack::Pop(&iDatabase); - - aNewDatabase = ETrue; - } - } - - // opened existing database file - if(!aNewDatabase) - { - // add temp tables - CreateTempTablesL(); - - //check ownership - imeiError = CheckImei(); - - if(imeiError != KErrNone) - { - //take ownership - TRAP(imeiError, UpdateImeiL() ); - - //Touch blacklisted items - TRAP(blistError, PrepareBlacklistedItemsForRetryL() ); - } - - //check if MMC is known - if(CheckMediaIDL() != KErrNone) - { - //Touch blacklisted items - TRAP(blistError2, PrepareBlacklistedItemsForRetryL() ); - } - - if(imeiError != KErrNone || blistError != KErrNone || blistError2 != KErrNone ) - { - CleanupClosePushL(iDatabase); - RecreateDatabaseL(ETrue); - CleanupStack::Pop(&iDatabase); - } - } - - PrepareStatementsL(); - - // database now usable - iUnrecoverable = EFalse; - - return KErrNone; - } - -// --------------------------------------------------------------------------- -// PrepareDbL database tables -// --------------------------------------------------------------------------- -// -void CThumbnailStore::PrepareDbL() - { - TN_DEBUG1( "CThumbnailStore::PrepareDbL()" ); - OstTrace0( TRACE_NORMAL, CTHUMBNAILSTORE_PREPAREDBL, "CThumbnailStore::PrepareDbL" ); - - // add persistent tables - CreateTablesL(); - - AddVersionAndImeiL(); - - // add temp tables - CreateTempTablesL(); - } - -// --------------------------------------------------------------------------- -// Create database tables -// --------------------------------------------------------------------------- -// -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 ); - TN_DEBUG2( "CThumbnailStore::CreateTablesL() KThumbnailCreateInfoTableIndex1 err=%d", err ); - User::LeaveIfError( err ); - - 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 ); - } - -// --------------------------------------------------------------------------- -// Create temp tables -// --------------------------------------------------------------------------- -// -void CThumbnailStore::CreateTempTablesL() - { - TN_DEBUG1( "CThumbnailStore::CreateTempTablesL()" ); - OstTrace0( TRACE_NORMAL, CTHUMBNAILSTORE_CREATETEMPTABLESL, "CThumbnailStore::CreateTempTablesL" ); - - TInt err = iDatabase.Exec( KThumbnailCreateTempInfoTable ); - -#ifdef _DEBUG - if(err < 0) - { - TPtrC errorMsg = iDatabase.LastErrorMessage(); - TN_DEBUG2( "CThumbnailStore::PrepareDbL() KThumbnailCreateTempInfoTable %S" , &errorMsg); - OstTraceExt1( TRACE_NORMAL, DUP1_CTHUMBNAILSTORE_CREATETEMPTABLESL, "CThumbnailStore::CreateTempTablesL - KThumbnailCreateTempInfoTable;errorMsg=%S", errorMsg ); - } -#endif - - User::LeaveIfError( err ); - - err = iDatabase.Exec( KThumbnailCreateTempInfoDataTable ); - -#ifdef _DEBUG - if(err < 0) - { - TPtrC errorMsg = iDatabase.LastErrorMessage(); - TN_DEBUG2( "CThumbnailStore::PrepareDbL() KThumbnailCreateTempInfoDataTable %S" , &errorMsg); - OstTraceExt1( TRACE_NORMAL, DUP2_CTHUMBNAILSTORE_CREATETEMPTABLESL, "CThumbnailStore::CreateTempTablesL - KThumbnailCreateTempInfoDataTable;errorMsg=%S", errorMsg ); - } -#endif - - User::LeaveIfError( err ); - } - -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) ); - TUint id = volumeinfo.iUniqueID; - TBuf<50> mediaid; - mediaid.Num(id); - - CloseStatements(); - iDatabase.Close(); - 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(); - User::LeaveIfError( RFs::DriveToChar( iDrive, iDriveChar )); - pathPtr.Append( iDriveChar ); - pathPtr.Append( KThumbnailDatabaseName ); - - TInt err(KErrNone); - - // delete old if necessary - 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; - - RSqlSecurityPolicy securityPolicy; - CleanupClosePushL( securityPolicy ); - securityPolicy.CreateL( KThumbnailDatabaseSecurityPolicy ); - - // 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 ); - - // add tables - 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); - - // write media id file if doesn't exist - if(!BaflUtils::FileExists( iFs, mediaid )) - { - RFile64 file; - mediaidErr = file.Create(iFs, mediaid, EFileShareReadersOrWriters ); - 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 - if (prepareErr < 0 || mediaidErr < 0) - { - 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 ); - User::LeaveIfError( mediaidErr ); - - CleanupStack::PopAndDestroy( databasePath ); - } - -TInt CThumbnailStore::CheckRowIDs() - { - TN_DEBUG1( "CThumbnailStore::CheckRowIDs()"); - OstTrace0( TRACE_FATAL, CTHUMBNAILSTORE_CHECKROWIDS, "CThumbnailStore::CheckRowIDs" ); - - RSqlStatement stmt; - TInt column = 0; - TInt rowStatus = 0; - TInt64 inforows = -1; - TInt64 datarows = -1; - - TInt ret = stmt.Prepare( iDatabase, KGetInfoRowID ); - if(ret < 0) - { - 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(); - - if ( rowStatus == KSqlAtRow) - { - inforows = stmt.ColumnInt64( column ); - } - - stmt.Close(); - - if(rowStatus < 0) - { -#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; - } - - ret = stmt.Prepare( iDatabase, KGetDataRowID ); - if(ret < 0) - { - stmt.Close(); - TN_DEBUG1( "CThumbnailStore::CheckRowIDs() KGetDataRowID failed"); - OstTrace0( TRACE_FATAL, DUP3_CTHUMBNAILSTORE_CHECKROWIDS, "CThumbnailStore::CheckRowIDs - KGetDataRowID failed" ); - return KErrNotSupported; - } - rowStatus = stmt.Next(); - - if ( rowStatus == KSqlAtRow) - { - datarows = stmt.ColumnInt64( column ); - } - - stmt.Close(); - - if( rowStatus < 0) - { -#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 ) - { - TN_DEBUG1( "CThumbnailStore::CheckRowIDsL() - tables out of sync" ); - return KErrNotSupported; - } - else - { - return KErrNone; - } - } - -// ----------------------------------------------------------------------------- -// CheckVersion() -// ----------------------------------------------------------------------------- -// -TInt CThumbnailStore::CheckVersion() - { - TN_DEBUG1( "CThumbnailStore::CheckVersion()" ); - OstTrace0( TRACE_FATAL, CTHUMBNAILSTORE_CHECKVERSION, "CThumbnailStore::CheckVersion" ); - RSqlStatement stmt; - - TInt rowStatus = 0; - TInt column = 0; - TInt minor = 0; - TInt major = 0; - - TInt ret = stmt.Prepare( iDatabase, KThumbnailSelectFromVersion ); - if(ret < 0 ) - { - stmt.Close(); - TN_DEBUG1( "CThumbnailStore::CheckVersion() unknown version" ); - OstTrace0( TRACE_FATAL, DUP1_CTHUMBNAILSTORE_CHECKVERSION, "CThumbnailStore::CheckVersion - unknown version" ); - return KErrNotSupported; - } - - rowStatus = stmt.Next(); - - if ( rowStatus == KSqlAtRow) - { - major = stmt.ColumnInt( column++); - minor = stmt.ColumnInt( column++); - } - - stmt.Close(); - - if( rowStatus < 0 ) - { -#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; - } - - if(major == KMajor && minor == KMinor ) - { - return KErrNone; - } - else - { - TN_DEBUG1( "CThumbnailStore::CheckVersion() - wrong DB version" ); - OstTrace0( TRACE_FATAL, DUP3_CTHUMBNAILSTORE_CHECKVERSION, "CThumbnailStore::CheckVersion" ); - return KErrNotSupported; - } - } - -// ----------------------------------------------------------------------------- -// CheckImei() -// ----------------------------------------------------------------------------- -// -TInt CThumbnailStore::CheckImei() - { - TN_DEBUG1( "CThumbnailStore::CheckImei()" ); - OstTrace0( TRACE_FATAL, CTHUMBNAILSTORE_CHECKIMEI, "CThumbnailStore::CheckImei" ); - RSqlStatement stmt; - - TInt rowStatus = 0; - TInt column = 0; - TBuf imei; - - TInt ret = stmt.Prepare( iDatabase, KThumbnailSelectFromVersion ); - if(ret < 0 ) - { - stmt.Close(); - TN_DEBUG1( "CThumbnailStore::CheckImei() failed" ); - OstTrace0( TRACE_FATAL, DUP1_CTHUMBNAILSTORE_CHECKIMEI, "CThumbnailStore::CheckImei - failed" ); - return KErrNotSupported; - } - - rowStatus = stmt.Next(); - - if ( rowStatus == KSqlAtRow) - { - column = 2; // imei column - stmt.ColumnText( column, imei); - } - - stmt.Close(); - - if( rowStatus < 0 ) - { -#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; - } - - if( imei == iImei ) - { - return KErrNone; - } - else - { - TN_DEBUG1( "CThumbnailStore::CheckImei() mismatch" ); - OstTrace0( TRACE_FATAL, DUP3_CTHUMBNAILSTORE_CHECKIMEI, "CThumbnailStore::CheckImei - mismatch" ); - return KErrNotSupported; - } - } - -// ----------------------------------------------------------------------------- -// CheckMediaID() -// ----------------------------------------------------------------------------- -// -TInt CThumbnailStore::CheckMediaIDL() - { - TN_DEBUG1( "CThumbnailStore::CheckMediaIDL()" ); - OstTrace0( TRACE_FATAL, CTHUMBNAILSTORE_CHECKMEDIAIDL, "CThumbnailStore::CheckMediaIDL" ); - - TVolumeInfo volumeinfo; - User::LeaveIfError( iFs.Volume(volumeinfo, iDrive) ); - TUint id = volumeinfo.iUniqueID; - TBuf<50> mediaid; - mediaid.Num(id); - - if(!BaflUtils::FileExists( iFs, mediaid )) - { - RFile64 file; - 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; - } - - return KErrNone; - } - -// ---------------------------------------------------------------------------- -// AddVersionAndImeiL() -// ----------------------------------------------------------------------------- -// -void CThumbnailStore::AddVersionAndImeiL() - { - TN_DEBUG1( "CThumbnailStore::AddVersionAndImei()" ); - OstTrace0( TRACE_FATAL, CTHUMBNAILSTORE_ADDVERSIONANDIMEIL, "CThumbnailStore::AddVersionAndImeiL" ); - RSqlStatement stmt; - CleanupClosePushL( stmt ); - - TInt paramIndex = 0; - - User::LeaveIfError( stmt.Prepare( iDatabase, KThumbnailInsertToVersion )); - paramIndex = stmt.ParameterIndex( KThumbnailSqlParamImei ); - User::LeaveIfError( paramIndex ); - User::LeaveIfError( stmt.BindText( paramIndex, iImei )); - - paramIndex = stmt.ParameterIndex( KThumbnailSqlParamMinor ); - User::LeaveIfError( paramIndex ); - User::LeaveIfError( stmt.BindInt( paramIndex, KMinor )); - - paramIndex = stmt.ParameterIndex( KThumbnailSqlParamMajor ); - User::LeaveIfError( paramIndex ); - User::LeaveIfError( stmt.BindInt( paramIndex, KMajor )); - - User::LeaveIfError( stmt.Exec()); - CleanupStack::PopAndDestroy( &stmt ); - } - -// ----------------------------------------------------------------------------- -// UpdateImeiL() -// ----------------------------------------------------------------------------- -// -void CThumbnailStore::UpdateImeiL() - { - TN_DEBUG1( "CThumbnailStore::UpdateImeiL()" ); - OstTrace0( TRACE_FATAL, CTHUMBNAILSTORE_UPDATEIMEIL, "CThumbnailStore::UpdateImeiL" ); - RSqlStatement stmt; - CleanupClosePushL( stmt ); - - User::LeaveIfError( stmt.Prepare( iDatabase, KThumbnailUpdateIMEI ) ); - - TInt paramIndex = stmt.ParameterIndex( KThumbnailSqlParamImei ); - User::LeaveIfError( paramIndex ); - User::LeaveIfError( stmt.BindText( paramIndex, iImei )); - - TInt err = stmt.Exec(); - - if(err < 0) - { -#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); - } - - CleanupStack::PopAndDestroy( &stmt ); - } - -// --------------------------------------------------------------------------- -// CThumbnailStore::PrepareStatementsL() -// --------------------------------------------------------------------------- -// -void CThumbnailStore::PrepareStatementsL() - { - TN_DEBUG1("CThumbnailStore::PrepareStatementsL()"); - OstTrace0( TRACE_FATAL, CTHUMBNAILSTORE_PREPARESTATEMENTSL, "CThumbnailStore::PrepareStatementsL" ); - - TInt err = KErrNone; -#ifdef _DEBUG - TFileName msg; -#endif - - err = iStmt_KThumbnailSelectInfoByPath.Prepare( iDatabase, KThumbnailSelectInfoByPath ); -#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 ); - - err = iStmt_KThumbnailSelectTempInfoByPath.Prepare( iDatabase, KThumbnailSelectTempInfoByPath ); -#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 ); - - err = iStmt_KThumbnailInsertTempThumbnailInfo.Prepare( iDatabase, KThumbnailInsertTempThumbnailInfo ); -#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 ); - - err = iStmt_KThumbnailInsertTempThumbnailInfoData.Prepare( iDatabase, KThumbnailInsertTempThumbnailInfoData ); -#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 ); - - err = iStmt_KThumbnailSelectModifiedByPath.Prepare( iDatabase, KThumbnailSelectModifiedByPath ); -#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 ); - - err = iStmt_KThumbnailSelectTempModifiedByPath.Prepare( iDatabase, KThumbnailSelectTempModifiedByPath ); -#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 ); - - err = iStmt_KThumbnailFindDuplicate.Prepare( iDatabase, KThumbnailFindDuplicate ); -#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 ); - - err = iStmt_KThumbnailTempFindDuplicate.Prepare( iDatabase, KThumbnailTempFindDuplicate ); -#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 ); - - err = iStmt_KThumbnailSqlFindDeleted.Prepare( iDatabase, KThumbnailSqlFindDeleted ); -#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 ); - - err = iStmt_KThumbnailSelectSizeByPath.Prepare( iDatabase, KThumbnailSelectSizeByPath ); -#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 ); - - err = iStmt_KThumbnailSelectTempSizeByPath.Prepare( iDatabase, KThumbnailSelectTempSizeByPath ); -#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 ); - - err = iStmt_KThumbnailSqlSelectRowIDInfoByPath.Prepare( iDatabase, KThumbnailSqlSelectRowIDInfoByPath ); -#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 ); - - err = iStmt_KThumbnailSqlDeleteInfoByPath.Prepare( iDatabase, KThumbnailSqlDeleteInfoByPath ); -#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 ); - - err = iStmt_KThumbnailSqlDeleteInfoDataByPath.Prepare( iDatabase, KThumbnailSqlDeleteInfoDataByPath ); -#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 ); - - err = iStmt_KTempThumbnailSqlSelectRowIDInfoByPath.Prepare( iDatabase, KTempThumbnailSqlSelectRowIDInfoByPath ); -#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 ); - - err = iStmt_KTempThumbnailSqlDeleteInfoByPath.Prepare( iDatabase, KTempThumbnailSqlDeleteInfoByPath ); -#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 ); - - err = iStmt_KTempThumbnailSqlDeleteInfoDataByPath.Prepare( iDatabase, KTempThumbnailSqlDeleteInfoDataByPath ); -#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 ); - - err = iStmt_KThumbnailSqlInsertDeleted.Prepare( iDatabase, KThumbnailSqlInsertDeleted ); -#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 ); - - err = iStmt_KThumbnailSqlSelectMarked.Prepare( iDatabase, KThumbnailSqlSelectMarked ); -#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 ); - - err = iStmt_KThumbnailSqlDeleteInfoByRowID.Prepare( iDatabase, KThumbnailSqlDeleteInfoByRowID ); -#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 ); - - err = iStmt_KThumbnailSqlDeleteInfoDataByRowID.Prepare( iDatabase, KThumbnailSqlDeleteInfoDataByRowID ); -#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 ); - - err = iStmt_KThumbnailSelectAllPaths.Prepare( iDatabase, KThumbnailSelectAllPaths ); -#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 ); - - err = iStmt_KThumbnailRename.Prepare( iDatabase, KThumbnailRename ); -#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 ); - - err = iStmt_KThumbnailTempRename.Prepare( iDatabase, KThumbnailTempRename ); -#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" ); - } - -// --------------------------------------------------------------------------- -// CThumbnailStore::ResetStatement() -// --------------------------------------------------------------------------- -// -void CThumbnailStore::ResetStatement( TAny* aStmt ) - { - // called by CleanupStack::PopAndDestroy() - // just reset so that there's no need to prepare again - ((RSqlStatement*)aStmt)->Reset(); - } - -// --------------------------------------------------------------------------- -// CThumbnailStore::CloseStatements() -// --------------------------------------------------------------------------- -// -void CThumbnailStore::CloseStatements() - { - TN_DEBUG1("CThumbnailStore::CloseStatements()"); - OstTrace0( TRACE_NORMAL, CTHUMBNAILSTORE_CLOSESTATEMENTS, "CThumbnailStore::CloseStatements" ); - - iStmt_KThumbnailSelectInfoByPath.Close(); - iStmt_KThumbnailSelectTempInfoByPath.Close(); - iStmt_KThumbnailInsertTempThumbnailInfo.Close(); - iStmt_KThumbnailInsertTempThumbnailInfoData.Close(); - iStmt_KThumbnailSelectModifiedByPath.Close(); - iStmt_KThumbnailSelectTempModifiedByPath.Close(); - iStmt_KThumbnailFindDuplicate.Close(); - iStmt_KThumbnailTempFindDuplicate.Close(); - iStmt_KThumbnailSqlFindDeleted.Close(); - iStmt_KThumbnailSelectSizeByPath.Close(); - iStmt_KThumbnailSelectTempSizeByPath.Close(); - iStmt_KThumbnailSqlSelectRowIDInfoByPath.Close(); - iStmt_KThumbnailSqlDeleteInfoByPath.Close(); - iStmt_KThumbnailSqlDeleteInfoDataByPath.Close(); - iStmt_KTempThumbnailSqlSelectRowIDInfoByPath.Close(); - iStmt_KTempThumbnailSqlDeleteInfoByPath.Close(); - iStmt_KTempThumbnailSqlDeleteInfoDataByPath.Close(); - iStmt_KThumbnailSqlInsertDeleted.Close(); - iStmt_KThumbnailSqlSelectMarked.Close(); - iStmt_KThumbnailSqlDeleteInfoByRowID.Close(); - iStmt_KThumbnailSqlDeleteInfoDataByRowID.Close(); - iStmt_KThumbnailSelectAllPaths.Close(); - iStmt_KThumbnailRename.Close(); - iStmt_KThumbnailTempRename.Close(); - - TN_DEBUG1("CThumbnailStore::CloseStatements() end"); - OstTrace0( TRACE_NORMAL, DUP1_CTHUMBNAILSTORE_CLOSESTATEMENTS, "CThumbnailStore::CloseStatements - end" ); - } - -// --------------------------------------------------------------------------- -// CThumbnailStore::StoreThumbnailL() -// Stores thumbnail image. -// --------------------------------------------------------------------------- -// -void CThumbnailStore::StoreThumbnailL( const TDesC& aPath, const TDes8& aData, - const TSize& aSize, const TSize& aOriginalSize, const TThumbnailFormat& aFormat, TInt aFlags, - const TThumbnailSize& aThumbnailSize, const TInt64 aModified, const TBool aThumbFromPath ) - { - TN_DEBUG1( "CThumbnailStore::StoreThumbnailL( private ) in" ); - - if(iReadOnly) - { - TN_DEBUG1( "CThumbnailStore::StoreThumbnailL() read only, skip..." ); - return; - } - -#ifdef _DEBUG - TTime aStart, aStop; - aStart.UniversalTime(); -#endif - - //Encapsulate insert to Transaction - RThumbnailTransaction transaction( iDatabase ); - CleanupClosePushL( transaction ); - transaction.BeginL(); - - // Insert into TempThumbnailInfo - RSqlStatement* stmt = NULL; - stmt = &iStmt_KThumbnailInsertTempThumbnailInfo; - CleanupStack::PushL(TCleanupItem(ResetStatement, stmt)); - - TInt paramIndex = stmt->ParameterIndex( KThumbnailSqlParamPath ); - User::LeaveIfError( paramIndex ); - User::LeaveIfError( stmt->BindText( paramIndex, aPath )); - - paramIndex = stmt->ParameterIndex( KThumbnailSqlParamWidth ); - User::LeaveIfError( paramIndex ); - User::LeaveIfError( stmt->BindInt( paramIndex, aSize.iWidth )); - - paramIndex = stmt->ParameterIndex( KThumbnailSqlParamHeight ); - User::LeaveIfError( paramIndex ); - User::LeaveIfError( stmt->BindInt( paramIndex, aSize.iHeight )); - - paramIndex = stmt->ParameterIndex( KThumbnailSqlParamOriginalWidth ); - User::LeaveIfError( paramIndex ); - User::LeaveIfError( stmt->BindInt( paramIndex, aOriginalSize.iWidth )); - - paramIndex = stmt->ParameterIndex( KThumbnailSqlParamOriginalHeight ); - User::LeaveIfError( paramIndex ); - User::LeaveIfError( stmt->BindInt( paramIndex, aOriginalSize.iHeight )); - - paramIndex = stmt->ParameterIndex( KThumbnailSqlParamFormat ); - User::LeaveIfError( paramIndex ); - User::LeaveIfError( stmt->BindInt( paramIndex, aFormat )); - - paramIndex = stmt->ParameterIndex( KThumbnailSqlParamFlags ); - User::LeaveIfError( paramIndex ); - User::LeaveIfError( stmt->BindInt( paramIndex, aFlags )); - - paramIndex = stmt->ParameterIndex( KThumbnailSqlParamSize ); - User::LeaveIfError( paramIndex ); - User::LeaveIfError( stmt->BindInt( paramIndex, aThumbnailSize )); - - // orientation temporarily to 0 - paramIndex = stmt->ParameterIndex( KThumbnailSqlParamOrientation ); - User::LeaveIfError( paramIndex ); - User::LeaveIfError( stmt->BindInt( paramIndex, 0 )); - - // thumb from associated path - TInt fromPath = aThumbFromPath; - paramIndex = stmt->ParameterIndex( KThumbnailSqlParamThumbFromPath ); - User::LeaveIfError( paramIndex ); - User::LeaveIfError( stmt->BindInt( paramIndex, fromPath )); - - // try getting modification time from file - 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 ) - { - timeStamp = aModified; - } - else - { - TInt timeErr = KErrNone; - - if (aPath.Length()) - { - // need to add drive letter - TFileName path; - path.Append(iDriveChar); - path.Append(KDrv); - path.Append(aPath); - - timeErr = iFs.Modified(path, timeStamp); - - 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() ); - } - } - - if (!aPath.Length() || timeErr != KErrNone) - { - // 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 ); - User::LeaveIfError( stmt->BindInt64( paramIndex, timeStamp.Int64() )); - - User::LeaveIfError( stmt->Exec()); - CleanupStack::PopAndDestroy( stmt ); - - // Insert into TempThumbnailInfoData - RSqlStatement* stmtData = NULL; - stmtData = &iStmt_KThumbnailInsertTempThumbnailInfoData; - CleanupStack::PushL(TCleanupItem(ResetStatement, stmtData)); - - paramIndex = stmtData->ParameterIndex( KThumbnailSqlParamData ); - User::LeaveIfError( paramIndex ); - User::LeaveIfError( stmtData->BindBinary( paramIndex, aData )); - - User::LeaveIfError( stmtData->Exec()); - CleanupStack::PopAndDestroy( stmtData ); - - // Commit transaction - transaction.CommitL(); - CleanupStack::PopAndDestroy( &transaction ); - - iBatchItemCount++; - - FlushCacheTable(); - -#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" ); - } - - -// --------------------------------------------------------------------------- -// CThumbnailStore::StoreThumbnailL() -// Stores thumbnail image. -// --------------------------------------------------------------------------- -// -void CThumbnailStore::StoreThumbnailL( const TDesC& aPath, CFbsBitmap* - aThumbnail, const TSize& aOriginalSize, TBool /*aCropped*/, const TThumbnailSize aThumbnailSize, - const TInt64 aModified, TBool aThumbFromPath, TBool aBlackListed ) - { - 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..." ); - return; - } - - __ASSERT_DEBUG(( aThumbnail ), ThumbnailPanic( EThumbnailNullPointer )); - - User::LeaveIfError( CheckDbState() ); - - // don't store custom/unknown sizes or zero sizes - if(aThumbnailSize == ECustomThumbnailSize || aThumbnailSize == EUnknownThumbnailSize - || thumbSize.iWidth <= 0 || thumbSize.iHeight <= 0 ) - { - TN_DEBUG1( "CThumbnailStore::StoreThumbnailL( public ) not stored"); - OstTrace0( TRACE_NORMAL, DUP10_CTHUMBNAILSTORE_STORETHUMBNAILL, "CThumbnailStore::StoreThumbnailL - not stored" ); - return; - } - - HBufC* path = aPath.AllocLC(); - TPtr ptr(path->Des()); - StripDriveLetterL( ptr ); - - // check for duplicates - TBool exists = FindDuplicateL(*path, aThumbnailSize); - - for ( TInt i = iPersistentSizes.Count(); --i >= 0; ) - { - TThumbnailPersistentSize & persistentSize = iPersistentSizes[i]; - - // don't store duplicates or zero sizes - if ( !exists ) - { - TInt flags = 0; - if ( persistentSize.iCrop ) - { - flags |= KThumbnailDbFlagCropped; - } - - if( aBlackListed ) - { - flags |= KThumbnailDbFlagBlacklisted; - } - - if( (aThumbnailSize == EImageFullScreenThumbnailSize || - aThumbnailSize == EVideoFullScreenThumbnailSize || - aThumbnailSize == EAudioFullScreenThumbnailSize || - aThumbnailSize == EContactFullScreenThumbnailSize) && !aBlackListed ) - { - TN_DEBUG1( "CThumbnailStore::StoreThumbnailL( public ) - encode jpg" ); - OstTrace0( TRACE_NORMAL, DUP11_CTHUMBNAILSTORE_STORETHUMBNAILL, "CThumbnailStore::StoreThumbnailL - encode jpg" ); - - HBufC8* data = NULL; - CleanupStack::PushL( data ); - - CImageEncoder* encoder = NULL; - - CImageEncoder::TOptions options = ( CImageEncoder::TOptions )( CImageEncoder::EOptionAlwaysThread ); - - TRAPD( decErr, encoder = CExtJpegEncoder::DataNewL( CExtJpegEncoder::EHwImplementation, data, options ) ); - 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 ); - CleanupStack::PushL( encoder ); - - CFrameImageData* frameImageData = CFrameImageData::NewL(); - CleanupStack::PushL( frameImageData ); - - TJpegImageData* imageData = new (ELeave) TJpegImageData(); - CleanupStack::PushL( imageData ); - - // Set some format specific data - imageData->iSampleScheme = TJpegImageData::EColor444; - imageData->iQualityFactor = 80; - - // imageData - ownership passed to frameImageData after AppendImageData - User::LeaveIfError(frameImageData->AppendImageData(imageData)); - CleanupStack::Pop( imageData ); - -#ifdef _DEBUG - TN_DEBUG4( "CThumbnailStore::StoreThumbnailL( public ) - size: %d x %d, displaymode: %d ", - aThumbnail->SizeInPixels().iWidth, - aThumbnail->SizeInPixels().iHeight, - aThumbnail->DisplayMode()); -#endif - - TRequestStatus request; - encoder->Convert( &request, *aThumbnail, frameImageData); - User::WaitForRequest( request); - - CleanupStack::PopAndDestroy( frameImageData ); - CleanupStack::PopAndDestroy( encoder ); - - 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(); - StoreThumbnailL( *path, ptr, aThumbnail->SizeInPixels(), - aOriginalSize, EThumbnailFormatJpeg, flags, - aThumbnailSize, aModified, aThumbFromPath ); - CleanupStack::Pop( data ); - } - 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; - data = NULL; - } - else - { - CBufFlat* buf = CBufFlat::NewL( KStreamBufferSize ); - CleanupStack::PushL( buf ); - RBufWriteStream stream; - stream.Open( *buf ); - aThumbnail->ExternalizeL( stream ); - - StoreThumbnailL( *path, buf->Ptr( 0 ), aThumbnail->SizeInPixels(), - aOriginalSize, EThumbnailFormatFbsBitmap, flags, - aThumbnailSize, aModified, aThumbFromPath); - - CleanupStack::PopAndDestroy( buf ); - } - - break; - } - } - - CleanupStack::PopAndDestroy( path ); - - TN_DEBUG1( "CThumbnailStore::StoreThumbnailL( public ) out" ); - OstTrace0( TRACE_NORMAL, DUP20_CTHUMBNAILSTORE_STORETHUMBNAILL, "CThumbnailStore::StoreThumbnailL - out" ); - } - -// --------------------------------------------------------------------------- -// Finds possible existing duplicate thumbnail. -// --------------------------------------------------------------------------- -// -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..." ); - return EFalse; - } - - User::LeaveIfError( CheckDbState() ); - - TInt rowStatus = 0; - TInt paramIndex = 0; - TInt found = EFalse; - - RSqlStatement* stmt = NULL; - stmt = &iStmt_KThumbnailTempFindDuplicate; - CleanupStack::PushL(TCleanupItem(ResetStatement, stmt)); - - paramIndex = stmt->ParameterIndex( KThumbnailSqlParamPath ); - User::LeaveIfError( paramIndex ); - User::LeaveIfError( stmt->BindText( paramIndex, aPath )); - - paramIndex = stmt->ParameterIndex( KThumbnailSqlParamSize ); - User::LeaveIfError( paramIndex ); - User::LeaveIfError( stmt->BindInt( paramIndex, aThumbnailSize )); - - rowStatus = stmt->Next(); - - //if not found from temp table, look from real table - if(rowStatus != KSqlAtRow) - { - CleanupStack::PopAndDestroy( stmt ); - stmt = &iStmt_KThumbnailFindDuplicate; - CleanupStack::PushL(TCleanupItem(ResetStatement, stmt)); - - paramIndex = stmt->ParameterIndex( KThumbnailSqlParamPath ); - User::LeaveIfError( paramIndex ); - User::LeaveIfError( stmt->BindText( paramIndex, aPath )); - - paramIndex = stmt->ParameterIndex( KThumbnailSqlParamSize ); - User::LeaveIfError( paramIndex ); - User::LeaveIfError( stmt->BindInt( paramIndex, aThumbnailSize )); - - rowStatus = stmt->Next(); - - 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; - } - - CleanupStack::PopAndDestroy( stmt ); - - // check if duplicate in Deleted - if (found) - { - stmt = &iStmt_KThumbnailSqlFindDeleted; - CleanupStack::PushL(TCleanupItem(ResetStatement, stmt)); - - paramIndex = stmt->ParameterIndex( KThumbnailSqlParamPath ); - User::LeaveIfError( paramIndex ); - User::LeaveIfError( stmt->BindText( paramIndex, aPath )); - - rowStatus = stmt->Next(); - - CleanupStack::PopAndDestroy( stmt ); - - 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; - } - } - - return found; - } - -// --------------------------------------------------------------------------- -// Get missing sizes by Path -// --------------------------------------------------------------------------- -// -void CThumbnailStore::GetMissingSizesL( const TDesC& aPath, TInt aSourceType, RArray < - 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..." ); - return; - } - - User::LeaveIfError( CheckDbState() ); - - HBufC* path = aPath.AllocLC(); - TPtr ptr(path->Des()); - StripDriveLetterL( ptr ); - - // define sizes to be checked - const TInt count = iPersistentSizes.Count(); - - for ( TInt i = 0 ; i < count; i++ ) - { - if ( iPersistentSizes[ i ].iSourceType == aSourceType && iPersistentSizes[ i ].iAutoCreate) - { - //if generating only grid size for image or video, other sizes are not missing - if( aCheckGridSizeOnly ) - { - if( (iPersistentSizes[i].iSourceType == TThumbnailPersistentSize::EImage || iPersistentSizes[i].iSourceType == TThumbnailPersistentSize::EVideo )&& - iPersistentSizes[i].iSizeType != TThumbnailPersistentSize::EGrid ) - { - 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 - { - aMissingSizes.AppendL( iPersistentSizes[ i ] ); - } - } - else - { - aMissingSizes.AppendL( iPersistentSizes[ i ] ); - } - } - } - - 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; - stmt = &iStmt_KThumbnailSelectTempSizeByPath; - CleanupStack::PushL(TCleanupItem(ResetStatement, stmt)); - - TInt paramIndex = stmt->ParameterIndex( KThumbnailSqlParamPath ); - User::LeaveIfError( paramIndex ); - User::LeaveIfError( stmt->BindText( paramIndex, *path )); - - TInt rowStatus = stmt->Next(); - - TInt round = 1; - TInt size = 0; - - while (round <= 2) - { - while ( rowStatus == KSqlAtRow && missingSizeCount > 0 ) - { - size = stmt->ColumnInt( 0 ); - - missingSizeCount = aMissingSizes.Count(); - for ( TInt i = 0; i < missingSizeCount; i++ ) - { - 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; - } - } - - rowStatus = stmt->Next(); - } - - CleanupStack::PopAndDestroy( stmt ); - - // all found - if (missingSizeCount == 0) - { - CleanupStack::PopAndDestroy( path ); - return; - } - else if (round == 1) - { - // change to real table - stmt = &iStmt_KThumbnailSelectSizeByPath; - CleanupStack::PushL(TCleanupItem(ResetStatement, stmt)); - - paramIndex = stmt->ParameterIndex( KThumbnailSqlParamPath ); - User::LeaveIfError( paramIndex ); - User::LeaveIfError( stmt->BindText( paramIndex, *path )); - rowStatus = stmt->Next(); - } - - round++; - } - - CleanupStack::PopAndDestroy( path ); - } - -// --------------------------------------------------------------------------- -// CThumbnailStore::FetchThumbnailL() -// Fetches thumbnail image. -// --------------------------------------------------------------------------- -// -void CThumbnailStore::FetchThumbnailL( const TDesC& aPath, CFbsBitmap* & - 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..." ); - User::Leave( KErrNotFound ); - } - - User::LeaveIfError( CheckDbState() ); - - HBufC* path = aPath.AllocLC(); - TPtr ptr(path->Des()); - StripDriveLetterL( ptr ); - - TInt paramIndex = 0; - TInt found = KErrNotFound; - TInt rowStatus = 0; - 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; - CleanupStack::PushL(TCleanupItem(ResetStatement, stmt)); - - paramIndex = stmt->ParameterIndex( KThumbnailSqlParamPath ); - User::LeaveIfError( paramIndex ); - User::LeaveIfError( stmt->BindText( paramIndex, *path )); - - paramIndex = stmt->ParameterIndex( KThumbnailSqlParamSize ); - User::LeaveIfError( paramIndex ); - User::LeaveIfError( stmt->BindInt( paramIndex, aThumbnailSize )); - - rowStatus = stmt->Next(); - - //if not found from temp table, look from real table - 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; - CleanupStack::PushL(TCleanupItem(ResetStatement, stmt)); - - paramIndex = stmt->ParameterIndex( KThumbnailSqlParamPath ); - User::LeaveIfError( paramIndex ); - User::LeaveIfError( stmt->BindText( paramIndex, *path )); - - paramIndex = stmt->ParameterIndex( KThumbnailSqlParamSize ); - User::LeaveIfError( paramIndex ); - User::LeaveIfError( stmt->BindInt( paramIndex, aThumbnailSize )); - - rowStatus = stmt->Next(); - } - - 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 - // changed, delete thumbnails from tables and leave with - // KErrNotFound to get thumbnail regenerated. - column = 4; - TInt flags = stmt->ColumnInt( column ); - if( flags & KThumbnailDbFlagDeleted ) - { - CleanupStack::PopAndDestroy( stmt ); - - // delete existing blacklisted thumbs - DeleteThumbnailsL(*path, ETrue); - - CleanupStack::PopAndDestroy( path ); - - User::Leave( KErrNotFound ); - } - else if( flags & KThumbnailDbFlagBlacklisted ) - { - CleanupStack::PopAndDestroy( stmt ); - CleanupStack::PopAndDestroy( path ); - - User::Leave( KErrCompletion ); - } - else if( !(flags & KThumbnailDbFlagBlacklisted) ) - { - found = KErrNone; - column = 0; - TInt format = stmt->ColumnInt( column++ ); - if(format == 1 /*TThumbnailFormat::EThumbnailFormatJpeg */ ) - { - TPtrC8 ptr = stmt->ColumnBinaryL( column++ ); - HBufC8* data = ptr.AllocL() ; - aThumbnail = NULL; - aData = data; - } - else - { - TPtrC8 ptr = stmt->ColumnBinaryL( column++ ); - RDesReadStream stream( ptr ); - aThumbnail = new( ELeave )CFbsBitmap(); - CleanupStack::PushL( aThumbnail ); - aThumbnail->InternalizeL( stream ); - CleanupStack::Pop( aThumbnail ); - aData = NULL; - } - - //fetch real size of TN - column = 2; - aThumbnailRealSize.iWidth = stmt->ColumnInt( column++ ); - aThumbnailRealSize.iHeight = stmt->ColumnInt( column ); - } - } - else - { - TN_DEBUG1( "CThumbnailStore::FetchThumbnailL() -- thumbnail NOT found" ); - OstTrace0( TRACE_NORMAL, DUP4_CTHUMBNAILSTORE_FETCHTHUMBNAILL, "CThumbnailStore::FetchThumbnailL - thumbnail NOT found" ); - } - - CleanupStack::PopAndDestroy( stmt ); - CleanupStack::PopAndDestroy( path ); - - User::LeaveIfError( found ); - } - -// ----------------------------------------------------------------------------- -// Delete thumbnails for given object file by Path -// ----------------------------------------------------------------------------- -// -void CThumbnailStore::DeleteThumbnailsL( const TDesC& aPath, TBool aForce, - TBool aTransaction ) - { - TN_DEBUG2( "CThumbnailStore::DeleteThumbnailsL(%S)", &aPath ); - OstTraceExt1( TRACE_NORMAL, CTHUMBNAILSTORE_DELETETHUMBNAILSL, "CThumbnailStore::DeleteThumbnailsL;aPath=%S", aPath ); - - if(iReadOnly) - { - TN_DEBUG1( "CThumbnailStore::DeleteThumbnailsL() read only, skip..." ); - return; - } - -#ifdef _DEBUG - TTime aStart, aStop; - aStart.UniversalTime(); -#endif - - User::LeaveIfError( CheckDbState() ); - - TInt paramIndex = 0; - TInt paramIndex1 = 0; - TInt paramIndex2 = 0; - TInt rowStatus = 0; - TInt column = 0; - TInt64 rowid = 0; - TInt count = 0; - - HBufC* path = aPath.AllocLC(); - TPtr ptr(path->Des()); - StripDriveLetterL( ptr ); - - RThumbnailTransaction transaction( iDatabase ); - if (aTransaction) - { - CleanupClosePushL( transaction ); - transaction.BeginL(); - } - - 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; - RSqlStatement* stmt_infodata = NULL; - - stmt = &iStmt_KTempThumbnailSqlSelectRowIDInfoByPath; - CleanupStack::PushL(TCleanupItem(ResetStatement, stmt)); - stmt_info = &iStmt_KTempThumbnailSqlDeleteInfoByPath; - CleanupStack::PushL(TCleanupItem(ResetStatement, stmt_info)); - stmt_infodata = &iStmt_KTempThumbnailSqlDeleteInfoDataByPath; - CleanupStack::PushL(TCleanupItem(ResetStatement, stmt_infodata)); - - paramIndex = stmt->ParameterIndex( KThumbnailSqlParamPath ); - User::LeaveIfError( paramIndex ); - User::LeaveIfError( stmt->BindText( paramIndex, *path )); - - rowStatus = stmt->Next(); - - while(rowStatus == KSqlAtRow) - { - rowid = stmt->ColumnInt64( column ); - paramIndex1 = stmt_info->ParameterIndex( KThumbnailSqlParamRowID ); - User::LeaveIfError( paramIndex1 ); - User::LeaveIfError( stmt_info->BindInt64( paramIndex1, rowid )); - - TInt err = stmt_info->Exec(); - stmt_info->Reset(); - User::LeaveIfError( err ); - - paramIndex2 = stmt_infodata->ParameterIndex( KThumbnailSqlParamRowID ); - User::LeaveIfError( paramIndex2 ); - User::LeaveIfError( stmt_infodata->BindInt64( paramIndex2, rowid )); - - err = stmt_infodata->Exec(); - stmt_infodata->Reset(); - 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(); - - paramIndex = stmt->ParameterIndex( KThumbnailSqlParamPath ); - User::LeaveIfError( paramIndex ); - User::LeaveIfError( stmt->BindText( paramIndex, *path )); - - rowStatus = stmt->Next(); - } - - CleanupStack::PopAndDestroy( stmt_infodata ); - CleanupStack::PopAndDestroy( stmt_info ); - CleanupStack::PopAndDestroy( stmt ); - - // if forcing instant delete - if (aForce) - { - //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)); - stmt_info = &iStmt_KThumbnailSqlDeleteInfoByPath; - CleanupStack::PushL(TCleanupItem(ResetStatement, stmt_info)); - stmt_infodata = &iStmt_KThumbnailSqlDeleteInfoDataByPath; - CleanupStack::PushL(TCleanupItem(ResetStatement, stmt_infodata)); - - paramIndex = stmt->ParameterIndex( KThumbnailSqlParamPath ); - User::LeaveIfError( paramIndex ); - User::LeaveIfError( stmt->BindText( paramIndex, *path )); - - rowStatus = stmt->Next(); - - while(rowStatus == KSqlAtRow) - { - rowid = stmt->ColumnInt64( column ); - paramIndex1 = stmt_info->ParameterIndex( KThumbnailSqlParamRowID ); - User::LeaveIfError( paramIndex1 ); - User::LeaveIfError( stmt_info->BindInt64( paramIndex1, rowid )); - - TInt err = stmt_info->Exec(); - stmt_info->Reset(); - User::LeaveIfError( err ); - - paramIndex2 = stmt_infodata->ParameterIndex( KThumbnailSqlParamRowID ); - User::LeaveIfError( paramIndex2 ); - User::LeaveIfError( stmt_infodata->BindInt64( paramIndex2, rowid )); - - err = stmt_infodata->Exec(); - stmt_infodata->Reset(); - 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(); - } - - CleanupStack::PopAndDestroy( stmt_infodata ); - CleanupStack::PopAndDestroy( stmt_info ); - CleanupStack::PopAndDestroy( stmt ); - - //remove delete mark - User::LeaveIfError( iDatabase.Exec( KThumbnailSqlDeleteFromDeleted ) ); - } - 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)); - - paramIndex = stmt->ParameterIndex( KThumbnailSqlParamPath ); - User::LeaveIfError( paramIndex ); - User::LeaveIfError( stmt->BindText( paramIndex, *path )); - - rowStatus = stmt->Next(); - - CleanupStack::PopAndDestroy( stmt ); - - // there were matching rows in main table - 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; - CleanupStack::PushL(TCleanupItem(ResetStatement, stmt)); - - paramIndex = stmt->ParameterIndex( KThumbnailSqlParamPath ); - User::LeaveIfError( paramIndex ); - User::LeaveIfError( stmt->BindText( paramIndex, *path )); - - count = stmt->Exec(); - - CleanupStack::PopAndDestroy( stmt ); - } - else - { - TN_DEBUG1( "CThumbnailStore::DeleteThumbnailByPathL() -- no thumbs in MAIN" ); - OstTrace0( TRACE_NORMAL, DUP7_CTHUMBNAILSTORE_DELETETHUMBNAILSL, "CThumbnailStore::DeleteThumbnailsL - no thumbs in MAIN" ); - } - } - - if (aTransaction) - { - transaction.CommitL(); - CleanupStack::PopAndDestroy( &transaction ); - } - -#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(); - } - - CleanupStack::PopAndDestroy( path ); - } - -// ----------------------------------------------------------------------------- -// Rename thumbnails -// ----------------------------------------------------------------------------- -// -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..." ); - return; - } - -#ifdef _DEBUG - TTime aStart, aStop; - aStart.UniversalTime(); -#endif - - User::LeaveIfError( CheckDbState() ); - - TInt paramIndex = 0; - - HBufC* path = aCurrentPath.AllocLC(); - TPtr ptr(path->Des()); - StripDriveLetterL( ptr ); - - HBufC* newPath = aNewPath.AllocLC(); - TPtr ptr2(newPath->Des()); - StripDriveLetterL( ptr2 ); - - RThumbnailTransaction transaction( iDatabase ); - CleanupClosePushL( transaction ); - transaction.BeginL(); - - TN_DEBUG1( "CThumbnailStore::RenameThumbnailsL() -- TEMP TABLE" ); - OstTrace0( TRACE_NORMAL, DUP1_CTHUMBNAILSTORE_RENAMETHUMBNAILSL, "CThumbnailStore::RenameThumbnailsL - TEMP TABLE" ); - - RSqlStatement* stmt = NULL; - stmt = &iStmt_KThumbnailTempRename; - CleanupStack::PushL(TCleanupItem(ResetStatement, stmt)); - - paramIndex = stmt->ParameterIndex( KThumbnailSqlParamPath ); - User::LeaveIfError( paramIndex ); - User::LeaveIfError( stmt->BindText( paramIndex, *path )); - - paramIndex = stmt->ParameterIndex( KThumbnailSqlParamNewPath ); - User::LeaveIfError( paramIndex ); - User::LeaveIfError( stmt->BindText( paramIndex, *newPath )); - - 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; - CleanupStack::PushL(TCleanupItem(ResetStatement, stmt)); - - paramIndex = stmt->ParameterIndex( KThumbnailSqlParamPath ); - User::LeaveIfError( paramIndex ); - User::LeaveIfError( stmt->BindText( paramIndex, *path )); - - paramIndex = stmt->ParameterIndex( KThumbnailSqlParamNewPath ); - User::LeaveIfError( paramIndex ); - User::LeaveIfError( stmt->BindText( paramIndex, *newPath )); - - User::LeaveIfError( stmt->Exec() ); - - CleanupStack::PopAndDestroy( stmt ); - - // if thumb was for some reason already marked deleted, clean from deleted - User::LeaveIfError( iDatabase.Exec( KThumbnailSqlDeleteFromDeleted ) ); - - transaction.CommitL(); - CleanupStack::PopAndDestroy( &transaction ); - - CleanupStack::PopAndDestroy( newPath ); - CleanupStack::PopAndDestroy( path ); - -#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 - } - -// --------------------------------------------------------------------------- -// CThumbnailStore::PersistentSizes() -// --------------------------------------------------------------------------- -// -void CThumbnailStore::SetPersistentSizes(const RArray < TThumbnailPersistentSize > &aSizes) - { - iPersistentSizes = aSizes; - } - -// --------------------------------------------------------------------------- -// CThumbnailStore::FlushCacheTable() -// --------------------------------------------------------------------------- -// -void CThumbnailStore::FlushCacheTable( TBool aForce ) - { - TN_DEBUG1("CThumbnailStore::FlushCacheTable() in"); - OstTrace0( TRACE_NORMAL, CTHUMBNAILSTORE_FLUSHCACHETABLE, "CThumbnailStore::FlushCacheTable - in" ); - - StopAutoFlush(); - - if(iReadOnly) - { - TN_DEBUG1( "CThumbnailStore::FlushCacheTable() read only, skip..." ); - return; - } - - if(iBatchItemCount <= 0 || CheckDbState() != KErrNone) - { - // cache empty or db unusable - TN_DEBUG1( "CThumbnailStore::FlushCacheTable() error "); - OstTrace0( TRACE_NORMAL, DUP1_CTHUMBNAILSTORE_FLUSHCACHETABLE, "CThumbnailStore::FlushCacheTable - error" ); - return; - } - - // longer flush allowed if MTP sync on - TInt MPXHarvesting(0); - TInt ret = RProperty::Get(KTAGDPSNotification, KMPXHarvesting, MPXHarvesting); - 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 - TReal32 aMaxFlushDelay(KMaxFlushDelay); - TReal32 aPreviousFlushDelay(iPreviousFlushDelay); - TReal32 aBatchFlushItemCount(iBatchFlushItemCount); - - if(MPXHarvesting) - { - //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; - } - - //1st item in batch - 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 ) - { - TReal32 aNewBatchFlushItemCount = aMaxFlushDelay / aPreviousFlushDelay * aBatchFlushItemCount; - 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 ) - { - iBatchFlushItemCount = KMInBatchItems; - } - else if( iBatchFlushItemCount > KMaxBatchItems ) - { - iBatchFlushItemCount = KMaxBatchItems; - } - } - else - { - //cannot calculate, init values set to min - iBatchFlushItemCount = KMInBatchItems; - } - } - - TN_DEBUG3("CThumbnailStore::FlushCacheTable() iBatchFlushItemCount = %d, iBatchItemCount = %d", iBatchFlushItemCount, iBatchItemCount); - OstTrace0( TRACE_NORMAL, DUP10_CTHUMBNAILSTORE_FLUSHCACHETABLE, "CThumbnailStore::FlushCacheTable" ); - - if( iBatchItemCount < iBatchFlushItemCount && !aForce) - { - //some items in cache - StartAutoFlush(); - return; - } - - iStartFlush.UniversalTime(); - - // 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 - - TInt err_tempdata = iDatabase.Exec( KThumbnailMoveFromTempDataToMainTable ); - -#ifdef _DEBUG - if(err_tempdata < 0) - { - 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 - if(err_tempinfo == KSqlErrCorrupt || err_tempinfo == KErrCorrupt || - 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)); - } - - iStopFlush.UniversalTime(); - 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" ); - } - -// ----------------------------------------------------------------------------- -// StartAutoFlush() -// ----------------------------------------------------------------------------- -// -void CThumbnailStore::StartAutoFlush() - { - TN_DEBUG1( "CThumbnailStore::StartAutoFlush()" ); - OstTrace0( TRACE_NORMAL, CTHUMBNAILSTORE_STARTAUTOFLUSH, "CThumbnailStore::StartAutoFlush" ); - if(iReadOnly) - { - TN_DEBUG1( "CThumbnailStore::StartAutoFlush() read only, skip..." ); - return; - } - - TInt err = KErrNone; - - if( iAutoFlushTimer ) - { - iAutoFlushTimer->Cancel(); - } - else - { - TRAP(err, iAutoFlushTimer = CPeriodic::NewL(CActive::EPriorityIdle) ); - } - - 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 - { - iAutoFlushTimer->Start( KAutoFlushTimeout * 1000000, KAutoFlushTimeout * 1000000, - TCallBack(AutoFlushTimerCallBack, this)); - } - } - -// ----------------------------------------------------------------------------- -// StopAutoFlush() -// ----------------------------------------------------------------------------- -// -void CThumbnailStore::StopAutoFlush() - { - TN_DEBUG1( "CThumbnailStore::StopAutoFlush()" ); - OstTrace0( TRACE_NORMAL, CTHUMBNAILSTORE_STOPAUTOFLUSH, "CThumbnailStore::StopAutoFlush" ); - if( iAutoFlushTimer ) - { - iAutoFlushTimer->Cancel(); - } - } - -// ----------------------------------------------------------------------------- -// StartMaintenance() -// ----------------------------------------------------------------------------- -// -void CThumbnailStore::StartMaintenance() - { - TN_DEBUG1( "CThumbnailStore::StartMaintenance()"); - OstTrace0( TRACE_NORMAL, CTHUMBNAILSTORE_STARTMAINTENANCE, "CThumbnailStore::StartMaintenance" ); - TInt err = KErrNone; - - if( iMaintenanceTimer && iMaintenanceTimer->IsActive() ) - { - return; - } - else if (!iMaintenanceTimer) - { - TRAP(err, iMaintenanceTimer = CPeriodic::NewL(CActive::EPriorityIdle) ); - } - - 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 - { - iMaintenanceTimer->Start( KStoreMaintenancePeriodic, KStoreMaintenancePeriodic, - TCallBack(MaintenanceTimerCallBack, this)); - } - } - -// --------------------------------------------------------------------------- -// CThumbnailStore::AutoFlushTimerCallBack() -// --------------------------------------------------------------------------- -// -TInt CThumbnailStore::AutoFlushTimerCallBack(TAny* aAny) - { - TN_DEBUG1( "CThumbnailStore::AutoFlushTimerCallBack()"); - OstTrace0( TRACE_NORMAL, CTHUMBNAILSTORE_AUTOFLUSHTIMERCALLBACK, "CThumbnailStore::AutoFlushTimerCallBack" ); - CThumbnailStore* self = static_cast( aAny ); - - self->FlushCacheTable(ETrue); - - return KErrNone; // Return value ignored by CPeriodic - } - -// --------------------------------------------------------------------------- -// CThumbnailStore::MaintenanceTimerCallBack() -// --------------------------------------------------------------------------- -// -TInt CThumbnailStore::MaintenanceTimerCallBack(TAny* aAny) - { - CThumbnailStore* self = static_cast( aAny ); - - self->iMaintenanceTimer->Cancel(); - - TInt MPXHarvesting(0); - TInt DaemonProcessing(0); - TInt ret = RProperty::Get(KTAGDPSNotification, KMPXHarvesting, MPXHarvesting); - 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; - - // delete marked rows from database - TRAPD( err, deleteCount = self->DeleteMarkedL() ); - 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; - } - - // no more marked rows - 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; - } - } - - // file existence check - 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; - - TRAPD( err, finished = self->FileExistenceCheckL() ); - 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; - } - - // all files checked. - 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; - } - } - - // next round - 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(); - } - } - 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 - } - -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) - { - TN_DEBUG1( "CThumbnailStore::CheckModifiedByPathL() read only, skip..." ); - modifiedChanged = EFalse; - return ETrue; - } - - User::LeaveIfError( CheckDbState() ); - - HBufC* path = aPath.AllocLC(); - TPtr ptr(path->Des()); - StripDriveLetterL( ptr ); - - TBool ret(EFalse); - - modifiedChanged = EFalse; - - TInt column = 0; - - RSqlStatement* stmt = NULL; - stmt = &iStmt_KThumbnailSelectTempModifiedByPath; - CleanupStack::PushL(TCleanupItem(ResetStatement, stmt)); - - TInt paramIndex = stmt->ParameterIndex( KThumbnailSqlParamPath ); - User::LeaveIfError( paramIndex ); - User::LeaveIfError( stmt->BindText( paramIndex, *path )); - - TInt rowStatus = stmt->Next(); - - TBool checkMain = EFalse; - - TN_DEBUG1( "CThumbnailStore::CheckModifiedL() -- temp" ); - OstTrace0( TRACE_NORMAL, DUP1_CTHUMBNAILSTORE_CHECKMODIFIEDBYPATHL, "CThumbnailStore::CheckModifiedByPathL -- temp" ); - - while(rowStatus == KSqlAtRow || !checkMain) - { - if(rowStatus == KSqlAtRow) - { - ret = ETrue; - 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(); - } - - //switch to main table if modified not found from temp - 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; - - CleanupStack::PopAndDestroy( stmt ); - stmt = &iStmt_KThumbnailSelectModifiedByPath; - CleanupStack::PushL(TCleanupItem(ResetStatement, stmt)); - - paramIndex = stmt->ParameterIndex( KThumbnailSqlParamPath ); - User::LeaveIfError( paramIndex ); - User::LeaveIfError( stmt->BindText( paramIndex, *path )); - - rowStatus = stmt->Next(); - } - } - - CleanupStack::PopAndDestroy( stmt ); - CleanupStack::PopAndDestroy( path ); - - return ret; -} - - -// ----------------------------------------------------------------------------- -// IsReadOnly() -// ----------------------------------------------------------------------------- -// -TBool CThumbnailStore::IsReadOnly() - { - return iReadOnly; - } - -// ----------------------------------------------------------------------------- -// PrepareBlacklistedItemsForRetryL() -// ----------------------------------------------------------------------------- -// -void CThumbnailStore::PrepareBlacklistedItemsForRetryL() - { - TN_DEBUG1( "CThumbnailStore::PrepareBlacklistedItemsForRetry()" ); - OstTrace0( TRACE_NORMAL, CTHUMBNAILSTORE_PREPAREBLACKLISTEDITEMSFORRETRYL, "CThumbnailStore::PrepareBlacklistedItemsForRetryL" ); - - RSqlStatement stmt; - CleanupClosePushL( stmt ); - - User::LeaveIfError( stmt.Prepare( iDatabase, KThumbnailTouchBlacklistedRows )); - - TInt paramIndex = stmt.ParameterIndex( KThumbnailSqlParamFlag ); - User::LeaveIfError( paramIndex ); - User::LeaveIfError( stmt.BindInt( paramIndex, KThumbnailDbFlagBlacklisted )); - 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 ); - } - -// ----------------------------------------------------------------------------- -// DeleteMarkedL() -// ----------------------------------------------------------------------------- -// -TInt CThumbnailStore::DeleteMarkedL() - { - TN_DEBUG1( "CThumbnailStore::DeleteMarkedL()" ); - OstTrace0( TRACE_NORMAL, CTHUMBNAILSTORE_DELETEMARKEDL, "CThumbnailStore::DeleteMarkedL" ); - if(iReadOnly) - { - TN_DEBUG1( "CThumbnailStore::DeleteMarkedL() read only, skip..." ); - return KErrAccessDenied; - } - -#ifdef _DEBUG - TTime aStart, aStop; - aStart.UniversalTime(); -#endif - - User::LeaveIfError( CheckDbState() ); - - TInt paramIndex = 0; - TInt paramIndex1 = 0; - TInt paramIndex2 = 0; - TInt rowStatus = 0; - TInt column = 0; - TInt64 rowid = 0; - TInt deleteCount = 0; - - RThumbnailTransaction transaction( iDatabase ); - CleanupClosePushL( transaction ); - transaction.BeginL(); - - RSqlStatement* stmt = NULL; - RSqlStatement* stmt_info = NULL; - RSqlStatement* stmt_infodata = NULL; - - stmt = &iStmt_KThumbnailSqlSelectMarked; - CleanupStack::PushL(TCleanupItem(ResetStatement, stmt)); - stmt_info = &iStmt_KThumbnailSqlDeleteInfoByRowID; - CleanupStack::PushL(TCleanupItem(ResetStatement, stmt_info)); - stmt_infodata = &iStmt_KThumbnailSqlDeleteInfoDataByRowID; - CleanupStack::PushL(TCleanupItem(ResetStatement, stmt_infodata)); - - // select marked rows - paramIndex = stmt->ParameterIndex( KThumbnailSqlParamLimit ); - User::LeaveIfError( paramIndex ); - User::LeaveIfError( stmt->BindInt( paramIndex, KStoreMaintenanceDeleteLimit )); - - rowStatus = stmt->Next(); - - while(rowStatus == KSqlAtRow) - { - rowid = stmt->ColumnInt64( column ); - paramIndex1 = stmt_info->ParameterIndex( KThumbnailSqlParamRowID ); - User::LeaveIfError( paramIndex1 ); - User::LeaveIfError( stmt_info->BindInt64( paramIndex1, rowid )); - - TInt err = stmt_info->Exec(); - stmt_info->Reset(); - User::LeaveIfError( err ); - - paramIndex2 = stmt_infodata->ParameterIndex( KThumbnailSqlParamRowID ); - User::LeaveIfError( paramIndex2 ); - User::LeaveIfError( stmt_infodata->BindInt64( paramIndex2, rowid )); - - err = stmt_infodata->Exec(); - stmt_infodata->Reset(); - User::LeaveIfError( err ); - deleteCount++; - - TN_DEBUG1( "CThumbnailStore::DeleteMarkedL() - thumbnail deleted" ); - OstTrace0( TRACE_NORMAL, DUP1_CTHUMBNAILSTORE_DELETEMARKEDL, "CThumbnailStore::DeleteMarkedL - thumbnail deleted" ); - - rowStatus = stmt->Next(); - } - - CleanupStack::PopAndDestroy( stmt_infodata ); - CleanupStack::PopAndDestroy( stmt_info ); - CleanupStack::PopAndDestroy( stmt ); - - // remove successfully deleted paths from Deleted table - if (deleteCount > 0) - { - User::LeaveIfError( iDatabase.Exec( KThumbnailSqlDeleteFromDeleted ) ); - } - - transaction.CommitL(); - CleanupStack::PopAndDestroy( &transaction ); - -#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; - } - -// ----------------------------------------------------------------------------- -// FileExistenceCheckL() -// ----------------------------------------------------------------------------- -// -TInt CThumbnailStore::FileExistenceCheckL() - { - TN_DEBUG1( "CThumbnailStore::FileExistenceCheckL()" ); - OstTrace0( TRACE_NORMAL, CTHUMBNAILSTORE_FILEEXISTENCECHECKL, "CThumbnailStore::FileExistenceCheckL" ); - if(iReadOnly) - { - TN_DEBUG1( "CThumbnailStore::FileExistenceCheckL() read only, skip..." ); - return ETrue; - } - -#ifdef _DEBUG - TTime aStart, aStop; - aStart.UniversalTime(); -#endif - - User::LeaveIfError( CheckDbState() ); - - TInt paramIndex = 0; - TInt rowStatus = 0; - TInt column = 0; - TInt64 rowid = 0; - TFileName path; - TFileName prevPath; - TFileName full; - TInt count = 0; - - TBool finished = EFalse; - - RThumbnailTransaction transaction( iDatabase ); - CleanupClosePushL( transaction ); - transaction.BeginL(); - - // get rows - RSqlStatement* stmt = NULL; - stmt = &iStmt_KThumbnailSelectAllPaths; - CleanupStack::PushL(TCleanupItem(ResetStatement, stmt)); - - paramIndex = stmt->ParameterIndex( KThumbnailSqlParamRowID ); - User::LeaveIfError( paramIndex ); - User::LeaveIfError( stmt->BindInt64( paramIndex, iLastCheckedRowID )); - - paramIndex = stmt->ParameterIndex( KThumbnailSqlParamLimit ); - User::LeaveIfError( paramIndex ); - User::LeaveIfError( stmt->BindInt( paramIndex, KStoreMaintenanceExistLimit )); - - rowStatus = stmt->Next(); - - while(rowStatus == KSqlAtRow) - { - column = 0; - path.Zero(); - - rowid = stmt->ColumnInt64( column++ ); - stmt->ColumnText( column, path ); - - full.Zero(); - full.Append(iDriveChar); - full.Append(KDrv); - full.Append(path); - - // if path matches previous one, skip - if (path.CompareF(prevPath) != 0) - { - // file doesn't exist anymore, mark thumbs deleted - if(!BaflUtils::FileExists( iFs, full )) - { - TN_DEBUG2( "CThumbnailStore::FileExistenceCheckL(%S) - not found", &full ); - DeleteThumbnailsL(path, EFalse, EFalse); - } - - prevPath.Zero(); - prevPath.Append(path); - } - - iLastCheckedRowID = rowid; - count++; - - // get next - rowStatus = stmt->Next(); - } - - if (count < KStoreMaintenanceExistLimit) - { - // all rows checked - finished = ETrue; - } - - CleanupStack::PopAndDestroy( stmt ); - - transaction.CommitL(); - CleanupStack::PopAndDestroy( &transaction ); - -#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; - } - -// ----------------------------------------------------------------------------- -// StripDriveLetter -// ----------------------------------------------------------------------------- -// -void CThumbnailStore::StripDriveLetterL( TDes& aPath ) - { - TInt pos = aPath.Find(KDrv); - TInt pos2 = aPath.Find(KBackSlash); - - // if URI contains drive letter - if ( pos == 1 ) - { - // normal URI - if ( pos2 == 2 ) - { - aPath.Delete(0,pos+1); - } - // virtual URI - else - { - aPath.Replace(0,2,KBackSlash); - } - } - } - -// ----------------------------------------------------------------------------- -// CheckDbState -// ----------------------------------------------------------------------------- -// -TInt CThumbnailStore::CheckDbState() - { - 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; - } - else - { - return KErrNone; - } - } - -void CThumbnailStore::HandleDiskSpaceNotificationL( TBool aDiskFull ) - { - TN_DEBUG2( "CThumbnailStore::HandleDiskSpaceNotificationL() aDiskFull = %d", aDiskFull ); - OstTrace1( TRACE_NORMAL, CTHUMBNAILSTORE_HANDLEDISKSPACENOTIFICATIONL, "CThumbnailStore::HandleDiskSpaceNotificationL;aDiskFull=%u", aDiskFull ); - iDiskFull = aDiskFull; - } - -#ifdef _DEBUG -void CThumbnailStore::HandleDiskSpaceError(TInt aError ) -#else -void CThumbnailStore::HandleDiskSpaceError(TInt /*aError*/ ) -#endif - { - TN_DEBUG2( "CThumbnailStore::HandleDiskSpaceError() aError = %d", aError ); -#ifdef _DEBUG - OstTrace1( TRACE_NORMAL, CTHUMBNAILSTORE_HANDLEDISKSPACEERROR, "CThumbnailStore::HandleDiskSpaceError;aError=%d", aError ); -#endif - } - -TBool CThumbnailStore::IsDiskFull() - { - if(iReadOnly) - { - TN_DEBUG1( "CThumbnailStore::IsDiskFull() read only, skip..." ); - return EFalse; - } - return iDiskFull; - } - -// ----------------------------------------------------------------------------- -// ActivityDetected() -// ----------------------------------------------------------------------------- -// -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..." ); - return; - } - - if( aActive ) - { - iIdle = EFalse; - } - else - { - TInt MPXHarvesting(0); - TInt DaemonProcessing(0); - - TInt ret = RProperty::Get(KTAGDPSNotification, KMPXHarvesting, MPXHarvesting); - 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; - } - - ret = RProperty::Get(KTAGDPSNotification, KDaemonProcessing, DaemonProcessing); - 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(); - } - } - - -// ----------------------------------------------------------------------------- -// CThumbnailStoreDiskSpaceNotifierAO class -// ----------------------------------------------------------------------------- -// -CThumbnailStoreDiskSpaceNotifierAO* CThumbnailStoreDiskSpaceNotifierAO::NewL( - MThumbnailStoreDiskSpaceNotifierObserver& aObserver, TInt64 aThreshold, const TDesC& aFilename) - { - CThumbnailStoreDiskSpaceNotifierAO* self = - CThumbnailStoreDiskSpaceNotifierAO::NewLC( aObserver, aThreshold, aFilename); - CleanupStack::Pop( self ); - return self; - } - -CThumbnailStoreDiskSpaceNotifierAO* CThumbnailStoreDiskSpaceNotifierAO::NewLC( - MThumbnailStoreDiskSpaceNotifierObserver& aObserver, TInt64 aThreshold, const TDesC& aFilename) - { - TDriveNumber driveNumber = GetDriveNumberL( aFilename ); - - CThumbnailStoreDiskSpaceNotifierAO* self = - new ( ELeave ) CThumbnailStoreDiskSpaceNotifierAO( aObserver, aThreshold, driveNumber ); - CleanupStack::PushL( self ); - self->ConstructL(); - return self; - } - -TDriveNumber CThumbnailStoreDiskSpaceNotifierAO::GetDriveNumberL( const TDesC& aFilename ) - { - TN_DEBUG1( "CThumbnailStoreDiskSpaceNotifierAO::GetDriveNumberL()"); - OstTrace0( TRACE_NORMAL, CTHUMBNAILSTOREDISKSPACENOTIFIERAO_GETDRIVENUMBERL, "CThumbnailStoreDiskSpaceNotifierAO::GetDriveNumberL" ); - TLex driveParser( aFilename ); - - TChar driveChar = driveParser.Get(); - - if( 0 == driveChar || TChar( ':' ) != driveParser.Peek() ) - { - TN_DEBUG1( "CThumbnailStoreDiskSpaceNotifierAO::GetDriveNumberL() KErrArgument"); - OstTrace0( TRACE_NORMAL, DUP1_CTHUMBNAILSTOREDISKSPACENOTIFIERAO_GETDRIVENUMBERL, "CThumbnailStoreDiskSpaceNotifierAO::GetDriveNumberL - KErrArgument" ); - User::Leave( KErrArgument ); - } - - TInt driveNumber; - - RFs::CharToDrive( driveChar, driveNumber ); - - return (TDriveNumber)driveNumber; - } - -CThumbnailStoreDiskSpaceNotifierAO::~CThumbnailStoreDiskSpaceNotifierAO() - { - TN_DEBUG1( "CThumbnailStoreDiskSpaceNotifierAO::~CThumbnailStoreDiskSpaceNotifierAO()"); - OstTrace0( TRACE_NORMAL, CTHUMBNAILSTOREDISKSPACENOTIFIERAO_CTHUMBNAILSTOREDISKSPACENOTIFIERAO, "CThumbnailStoreDiskSpaceNotifierAO::~CThumbnailStoreDiskSpaceNotifierAO" ); - Cancel(); - - iFileServerSession.Close(); - } - -void CThumbnailStoreDiskSpaceNotifierAO::RunL() - { - TN_DEBUG1( "CThumbnailStoreDiskSpaceNotifierAO::RunL()"); - OstTrace0( TRACE_NORMAL, CTHUMBNAILSTOREDISKSPACENOTIFIERAO_RUNL, "CThumbnailStoreDiskSpaceNotifierAO::RunL" ); - TVolumeInfo volumeInfo; - - if ( iState == CThumbnailStoreDiskSpaceNotifierAO::ENormal ) - { - TInt status = iStatus.Int(); - - TInt ret(KErrNone); - - switch( status ) - { - case KErrNone: - ret = iFileServerSession.Volume( volumeInfo, iDrive ); - - if(!ret) - { - // Check if free space is less than threshold level - 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; - iIterationCount = 0; - SetActive(); - TRequestStatus* status = &iStatus; - User::RequestComplete( status, KErrNone ); - return; - } - else - { - TN_DEBUG1( "CThumbnailStoreDiskSpaceNotifierAO::RunL() NOT FULL"); - OstTrace0( TRACE_NORMAL, DUP2_CTHUMBNAILSTOREDISKSPACENOTIFIERAO_RUNL, "CThumbnailStoreDiskSpaceNotifierAO::RunL - NOT FULL" ); - iDiskFull = EFalse; - iObserver.HandleDiskSpaceNotificationL( iDiskFull ); - } - } - 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 ); - } - - StartNotifier(); - break; - - case KErrArgument: - TN_DEBUG1( "CThumbnailStoreDiskSpaceNotifierAO::RunL() KErrArgument"); - OstTrace0( TRACE_NORMAL, DUP4_CTHUMBNAILSTOREDISKSPACENOTIFIERAO_RUNL, "CThumbnailStoreDiskSpaceNotifierAO::RunL - KErrArgument" ); - User::Leave( status ); - break; - default: - break; - } - } - else if ( iState == CThumbnailStoreDiskSpaceNotifierAO::EIterate ) - { - const TInt KMaxIterations = 10; - - User::LeaveIfError( iFileServerSession.Volume( volumeInfo, iDrive ) ); - if ( volumeInfo.iFree < iThreshold ) - { - iObserver.HandleDiskSpaceNotificationL( iDiskFull ); - ++iIterationCount; - if ( iIterationCount < KMaxIterations ) - { - SetActive(); - TRequestStatus* status = &iStatus; - User::RequestComplete( status, KErrNone ); - return; - } - else - { - User::LeaveIfError( iFileServerSession.Volume( volumeInfo, iDrive ) ); - if ( volumeInfo.iFree >= iThreshold ) - { - TN_DEBUG1( "CThumbnailStoreDiskSpaceNotifierAO::RunL() NOT FULL"); - OstTrace0( TRACE_NORMAL, DUP5_CTHUMBNAILSTOREDISKSPACENOTIFIERAO_RUNL, "CThumbnailStoreDiskSpaceNotifierAO::RunL - NOT FULL" ); - iDiskFull = EFalse; - } - } - } - else - { - TN_DEBUG1( "CThumbnailStoreDiskSpaceNotifierAO::RunL() NOT FULL"); - OstTrace0( TRACE_NORMAL, DUP6_CTHUMBNAILSTOREDISKSPACENOTIFIERAO_RUNL, "CThumbnailStoreDiskSpaceNotifierAO::RunL - NOT FULL" ); - iDiskFull = EFalse; - } - iState = ENormal; - iIterationCount = 0; - StartNotifier(); - } - else - { - TN_DEBUG1( "CThumbnailStoreDiskSpaceNotifierAO::RunL() KErrGeneral"); - OstTrace0( TRACE_NORMAL, DUP7_CTHUMBNAILSTOREDISKSPACENOTIFIERAO_RUNL, "CThumbnailStoreDiskSpaceNotifierAO::RunL - KErrGeneral" ); - User::Leave( KErrGeneral ); - } - } - -TInt CThumbnailStoreDiskSpaceNotifierAO::RunError(TInt aError) - { - TN_DEBUG2( "CThumbnailStoreDiskSpaceNotifierAO::RunError() %d", aError); - OstTrace1( TRACE_NORMAL, CTHUMBNAILSTOREDISKSPACENOTIFIERAO_RUNERROR, "CThumbnailStoreDiskSpaceNotifierAO::RunError;aError=%d", aError ); - - iObserver.HandleDiskSpaceError( aError ); - - return KErrNone; - } - -void CThumbnailStoreDiskSpaceNotifierAO::DoCancel() - { - TN_DEBUG1( "CThumbnailStoreDiskSpaceNotifierAO::DoCancel()"); - OstTrace0( TRACE_NORMAL, CTHUMBNAILSTOREDISKSPACENOTIFIERAO_DOCANCEL, "CThumbnailStoreDiskSpaceNotifierAO::DoCancel" ); - - if( IsActive() ) - { - iFileServerSession.NotifyDiskSpaceCancel(); - } - } - -CThumbnailStoreDiskSpaceNotifierAO::CThumbnailStoreDiskSpaceNotifierAO( - MThumbnailStoreDiskSpaceNotifierObserver& aObserver, TInt64 aThreshold, const TDriveNumber aDrive) - : CActive( CActive::EPriorityStandard ), - 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 ) ); - - TVolumeInfo volumeInfo; - TInt ret = iFileServerSession.Volume( volumeInfo, iDrive ); - - if( !ret ) - { - 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 ); - } - - iObserver.HandleDiskSpaceNotificationL( iDiskFull ); - - StartNotifier(); - } - -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(); - } - -TBool CThumbnailStoreDiskSpaceNotifierAO::DiskFull() const - { - return iDiskFull; - } - -// End of file