FCL/sf/mw/imghandling: comparison imagehandlingutilities/thumbnailmanager/thumbnailserver/src/thumbnailstore.cpp

equal deleted inserted replaced

-:7197e789b953
+:ffa62e555b02
 const TInt KMinor = 2;
 const TInt KStoreUnrecoverableErr = KErrCorrupt;
 // Database path without drive letter
-_LIT( KThumbnailDatabaseName, ":[102830AB]thumbnail_v3.db" );
+_LIT( KThumbnailDatabaseName, ":[102830AB]thumbnail_v5.db" );
 _LIT( KDrv, ":");
 // Allow access to database only for the server process
 const TSecurityPolicy KThumbnailDatabaseSecurityPolicy( TSecureId(
 // ---------------------------------------------------------------------------
 // RThumbnailTransaction::BeginL()
 // ---------------------------------------------------------------------------
 //
 void RThumbnailTransaction::BeginL()
 {
+if (iDatabase.InTransaction())
+{
+TN_DEBUG1( "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;
 }
 // RThumbnailTransaction::Close()
 // ---------------------------------------------------------------------------
 //
 void RThumbnailTransaction::Close()
 {
-if ( iState != EClosed )
+if ( iState != EClosed && iState != EOldOpen )
 {
 Rollback();
 }
 }
 // RThumbnailTransaction::CommitL()
 // ---------------------------------------------------------------------------
 //
 void RThumbnailTransaction::CommitL()
 {
-TInt ret = iDatabase.Exec( KThumbnailCommitTransaction );
+if ( iState != EOldOpen )
+{
+TInt ret = iDatabase.Exec( KThumbnailCommitTransaction );
 #ifdef _DEBUG
 TPtrC errorMsg = iDatabase.LastErrorMessage();
 TN_DEBUG3( "RThumbnailTransaction::CommitL() lastError %S, ret = %d" , &errorMsg, ret);
 #endif
 User::LeaveIfError( ret );
+}
 iState = EClosed;
 }
 // ---------------------------------------------------------------------------
 // RThumbnailTransaction::Rollback()
 // ---------------------------------------------------------------------------
 //
 TInt RThumbnailTransaction::Rollback()
 {
-const TInt err = iDatabase.Exec( KThumbnailRollbackTransaction );
+if ( iState != EOldOpen )
-if ( err >= 0 )
+{
-{
+const TInt err = iDatabase.Exec( KThumbnailRollbackTransaction );
-iState = EClosed;
+if ( err >= 0 )
-}
+{
-return err;
+iState = EClosed;
+}
+return err;
+}
+iState = EClosed;
+return KErrNone;
 }
 // ======== MEMBER FUNCTIONS ========
 {
 delete iDiskFullNotifier;
 iDiskFullNotifier = NULL;
 }
-if(!iServer->IsFormatting())
-{
-	    FlushCacheTable( ETrue );
-}
 if( iAutoFlushTimer )
 {
 iAutoFlushTimer->Cancel();
 delete iAutoFlushTimer;
 iAutoFlushTimer = NULL;
 }
+if( iMaintenanceTimer )
+{
+iMaintenanceTimer->Cancel();
+delete iMaintenanceTimer;
+iMaintenanceTimer = NULL;
+}
+if(!iServer->IsFormatting())
+{
+	    FlushCacheTable( ETrue );
+}
 CloseStatements();
 iDatabase.Close();
 TN_DEBUG1( "CThumbnailStore::~CThumbnailStore() - database closed" );
 }
 // C++ default constructor can NOT contain any code, that might leave.
 // ---------------------------------------------------------------------------
 //
 CThumbnailStore::CThumbnailStore( RFs& aFs, TInt aDrive, TDesC& aImei, CThumbnailServer* aServer ):
 iFs( aFs ), iDrive( aDrive ), iDriveChar( 0 ), iBatchItemCount(0), iImei(aImei),
-iServer(aServer), iDiskFull(EFalse), iUnrecoverable(ETrue)
+iServer(aServer), iDiskFull(EFalse), iUnrecoverable(ETrue), iBatchFlushItemCount(KMInBatchItems)
 {
 // no implementation required
 }
 // ---------------------------------------------------------------------------
 if(checkError == KErrNone)
 {
 checkError = CheckRowIDs();
 }
 }
-else
-{
+// if db file not found, wrong version, corrupted database or other error opening db
-// if db file not found, wrong version, corrupted database or other error opening db
+if ( err != KErrNone || checkError == KErrNotSupported )
-if ( checkError == KErrNotSupported || err != KErrNone )
+{
-{
+CleanupClosePushL(iDatabase);
-CleanupClosePushL(iDatabase);
+RecreateDatabaseL(ETrue);
-RecreateDatabaseL(ETrue);
+CleanupStack::Pop(&iDatabase);
-CleanupStack::Pop(&iDatabase);
+aNewDatabase = ETrue;
-aNewDatabase = ETrue;
+}
-}
-}
 }
 // opened existing database file
 if(!aNewDatabase)
 {
 imeiError = CheckImei();
 if(imeiError != KErrNone)
 {
 //take ownership
-imeiError = UpdateImeiL();
+TRAP(imeiError, UpdateImeiL() );
 //Touch blacklisted items
 TRAP(blistError, PrepareBlacklistedItemsForRetryL() );
 }
 {
 //Touch blacklisted items
 TRAP(blistError2, PrepareBlacklistedItemsForRetryL() );
 }
-if(imeiError == KSqlErrCorrupt || imeiError == KErrCorrupt ||
+if(imeiError != KErrNone || blistError != KErrNone || blistError2 != KErrNone )
-blistError == KSqlErrCorrupt || blistError == KErrCorrupt ||
-blistError2 == KSqlErrCorrupt || blistError2 == KErrCorrupt )
 {
 CleanupClosePushL(iDatabase);
 RecreateDatabaseL(ETrue);
 CleanupStack::Pop(&iDatabase);
 }
 // -----------------------------------------------------------------------------
 // UpdateImeiL()
 // -----------------------------------------------------------------------------
 //
-TInt CThumbnailStore::UpdateImeiL()
+void CThumbnailStore::UpdateImeiL()
 {
 TN_DEBUG1( "CThumbnailStore::UpdateImeiL()" );
 RSqlStatement stmt;
 CleanupClosePushL( stmt );
-TInt ret = stmt.Prepare( iDatabase, KThumbnailUpdateIMEI );
+User::LeaveIfError( stmt.Prepare( iDatabase, KThumbnailUpdateIMEI ) );
 TInt paramIndex = stmt.ParameterIndex( KThumbnailSqlParamImei );
 User::LeaveIfError( paramIndex );
 User::LeaveIfError( stmt.BindText( paramIndex, iImei ));
-TInt err =  stmt.Exec();
+TInt err = stmt.Exec();
 if(err < 0)
 {
 #ifdef _DEBUG
-TPtrC errorMsg2 = iDatabase.LastErrorMessage();
+TPtrC errorMsg = iDatabase.LastErrorMessage();
-TN_DEBUG2( "RThumbnailTransaction::ResetThumbnailIDs() lastError %S, ret = %d" , &errorMsg2);
+TN_DEBUG2( "RThumbnailTransaction::UpdateImeiL() lastError %S" , &errorMsg);
 #endif
-return ret;
+User::Leave(err);
 }
 CleanupStack::PopAndDestroy( &stmt );
-return KErrNone;
 }
 // ---------------------------------------------------------------------------
 // CThumbnailStore::PrepareStatementsL()
 // ---------------------------------------------------------------------------
 err = iStmt_KThumbnailSelectAllPaths.Prepare( iDatabase, KThumbnailSelectAllPaths );
 #ifdef _DEBUG
 msg.Append( iDatabase.LastErrorMessage() );
 TN_DEBUG2( "CThumbnailStore::PrepareStatementsL() KThumbnailSelectAllPaths %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 );
+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 );
 msg.Zero();
 #endif
 User::LeaveIfError( err );
 TN_DEBUG1("CThumbnailStore::PrepareStatementsL() end");
 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");
 }
 // ---------------------------------------------------------------------------
 TN_DEBUG1( "CThumbnailStore::FindDuplicateL() - duplicate in temp table" );
 found = ETrue;
 }
+CleanupStack::PopAndDestroy( stmt );
 // check if duplicate in Deleted
 if (found)
 {
-CleanupStack::PopAndDestroy( stmt );
 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" );
 TN_DEBUG1( "CThumbnailStore::FindDuplicateL() - duplicate force-deleted" );
 found = EFalse;
 }
 }
-CleanupStack::PopAndDestroy( stmt );
 return found;
 }
 // ---------------------------------------------------------------------------
 User::LeaveIfError( stmt->BindText( paramIndex, *path ));
 rowStatus = stmt->Next();
 }
+CleanupStack::PopAndDestroy( stmt_infodata );
+CleanupStack::PopAndDestroy( stmt_info );
 CleanupStack::PopAndDestroy( stmt );
-CleanupStack::PopAndDestroy( stmt_info );
-CleanupStack::PopAndDestroy( stmt_infodata );
 // if forcing instant delete
 if (aForce)
 {
 //look from real table
 TN_DEBUG1( "CThumbnailStore::DeleteThumbnailByPathL() -- MAIN TABLE lookup" );
 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() -- 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 );
-CleanupStack::PopAndDestroy( stmt );
+}
 if (aTransaction)
 {
 transaction.CommitL();
 CleanupStack::PopAndDestroy( &transaction );
 }
 CleanupStack::PopAndDestroy( path );
 }
+// -----------------------------------------------------------------------------
+// Rename thumbnails
+// -----------------------------------------------------------------------------
+//
+void CThumbnailStore::RenameThumbnailsL( const TDesC& aCurrentPath, const TDesC& aNewPath )
+{
+TN_DEBUG2( "CThumbnailStore::RenameThumbnailsL(%S)", &aCurrentPath );
+#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" );
+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" );
+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();
+TN_DEBUG2( "CThumbnailStore::RenameThumbnailsL() took %d ms", (TInt)aStop.MicroSecondsFrom(aStart).Int64()/1000);
+#endif
+}
 // ---------------------------------------------------------------------------
 // CThumbnailStore::PersistentSizes()
 // ---------------------------------------------------------------------------
 //
 void CThumbnailStore::SetPersistentSizes(const RArray < TThumbnailPersistentSize > &aSizes)
 {
 // cache empty or db unusable
 return;
 }
-if(iBatchItemCount < KMaxBatchItems && !aForce)
+// fixed batch size 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);
+}
+if(MPXHarvesting && iBatchItemCount < KMaxBatchItemsMTP && !aForce)
+{
+TN_DEBUG1("CThumbnailStore::FlushCacheTable() MTP sync, fixed batch...");
+//some items in cache
+StartAutoFlush();
+return;
+}
+else if(!MPXHarvesting && iBatchItemCount < iBatchFlushItemCount && !aForce)
 {
 //some items in cache
 StartAutoFlush();
 return;
 }
-#ifdef _DEBUG
+iStartFlush.UniversalTime();
-TTime aStart, aStop;
-aStart.UniversalTime();
-#endif
 // Move data from temp table to main....
 TInt err_begin = iDatabase.Exec( KThumbnailBeginTransaction );
 TN_DEBUG2("CThumbnailStore::FlushCacheTable() KThumbnailBeginTransaction %d", err_begin);
 TN_DEBUG1("CThumbnailStore::FlushCacheTable() db corrupted");
 // open new
 TRAP_IGNORE(OpenDatabaseL(ETrue));
 }
+iStopFlush.UniversalTime();
+TInt aFlushDelay = (TInt)iStopFlush.MicroSecondsFrom(iStartFlush).Int64()/1000;
+TN_DEBUG2( "CThumbnailStore::FlushCacheTable() took %d ms", aFlushDelay);
+//adjust batch size dynamically between min and max based on read flush speed
+if (!MPXHarvesting)
+{
+//increase batch count if there room for one more item (based on average time per item)
+if( aFlushDelay < KMaxFlushDelay && iBatchFlushItemCount < KMaxBatchItems )
+{
+iBatchFlushItemCount++;
+}
+//decrease batch count if we exeeced max time allowed in flushing the TEMP table
+else if(aFlushDelay > KMaxFlushDelay && iBatchFlushItemCount > KMInBatchItems )
+{
+iBatchFlushItemCount--;
+}
+}
 //cache flushed
 iBatchItemCount = 0;
-#ifdef _DEBUG
+TN_DEBUG2("CThumbnailStore::FlushCacheTable() out iBatchFlushItemCount = %d", iBatchFlushItemCount);
-aStop.UniversalTime();
-TN_DEBUG2( "CThumbnailStore::FlushCacheTable() took %d ms", (TInt)aStop.MicroSecondsFrom(aStart).Int64()/1000);
-#endif
-TN_DEBUG1("CThumbnailStore::FlushCacheTable() out");
 }
 // -----------------------------------------------------------------------------
 // StartAutoFlush()
 // -----------------------------------------------------------------------------
 // next round
 if (self->iIdle && ( self->iDeleteThumbs || self->iCheckFilesExist) )
 {
 self->StartMaintenance();
 }
-else
+else if (!self->iDeleteThumbs && !self->iCheckFilesExist)
 {
 // no need to monitor activity anymore
 self->iActivityManager->Cancel();
 }
 }

changeset 17	ffa62e555b02
parent 15	7197e789b953
child 19	b790c5b3d11f