1 /*

     2 * Copyright (c) 2006-2007 Nokia Corporation and/or its subsidiary(-ies). 

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  Store for thumbnails.

    15  *

    16 */

    17 

    18 

    19 #include <s32mem.h>

    20 #include <e32cmn.h>

    21 #include <fbs.h>

    22 #include <imageconversion.h>

    23 #include <e32base.h>

    24 #include <ExifRead.h>

    25 #include <bautils.h>  

    26 #include <IclExtJpegApi.h>

    27 

    28 #include "thumbnailstore.h"

    29 #include "thumbnailsql.h"

    30 #include "thumbnaillog.h"

    31 #include "thumbnailmanageruids.hrh"

    32 #include "thumbnailcenrep.h"

    33 #include "thumbnailpanic.h"

    34 #include "thumbnailmanagerconstants.h"

    35 #include "thumbnailserver.h"

    36 #include "OstTraceDefinitions.h"

    37 #ifdef OST_TRACE_COMPILER_IN_USE

    38 #include "thumbnailstoreTraces.h"

    39 #endif

    40 

    41 

    42 

    43 _LIT8( KThumbnailSqlConfig, "page_size=32768; cache_size=64;" );

    44 

    45 const TInt KStreamBufferSize = 1024 * 8;

    46 const TInt KMajor = 3;

    47 const TInt KMinor = 2;

    48 

    49 const TInt KStoreUnrecoverableErr = KErrCorrupt;

    50 

    51 // Database path without drive letter

    52 //Symbian^4 v5

    53 _LIT( KThumbnailDatabaseName, ":[102830AB]thumbnail_v5.db" );

    54 

    55 

    56 // Allow access to database only for the server process

    57 const TSecurityPolicy KThumbnailDatabaseSecurityPolicy( TSecureId(

    58     THUMBNAIL_MANAGER_SERVER_UID ));

    59 

    60 

    61 // ---------------------------------------------------------------------------

    62 // RThumbnailTransaction::RThumbnailTransaction::TThumbnailPersistentSize

    63 // ---------------------------------------------------------------------------

    64 //

    65 RThumbnailTransaction::RThumbnailTransaction( RSqlDatabase& aDatabase ):

    66     iDatabase( aDatabase ), iState( EClosed )

    67     {

    68     // No implementation required

    69     }

    70 

    71 // ---------------------------------------------------------------------------

    72 // RThumbnailTransaction::BeginL()

    73 // ---------------------------------------------------------------------------

    74 //

    75 void RThumbnailTransaction::BeginL()

    76     {    

    77     if (iDatabase.InTransaction())

    78         {

    79         TN_DEBUG1( "RThumbnailTransaction::BeginL() - error: old transaction open!" );

    80         OstTrace0( TRACE_NORMAL, RTHUMBNAILTRANSACTION_BEGINL, "RThumbnailTransaction::BeginL - error: old transaction open!" );

    81         __ASSERT_DEBUG(( !iDatabase.InTransaction() ), ThumbnailPanic( EThumbnailSQLTransaction ));

    82         

    83         // old transaction already open, don't open another

    84         iState = EOldOpen;

    85         

    86         return;

    87         }

    88     

    89     const TInt err = iDatabase.Exec( KThumbnailBeginTransaction );

    90     if ( err >= 0 )

    91         {

    92         iState = EOpen;

    93         }

    94     else

    95         {

    96         iState = EError;

    97 #ifdef _DEBUG

    98     TPtrC errorMsg = iDatabase.LastErrorMessage();

    99     TN_DEBUG3( "RThumbnailTransaction::BeginL() lastError %S, ret = %d" , &errorMsg, err);

   100     OstTraceExt2( TRACE_NORMAL, DUP1_RTHUMBNAILTRANSACTION_BEGINL, "RThumbnailTransaction::BeginL - lastError;errorMsg=%S;err=%d", errorMsg, err );

   101 #endif

   102         User::Leave( err );

   103         }

   104     }

   105 

   106 // ---------------------------------------------------------------------------

   107 // RThumbnailTransaction::Close()

   108 // ---------------------------------------------------------------------------

   109 //

   110 void RThumbnailTransaction::Close()

   111     {

   112     if ( iState != EClosed && iState != EOldOpen )

   113         {

   114         Rollback();

   115         }

   116     }

   117 

   118 // ---------------------------------------------------------------------------

   119 // RThumbnailTransaction::CommitL()

   120 // ---------------------------------------------------------------------------

   121 //

   122 void RThumbnailTransaction::CommitL()

   123     {

   124     if ( iState != EOldOpen )

   125         {

   126         TInt ret = iDatabase.Exec( KThumbnailCommitTransaction );

   127     

   128 #ifdef _DEBUG

   129     TPtrC errorMsg = iDatabase.LastErrorMessage();

   130     TN_DEBUG3( "RThumbnailTransaction::CommitL() lastError %S, ret = %d" , &errorMsg, ret);

   131     OstTraceExt2( TRACE_NORMAL, DUP2_RTHUMBNAILTRANSACTION_BEGINL, "RThumbnailTransaction::BeginL - lastError;errorMsg=%S;ret=%d", errorMsg, ret );

   132 #endif  

   133     User::LeaveIfError( ret );

   134         }

   135     

   136     iState = EClosed;

   137     }

   138 

   139 // ---------------------------------------------------------------------------

   140 // RThumbnailTransaction::Rollback()

   141 // ---------------------------------------------------------------------------

   142 //

   143 TInt RThumbnailTransaction::Rollback()

   144     {

   145     if ( iState != EOldOpen )

   146         {

   147         // in some cases there could have been automatic rollback

   148         if (iDatabase.InTransaction())

   149             {

   150             const TInt err = iDatabase.Exec( KThumbnailRollbackTransaction );

   151             if ( err >= 0 )

   152                 {

   153                 iState = EClosed;

   154                 }

   155             

   156             return err;

   157             }

   158         else

   159             {

   160             TN_DEBUG1( "RThumbnailTransaction::Rollback() - automatic rollback already done!" );

   161             OstTrace0( TRACE_NORMAL, RTHUMBNAILTRANSACTION_ROLLBACK, "RThumbnailTransaction::Rollback - automatic rollback already done!" );

   162             }

   163         }

   164     

   165     iState = EClosed;

   166     

   167     return KErrNone;

   168     }

   169 

   170 

   171 // ======== MEMBER FUNCTIONS ========

   172 

   173 // ---------------------------------------------------------------------------

   174 // CThumbnailStore::NewL()

   175 // Two-phased constructor.

   176 // ---------------------------------------------------------------------------

   177 //

   178 CThumbnailStore* CThumbnailStore::NewL( RFs& aFs, TInt aDrive, TDesC& aImei, CThumbnailServer* aServer, const TBool aReadOnly )

   179     {

   180     CThumbnailStore* self = new( ELeave )CThumbnailStore( aFs, aDrive, aImei, aServer, aReadOnly );

   181     CleanupStack::PushL( self );

   182     self->ConstructL();

   183     CleanupStack::Pop( self );

   184     return self;

   185     }

   186 

   187 

   188 // ---------------------------------------------------------------------------

   189 // CThumbnailStore::~CThumbnailStore()

   190 // Destructor.

   191 // ---------------------------------------------------------------------------

   192 //

   193 CThumbnailStore::~CThumbnailStore()

   194     {

   195     TN_DEBUG2( "CThumbnailStore::~CThumbnailStore() drive: %d", iDrive );

   196     OstTrace1( TRACE_NORMAL, CTHUMBNAILSTORE_CTHUMBNAILSTORE, "CThumbnailStore::~CThumbnailStore;iDrive=%d", iDrive );

   197     

   198     if(iActivityManager)

   199         {

   200         delete iActivityManager;

   201         iActivityManager = NULL;

   202         }

   203     

   204     if(iDiskFullNotifier)

   205         {

   206         delete iDiskFullNotifier;

   207         iDiskFullNotifier = NULL;

   208         }

   209 

   210     if( iAutoFlushTimer )

   211         {

   212         iAutoFlushTimer->Cancel();

   213         delete iAutoFlushTimer;

   214         iAutoFlushTimer = NULL;

   215         }

   216     

   217     if( iMaintenanceTimer )

   218         {

   219         iMaintenanceTimer->Cancel();

   220         delete iMaintenanceTimer;

   221         iMaintenanceTimer = NULL;

   222         }

   223     

   224     CloseStatements();   

   225     iDatabase.Close();

   226     

   227     TN_DEBUG1( "CThumbnailStore::~CThumbnailStore() - database closed" );

   228     OstTrace0( TRACE_NORMAL, DUP1_CTHUMBNAILSTORE_CTHUMBNAILSTORE, "CThumbnailStore::~CThumbnailStore - database closed" );

   229     }

   230 

   231 // ---------------------------------------------------------------------------

   232 // CThumbnailStore::CThumbnailStore()

   233 // C++ default constructor can NOT contain any code, that might leave.

   234 // ---------------------------------------------------------------------------

   235 //

   236 CThumbnailStore::CThumbnailStore( RFs& aFs, TInt aDrive, TDesC& aImei, CThumbnailServer* aServer, const TBool aReadOnly ): 

   237     iFs( aFs ), iDrive( aDrive ), iDriveChar( 0 ), iBatchItemCount(0), iImei(aImei), iServer(aServer), iDiskFullNotifier(NULL), 

   238     iDiskFull(EFalse), iActivityManager(NULL), iUnrecoverable(ETrue), iBatchFlushItemCount(KMInBatchItems), iReadOnly(aReadOnly)

   239     {

   240     // no implementation required

   241     }

   242 

   243 // ---------------------------------------------------------------------------

   244 // CThumbnailStore::ConstructL()

   245 // Symbian 2nd phase constructor can leave.

   246 // ---------------------------------------------------------------------------

   247 //

   248 void CThumbnailStore::ConstructL()

   249     {

   250     TN_DEBUG1( "CThumbnailStore::ConstructL()" );

   251     OstTrace0( TRACE_NORMAL, CTHUMBNAILSTORE_CONSTRUCTL, "CThumbnailStore::ConstructL" );

   252 

   253 #ifdef _DEBUG

   254     iThumbCounter = 0;

   255 #endif

   256     if(!iReadOnly)

   257         {

   258         HBufC* databasePath = HBufC::NewLC( KMaxFileName );

   259         TPtr pathPtr = databasePath->Des();

   260         User::LeaveIfError( RFs::DriveToChar( iDrive, iDriveChar ));

   261         pathPtr.Append( iDriveChar );

   262         pathPtr.Append( KThumbnailDatabaseName );

   263         

   264         //start disk space monitor

   265         iDiskFullNotifier = CThumbnailStoreDiskSpaceNotifierAO::NewL( *this, 

   266                                                 KDiskFullThreshold,

   267                                                 pathPtr );

   268 

   269         CleanupStack::PopAndDestroy( databasePath );

   270     

   271         TN_DEBUG2( "CThumbnailStore::ConstructL() drive: %d", iDrive );

   272         OstTrace1( TRACE_NORMAL, DUP1_CTHUMBNAILSTORE_CONSTRUCTL, "CThumbnailStore::ConstructL;iDrive=%d", iDrive );

   273     

   274         OpenDatabaseL();

   275     

   276         // to monitor device activity

   277         iActivityManager = CTMActivityManager::NewL( this, KStoreMaintenanceIdle);

   278         iActivityManager->Start();

   279     

   280         iDeleteThumbs = ETrue;

   281         iCheckFilesExist = ETrue;

   282         }

   283     else

   284         {

   285 	    TN_DEBUG1( "CThumbnailStore::ConstructL() - read only, dymmy mode..." );

   286         OstTrace0( TRACE_NORMAL, DUP2_CTHUMBNAILSTORE_CONSTRUCTL, "CThumbnailStore::ConstructL - read only, dymmy mode..." );

   287         iDeleteThumbs = EFalse;

   288         iCheckFilesExist = EFalse;

   289         iLastCheckedRowID = -1;

   290         }

   291     }

   292 

   293 // ---------------------------------------------------------------------------

   294 // OpenDatabaseL database file

   295 // ---------------------------------------------------------------------------

   296 TInt CThumbnailStore::OpenDatabaseFileL()

   297     {

   298     TN_DEBUG1( "CThumbnailStore::OpenDatabaseFile()" );

   299     OstTrace0( TRACE_NORMAL, CTHUMBNAILSTORE_OPENDATABASEFILEL, "CThumbnailStore::OpenDatabaseFileL" );

   300     

   301     HBufC* databasePath = HBufC::NewLC( KMaxFileName );

   302     TPtr pathPtr = databasePath->Des();

   303     TChar driveChar = 0;

   304     User::LeaveIfError( RFs::DriveToChar( iDrive, driveChar ));

   305     pathPtr.Append( driveChar );

   306     pathPtr.Append( KThumbnailDatabaseName );

   307     

   308     TInt ret = iDatabase.Open( pathPtr );

   309     CleanupStack::PopAndDestroy( databasePath );

   310     return ret;

   311     }

   312 

   313 // ---------------------------------------------------------------------------

   314 // OpenDatabaseL database

   315 // ---------------------------------------------------------------------------

   316 TInt CThumbnailStore::OpenDatabaseL( TBool aNewDatabase )

   317     {

   318     TN_DEBUG2( "CThumbnailStore::OpenDatabaseL() drive: %d", iDrive );

   319     OstTrace1( TRACE_NORMAL, CTHUMBNAILSTORE_OPENDATABASEL, "CThumbnailStore::OpenDatabaseL;iDrive=%d", iDrive );

   320         

   321     CloseStatements();

   322     iDatabase.Close();

   323     iUnrecoverable = ETrue;

   324     

   325     TInt checkError = KErrNone;

   326     TInt blistError = KErrNone;

   327     TInt blistError2 = KErrNone;

   328     TInt imeiError = KErrNone;

   329     TInt err = KErrNone;

   330     

   331     if (aNewDatabase)

   332         {

   333         // delete existing and create new

   334         CleanupClosePushL(iDatabase);

   335         RecreateDatabaseL(ETrue);

   336         CleanupStack::Pop(&iDatabase);

   337         }

   338     else

   339         {

   340         // just open old

   341         err = OpenDatabaseFileL();

   342         

   343         TN_DEBUG2( "CThumbnailStore::OpenDatabaseL() -- err = %d", err);

   344         OstTrace1( TRACE_NORMAL, DUP1_CTHUMBNAILSTORE_OPENDATABASEL, "CThumbnailStore::OpenDatabaseL;err=%d", err );

   345                

   346         if ( err == KErrNone)

   347             {

   348             // db found, check version and rowids

   349             checkError = CheckVersion();

   350             if(checkError == KErrNone)

   351                 {

   352                 checkError = CheckRowIDs();

   353                 }

   354             }

   355 

   356         // if db file not found, wrong version, corrupted database or other error opening db

   357         if ( err != KErrNone || checkError == KErrNotSupported )

   358             {

   359             CleanupClosePushL(iDatabase);

   360             RecreateDatabaseL(ETrue);

   361             CleanupStack::Pop(&iDatabase);

   362             

   363             aNewDatabase = ETrue;

   364             }          

   365         }    

   366    

   367     // opened existing database file

   368     if(!aNewDatabase)

   369         {       

   370         // add temp tables

   371         CreateTempTablesL();

   372     

   373         //check ownership

   374         imeiError = CheckImei();

   375        

   376         if(imeiError != KErrNone)

   377             {

   378             //take ownership

   379             TRAP(imeiError, UpdateImeiL() );

   380             

   381             //Touch blacklisted items

   382             TRAP(blistError, PrepareBlacklistedItemsForRetryL() );

   383             }

   384        

   385         //check if MMC is known

   386         if(CheckMediaIDL() != KErrNone)

   387             {

   388             //Touch blacklisted items

   389             TRAP(blistError2, PrepareBlacklistedItemsForRetryL() );

   390             }

   391         

   392         if(imeiError != KErrNone || blistError != KErrNone || blistError2 != KErrNone )

   393             {

   394             CleanupClosePushL(iDatabase);

   395             RecreateDatabaseL(ETrue);

   396             CleanupStack::Pop(&iDatabase);

   397             }

   398         }

   399    

   400     PrepareStatementsL();

   401     

   402     // database now usable

   403     iUnrecoverable = EFalse;

   404     

   405     return KErrNone;

   406     }

   407 

   408 // ---------------------------------------------------------------------------

   409 // PrepareDbL database tables

   410 // ---------------------------------------------------------------------------

   411 //

   412 void CThumbnailStore::PrepareDbL()

   413     {

   414     TN_DEBUG1( "CThumbnailStore::PrepareDbL()" );

   415     OstTrace0( TRACE_NORMAL, CTHUMBNAILSTORE_PREPAREDBL, "CThumbnailStore::PrepareDbL" );

   416     

   417     // add persistent tables

   418     CreateTablesL();

   419       

   420     AddVersionAndImeiL();

   421     

   422     // add temp tables

   423     CreateTempTablesL();

   424     }

   425 

   426 // ---------------------------------------------------------------------------

   427 // Create database tables

   428 // ---------------------------------------------------------------------------

   429 //

   430 void CThumbnailStore::CreateTablesL()

   431     {

   432     TN_DEBUG1( "CThumbnailStore::CreateTablesL()" );

   433     OstTrace0( TRACE_NORMAL, CTHUMBNAILSTORE_CREATETABLESL, "CThumbnailStore::CreateTablesL" );

   434     

   435     TInt err = KErrNone;

   436     err = iDatabase.Exec( KThumbnailCreateInfoTable );

   437     TN_DEBUG2( "CThumbnailStore::CreateTablesL() KThumbnailCreateInfoTable err=%d", err );

   438     OstTrace1( TRACE_NORMAL, DUP1_CTHUMBNAILSTORE_CREATETABLESL, "CThumbnailStore::CreateTablesL - KThumbnailCreateInfoTable;err=%d", err );

   439     User::LeaveIfError( err );

   440     

   441     err = iDatabase.Exec( KThumbnailCreateInfoDataTable );

   442     TN_DEBUG2( "CThumbnailStore::CreateTablesL() KThumbnailCreateInfoDataTable err=%d", err );

   443     OstTrace1( TRACE_NORMAL, DUP2_CTHUMBNAILSTORE_CREATETABLESL, "CThumbnailStore::CreateTablesL - KThumbnailCreateInfoDataTable;err=%d", err );

   444     User::LeaveIfError( err );

   445     

   446     err = iDatabase.Exec(KThumbnailDeletedTable);

   447     TN_DEBUG2( "CThumbnailStore::CreateTablesL() KThumbnailDeletedTable err=%d", err );

   448     OstTrace1( TRACE_NORMAL, DUP3_CTHUMBNAILSTORE_CREATETABLESL, "CThumbnailStore::CreateTablesL - KThumbnailDeletedTable;err=%d", err );

   449     User::LeaveIfError( err );

   450     

   451     err = iDatabase.Exec( KThumbnailCreateInfoTableIndex1 );

   452     TN_DEBUG2( "CThumbnailStore::CreateTablesL() KThumbnailCreateInfoTableIndex1 err=%d", err );

   453     User::LeaveIfError( err );

   454     

   455     err = iDatabase.Exec(KThumbnailVersionTable);

   456     TN_DEBUG2( "CThumbnailStore::CreateTablesL() KThumbnailVersionTable err=%d", err );

   457     OstTrace1( TRACE_NORMAL, DUP4_CTHUMBNAILSTORE_CREATETABLESL, "CThumbnailStore::CreateTablesL;err=%d", err );

   458     User::LeaveIfError( err );

   459     }

   460 

   461 // ---------------------------------------------------------------------------

   462 // Create temp tables

   463 // ---------------------------------------------------------------------------

   464 //

   465 void CThumbnailStore::CreateTempTablesL()

   466     {

   467     TN_DEBUG1( "CThumbnailStore::CreateTempTablesL()" );

   468     OstTrace0( TRACE_NORMAL, CTHUMBNAILSTORE_CREATETEMPTABLESL, "CThumbnailStore::CreateTempTablesL" );

   469 

   470     TInt err = iDatabase.Exec( KThumbnailCreateTempInfoTable );

   471 

   472 #ifdef _DEBUG

   473     if(err < 0)

   474         {

   475         TPtrC errorMsg = iDatabase.LastErrorMessage();

   476         TN_DEBUG2( "CThumbnailStore::PrepareDbL() KThumbnailCreateTempInfoTable %S" , &errorMsg);

   477         OstTraceExt1( TRACE_NORMAL, DUP1_CTHUMBNAILSTORE_CREATETEMPTABLESL, "CThumbnailStore::CreateTempTablesL - KThumbnailCreateTempInfoTable;errorMsg=%S", errorMsg );

   478         }

   479 #endif

   480     

   481     User::LeaveIfError( err );

   482 

   483     err = iDatabase.Exec( KThumbnailCreateTempInfoDataTable );

   484 

   485 #ifdef _DEBUG

   486     if(err < 0)

   487         {

   488         TPtrC errorMsg = iDatabase.LastErrorMessage();

   489         TN_DEBUG2( "CThumbnailStore::PrepareDbL() KThumbnailCreateTempInfoDataTable %S" , &errorMsg);

   490         OstTraceExt1( TRACE_NORMAL, DUP2_CTHUMBNAILSTORE_CREATETEMPTABLESL, "CThumbnailStore::CreateTempTablesL - KThumbnailCreateTempInfoDataTable;errorMsg=%S", errorMsg );

   491         }

   492 #endif

   493     

   494     User::LeaveIfError( err );

   495     }

   496 

   497 void CThumbnailStore::RecreateDatabaseL(const TBool aDelete)

   498     {

   499     TN_DEBUG2( "CThumbnailStore::RecreateDatabaseL() drive: %d", iDrive );

   500     OstTrace1( TRACE_NORMAL, CTHUMBNAILSTORE_RECREATEDATABASEL, "CThumbnailStore::RecreateDatabaseL;iDrive=%d", iDrive );

   501     

   502     TVolumeInfo volumeinfo;

   503     User::LeaveIfError( iFs.Volume(volumeinfo, iDrive) );

   504     TUint id = volumeinfo.iUniqueID;

   505     TBuf<50> mediaid;

   506     mediaid.Num(id);

   507    

   508     CloseStatements();

   509     iDatabase.Close();

   510     iUnrecoverable = ETrue;

   511     

   512     TN_DEBUG1( "CThumbnailStore::RecreateDatabaseL() database closed" );

   513     OstTrace0( TRACE_NORMAL, DUP1_CTHUMBNAILSTORE_RECREATEDATABASEL, "CThumbnailStore::RecreateDatabaseL - database closed" );

   514     

   515     HBufC* databasePath = HBufC::NewLC( KMaxFileName );

   516     TPtr pathPtr = databasePath->Des();

   517     User::LeaveIfError( RFs::DriveToChar( iDrive, iDriveChar ));

   518     pathPtr.Append( iDriveChar );

   519     pathPtr.Append( KThumbnailDatabaseName );

   520     

   521     TInt err(KErrNone);

   522     

   523     // delete old if necessary

   524     if(aDelete)

   525         {

   526         TN_DEBUG1( "CThumbnailStore::RecreateDatabaseL() delete database" );

   527         OstTrace0( TRACE_NORMAL, DUP2_CTHUMBNAILSTORE_RECREATEDATABASEL, "CThumbnailStore::RecreateDatabaseL - delete database" );

   528         TInt del = iDatabase.Delete(pathPtr);     

   529         TN_DEBUG2( "CThumbnailStore::RecreateDatabaseL() deleted database, err: %d", del );       

   530         OstTrace0( TRACE_NORMAL, DUP4_CTHUMBNAILSTORE_RECREATEDATABASEL, "CThumbnailStore::RecreateDatabaseL" );

   531         }

   532         

   533     const TDesC8& config = KThumbnailSqlConfig;

   534 

   535     RSqlSecurityPolicy securityPolicy;

   536     CleanupClosePushL( securityPolicy );

   537     securityPolicy.CreateL( KThumbnailDatabaseSecurityPolicy );

   538 

   539     // create new

   540     TN_DEBUG1( "CThumbnailStore::RecreateDatabaseL() create new" );

   541     OstTrace0( TRACE_FATAL, DUP3_CTHUMBNAILSTORE_RECREATEDATABASEL, "CThumbnailStore::RecreateDatabaseL - create new" );

   542     TRAP(err, iDatabase.CreateL( pathPtr, securityPolicy, &config ));    

   543     TN_DEBUG2( "CThumbnailStore::RecreateDatabaseL() -- database created, err = %d", err );

   544     OstTrace1( TRACE_FATAL, DUP5_CTHUMBNAILSTORE_RECREATEDATABASEL, "CThumbnailStore::RecreateDatabaseL;err=%d", err );

   545     User::LeaveIfError(err);

   546     

   547     CleanupStack::PopAndDestroy( &securityPolicy );

   548     

   549     // add tables

   550     TRAPD(prepareErr, PrepareDbL() );

   551     

   552     TN_DEBUG2( "CThumbnailStore::RecreateDatabaseL() -- prepare tables, err = %d", prepareErr );

   553     OstTrace1( TRACE_FATAL, DUP6_CTHUMBNAILSTORE_RECREATEDATABASEL, "CThumbnailStore::RecreateDatabaseL - prepare tables;prepareErr=%d", prepareErr );

   554     

   555     TInt mediaidErr(KErrNone);

   556     

   557     // write media id file if doesn't exist

   558     if(!BaflUtils::FileExists( iFs, mediaid ))

   559         {

   560         RFile64 file;

   561         mediaidErr = file.Create(iFs, mediaid, EFileShareReadersOrWriters );

   562         file.Close();

   563         

   564         TN_DEBUG2( "CThumbnailStore::RecreateDatabaseL() -- mediaID file created, err = %d", mediaidErr );

   565         OstTrace1( TRACE_FATAL, DUP7_CTHUMBNAILSTORE_RECREATEDATABASEL, "CThumbnailStore::RecreateDatabaseL;mediaidErr=%d", mediaidErr );

   566         }

   567     

   568     // delete db if not fully complete

   569     if (prepareErr < 0 || mediaidErr < 0)

   570         {

   571         CloseStatements();

   572         iDatabase.Close();

   573         TN_DEBUG1( "CThumbnailStore::RecreateDatabaseL() delete database" );

   574         OstTrace0( TRACE_FATAL, DUP8_CTHUMBNAILSTORE_RECREATEDATABASEL, "CThumbnailStore::RecreateDatabaseL - delete database" );

   575         TInt del = iDatabase.Delete(pathPtr);     

   576         TN_DEBUG2( "CThumbnailStore::RecreateDatabaseL() deleted database, err: %d", del );

   577         OstTrace1( TRACE_FATAL, DUP9_CTHUMBNAILSTORE_RECREATEDATABASEL, "CThumbnailStore::RecreateDatabaseL - delete database;del=%d", del );

   578         }

   579     

   580     User::LeaveIfError( prepareErr );

   581     User::LeaveIfError( mediaidErr );

   582     

   583     CleanupStack::PopAndDestroy( databasePath );

   584     }

   585 

   586 TInt CThumbnailStore::CheckRowIDs()

   587     {

   588     TN_DEBUG1( "CThumbnailStore::CheckRowIDs()");

   589     OstTrace0( TRACE_FATAL, CTHUMBNAILSTORE_CHECKROWIDS, "CThumbnailStore::CheckRowIDs" );

   590     

   591     RSqlStatement stmt;

   592     TInt column = 0;   

   593     TInt rowStatus = 0;

   594     TInt64 inforows = -1;

   595     TInt64 datarows = -1;

   596     

   597     TInt ret = stmt.Prepare( iDatabase, KGetInfoRowID );

   598     if(ret < 0)

   599         {

   600         stmt.Close();

   601         TN_DEBUG1( "CThumbnailStore::CheckRowIDs() KGetInfoRowID failed %d");

   602         OstTrace1( TRACE_FATAL, DUP1_CTHUMBNAILSTORE_CHECKROWIDS, "CThumbnailStore::CheckRowIDs KGetInfoRowID failed;ret=%d", ret );

   603         return KErrNotSupported;

   604         }

   605     rowStatus = stmt.Next();

   606                 

   607     if ( rowStatus == KSqlAtRow)    

   608         {        

   609         inforows = stmt.ColumnInt64( column );  

   610         }

   611                 

   612     stmt.Close();

   613     

   614     if(rowStatus < 0)

   615         {

   616 #ifdef _DEBUG

   617         TPtrC errorMsg2 = iDatabase.LastErrorMessage();

   618         TN_DEBUG2( "RThumbnailTransaction::ResetThumbnailIDs() lastError %S, ret = %d" , &errorMsg2);

   619         OstTraceExt1( TRACE_FATAL, DUP2_CTHUMBNAILSTORE_CHECKROWIDS, "CThumbnailStore::CheckRowIDs - lastError;errorMsg2=%S", errorMsg2 );

   620 #endif

   621         return KErrNotSupported;

   622         }

   623               

   624     ret = stmt.Prepare( iDatabase, KGetDataRowID );

   625     if(ret < 0)

   626         {

   627         stmt.Close();

   628         TN_DEBUG1( "CThumbnailStore::CheckRowIDs() KGetDataRowID failed");

   629         OstTrace0( TRACE_FATAL, DUP3_CTHUMBNAILSTORE_CHECKROWIDS, "CThumbnailStore::CheckRowIDs - KGetDataRowID failed" );

   630         return KErrNotSupported;

   631         }

   632     rowStatus = stmt.Next();

   633                        

   634     if ( rowStatus == KSqlAtRow)    

   635         {        

   636         datarows = stmt.ColumnInt64( column );  

   637         }

   638             

   639     stmt.Close();

   640     

   641     if( rowStatus < 0)

   642         {

   643 #ifdef _DEBUG

   644         TPtrC errorMsg2 = iDatabase.LastErrorMessage();

   645         TN_DEBUG2( "RThumbnailTransaction::ResetThumbnailIDs() lastError %S, ret = %d" , &errorMsg2);

   646         OstTraceExt1( TRACE_FATAL, DUP4_CTHUMBNAILSTORE_CHECKROWIDS, "CThumbnailStore::CheckRowIDs - lastError;errorMsg2=%S", errorMsg2 );

   647 #endif

   648         return KErrNotSupported;

   649         }

   650     

   651     TN_DEBUG2( "CThumbnailStore::CheckRowIDsL() - inforows %Ld", inforows );

   652     OstTraceExt1( TRACE_FATAL, DUP5_CTHUMBNAILSTORE_CHECKROWIDS, "CThumbnailStore::CheckRowIDs;inforows=%g", inforows );

   653     TN_DEBUG2( "CThumbnailStore::CheckRowIDsL() - datarows %Ld", datarows );

   654     OstTraceExt1( TRACE_FATAL, DUP6_CTHUMBNAILSTORE_CHECKROWIDS, "CThumbnailStore::CheckRowIDs;datarows=%Ld", datarows );

   655             

   656     if( inforows != datarows )

   657         {

   658         TN_DEBUG1( "CThumbnailStore::CheckRowIDsL() - tables out of sync" );

   659         return KErrNotSupported;

   660         }  

   661     else

   662         {

   663         return KErrNone;

   664         }

   665     }

   666 

   667 // -----------------------------------------------------------------------------

   668 // CheckVersion()

   669 // -----------------------------------------------------------------------------

   670 //

   671 TInt CThumbnailStore::CheckVersion()

   672     {

   673     TN_DEBUG1( "CThumbnailStore::CheckVersion()" );

   674     OstTrace0( TRACE_FATAL, CTHUMBNAILSTORE_CHECKVERSION, "CThumbnailStore::CheckVersion" );

   675     RSqlStatement stmt;

   676          

   677     TInt rowStatus = 0;

   678     TInt column = 0;

   679     TInt minor = 0;

   680     TInt major = 0;

   681 

   682     TInt ret = stmt.Prepare( iDatabase, KThumbnailSelectFromVersion );

   683     if(ret < 0 )

   684        {  

   685        stmt.Close();

   686        TN_DEBUG1( "CThumbnailStore::CheckVersion() unknown version" );

   687        OstTrace0( TRACE_FATAL, DUP1_CTHUMBNAILSTORE_CHECKVERSION, "CThumbnailStore::CheckVersion - unknown version" );

   688        return KErrNotSupported;

   689        }

   690               

   691     rowStatus = stmt.Next();

   692     

   693     if ( rowStatus == KSqlAtRow)    

   694        {        

   695        major = stmt.ColumnInt( column++);

   696        minor = stmt.ColumnInt( column++);

   697        }

   698     

   699     stmt.Close();

   700     

   701     if( rowStatus < 0 )

   702         {

   703 #ifdef _DEBUG

   704          TPtrC errorMsg = iDatabase.LastErrorMessage();

   705         TN_DEBUG2( "RThumbnailTransaction::CheckVersion() lastError %S, ret = %d" , &errorMsg);

   706         OstTrace0( TRACE_FATAL, DUP2_CTHUMBNAILSTORE_CHECKVERSION, "CThumbnailStore::CheckVersion" );

   707 #endif

   708         return ret;

   709         }

   710     

   711     if(major == KMajor && minor == KMinor )

   712       {

   713       return KErrNone;  

   714       }

   715     else

   716       {

   717       TN_DEBUG1( "CThumbnailStore::CheckVersion() - wrong DB version" );

   718       OstTrace0( TRACE_FATAL, DUP3_CTHUMBNAILSTORE_CHECKVERSION, "CThumbnailStore::CheckVersion" );

   719       return KErrNotSupported;  

   720       }

   721     }

   722 

   723 // -----------------------------------------------------------------------------

   724 // CheckImei()

   725 // -----------------------------------------------------------------------------

   726 //

   727 TInt CThumbnailStore::CheckImei()

   728     {

   729     TN_DEBUG1( "CThumbnailStore::CheckImei()" );

   730     OstTrace0( TRACE_FATAL, CTHUMBNAILSTORE_CHECKIMEI, "CThumbnailStore::CheckImei" );

   731     RSqlStatement stmt;

   732          

   733     TInt rowStatus = 0;

   734     TInt column = 0;

   735     TBuf<KImeiBufferSize> imei;

   736       

   737     TInt ret = stmt.Prepare( iDatabase, KThumbnailSelectFromVersion );

   738     if(ret < 0 )

   739        {  

   740         stmt.Close();

   741        TN_DEBUG1( "CThumbnailStore::CheckImei() failed" );

   742        OstTrace0( TRACE_FATAL, DUP1_CTHUMBNAILSTORE_CHECKIMEI, "CThumbnailStore::CheckImei - failed" );

   743        return KErrNotSupported;

   744        }

   745               

   746     rowStatus = stmt.Next();

   747     

   748     if ( rowStatus == KSqlAtRow)    

   749        {        

   750        column = 2; // imei column

   751        stmt.ColumnText( column, imei);  

   752        }

   753     

   754     stmt.Close(); 

   755     

   756     if( rowStatus < 0 )

   757         {

   758 #ifdef _DEBUG

   759          TPtrC errorMsg = iDatabase.LastErrorMessage();

   760         TN_DEBUG2( "RThumbnailTransaction::CheckImei() lastError %S, ret = %d" , &errorMsg);

   761         OstTraceExt1( TRACE_FATAL, DUP2_CTHUMBNAILSTORE_CHECKIMEI, "CThumbnailStore::CheckImei - lastError;errorMsg=%S", errorMsg );

   762 #endif

   763         return ret;

   764         }

   765     

   766     if( imei == iImei )

   767       {

   768       return KErrNone;  

   769       }

   770     else

   771       {

   772       TN_DEBUG1( "CThumbnailStore::CheckImei() mismatch" );

   773       OstTrace0( TRACE_FATAL, DUP3_CTHUMBNAILSTORE_CHECKIMEI, "CThumbnailStore::CheckImei - mismatch" );

   774       return KErrNotSupported;  

   775       }

   776     }

   777 

   778 // -----------------------------------------------------------------------------

   779 // CheckMediaID()

   780 // -----------------------------------------------------------------------------

   781 //

   782 TInt CThumbnailStore::CheckMediaIDL()

   783     {

   784     TN_DEBUG1( "CThumbnailStore::CheckMediaIDL()" );

   785     OstTrace0( TRACE_FATAL, CTHUMBNAILSTORE_CHECKMEDIAIDL, "CThumbnailStore::CheckMediaIDL" );

   786     

   787     TVolumeInfo volumeinfo;

   788     User::LeaveIfError( iFs.Volume(volumeinfo, iDrive) );

   789     TUint id = volumeinfo.iUniqueID;

   790     TBuf<50> mediaid;

   791     mediaid.Num(id);

   792     

   793     if(!BaflUtils::FileExists( iFs, mediaid ))

   794        {

   795        RFile64 file;

   796        TInt err = file.Create(iFs, mediaid, EFileShareReadersOrWriters );

   797        file.Close();

   798        TN_DEBUG2( "CThumbnailStore::CheckMediaIDL() -- mediaID file created, err = %d", err );

   799        OstTrace1( TRACE_FATAL, DUP1_CTHUMBNAILSTORE_CHECKMEDIAIDL, "CThumbnailStore::CheckMediaIDL - mediaID file created;err=%d", err );

   800        

   801        return KErrNotSupported;

   802        } 

   803 

   804     return KErrNone;  

   805     }

   806      

   807 // ----------------------------------------------------------------------------

   808 // AddVersionAndImeiL()

   809 // -----------------------------------------------------------------------------

   810 //

   811 void CThumbnailStore::AddVersionAndImeiL()

   812     {

   813     TN_DEBUG1( "CThumbnailStore::AddVersionAndImei()" );

   814     OstTrace0( TRACE_FATAL, CTHUMBNAILSTORE_ADDVERSIONANDIMEIL, "CThumbnailStore::AddVersionAndImeiL" );

   815     RSqlStatement stmt;

   816     CleanupClosePushL( stmt );

   817             

   818     TInt paramIndex = 0;

   819             

   820     User::LeaveIfError( stmt.Prepare( iDatabase, KThumbnailInsertToVersion ));

   821     paramIndex = stmt.ParameterIndex( KThumbnailSqlParamImei );

   822     User::LeaveIfError( paramIndex );

   823     User::LeaveIfError( stmt.BindText( paramIndex, iImei ));  

   824     

   825     paramIndex = stmt.ParameterIndex( KThumbnailSqlParamMinor );

   826     User::LeaveIfError( paramIndex );

   827     User::LeaveIfError( stmt.BindInt( paramIndex, KMinor )); 

   828     

   829     paramIndex = stmt.ParameterIndex( KThumbnailSqlParamMajor );

   830     User::LeaveIfError( paramIndex );

   831     User::LeaveIfError( stmt.BindInt( paramIndex, KMajor )); 

   832     

   833     User::LeaveIfError( stmt.Exec());

   834     CleanupStack::PopAndDestroy( &stmt );  

   835     }

   836 

   837 // -----------------------------------------------------------------------------

   838 // UpdateImeiL()

   839 // -----------------------------------------------------------------------------

   840 //

   841 void CThumbnailStore::UpdateImeiL()

   842     {

   843     TN_DEBUG1( "CThumbnailStore::UpdateImeiL()" );

   844     OstTrace0( TRACE_FATAL, CTHUMBNAILSTORE_UPDATEIMEIL, "CThumbnailStore::UpdateImeiL" );

   845     RSqlStatement stmt;

   846     CleanupClosePushL( stmt );

   847             

   848     User::LeaveIfError( stmt.Prepare( iDatabase, KThumbnailUpdateIMEI ) );

   849     

   850     TInt paramIndex = stmt.ParameterIndex( KThumbnailSqlParamImei );

   851     User::LeaveIfError( paramIndex );

   852     User::LeaveIfError( stmt.BindText( paramIndex, iImei ));

   853     

   854     TInt err = stmt.Exec();

   855     

   856     if(err < 0)

   857         {

   858 #ifdef _DEBUG

   859         TPtrC errorMsg = iDatabase.LastErrorMessage();

   860         TN_DEBUG2( "RThumbnailTransaction::UpdateImeiL() lastError %S" , &errorMsg);

   861         OstTraceExt1( TRACE_FATAL, DUP1_CTHUMBNAILSTORE_UPDATEIMEIL, "CThumbnailStore::UpdateImeiL - lastError;errorMsg=%S", errorMsg );

   862 #endif

   863         User::Leave(err);

   864         }

   865     

   866     CleanupStack::PopAndDestroy( &stmt );

   867     }

   868 

   869 // ---------------------------------------------------------------------------

   870 // CThumbnailStore::PrepareStatementsL()

   871 // ---------------------------------------------------------------------------

   872 //

   873 void CThumbnailStore::PrepareStatementsL()

   874     {

   875     TN_DEBUG1("CThumbnailStore::PrepareStatementsL()");

   876     OstTrace0( TRACE_FATAL, CTHUMBNAILSTORE_PREPARESTATEMENTSL, "CThumbnailStore::PrepareStatementsL" );

   877     

   878     TInt err = KErrNone;  

   879 #ifdef _DEBUG

   880     TFileName msg;

   881 #endif

   882     

   883     err = iStmt_KThumbnailSelectInfoByPath.Prepare( iDatabase, KThumbnailSelectInfoByPath );

   884 #ifdef _DEBUG

   885     msg.Append( iDatabase.LastErrorMessage() );

   886     TN_DEBUG2( "CThumbnailStore::PrepareStatementsL() KThumbnailSelectInfoByPath %S" , &msg );

   887     OstTraceExt1( TRACE_FATAL, DUP1_CTHUMBNAILSTORE_PREPARESTATEMENTSL, "CThumbnailStore::PrepareStatementsL - KThumbnailSelectInfoByPath;msg=%S", msg );

   888     msg.Zero();

   889 #endif

   890     User::LeaveIfError( err );

   891     

   892     err = iStmt_KThumbnailSelectTempInfoByPath.Prepare( iDatabase, KThumbnailSelectTempInfoByPath );

   893 #ifdef _DEBUG

   894     msg.Append( iDatabase.LastErrorMessage() );

   895     TN_DEBUG2( "CThumbnailStore::PrepareStatementsL() KThumbnailSelectTempInfoByPath %S" , &msg );

   896     OstTraceExt1( TRACE_FATAL, DUP2_CTHUMBNAILSTORE_PREPARESTATEMENTSL, "CThumbnailStore::PrepareStatementsL - KThumbnailSelectTempInfoByPath;msg=%S", msg );

   897     msg.Zero();

   898 #endif

   899     User::LeaveIfError( err );

   900 

   901     err = iStmt_KThumbnailInsertTempThumbnailInfo.Prepare( iDatabase, KThumbnailInsertTempThumbnailInfo );

   902 #ifdef _DEBUG

   903     msg.Append( iDatabase.LastErrorMessage() );

   904     TN_DEBUG2( "CThumbnailStore::PrepareStatementsL() KThumbnailInsertTempThumbnailInfo %S" , &msg );

   905     OstTraceExt1( TRACE_FATAL, DUP3_CTHUMBNAILSTORE_PREPARESTATEMENTSL, "CThumbnailStore::PrepareStatementsL - KThumbnailInsertTempThumbnailInfo ;msg=%S", msg );

   906     msg.Zero();

   907 #endif

   908     User::LeaveIfError( err );

   909     

   910     err = iStmt_KThumbnailInsertTempThumbnailInfoData.Prepare( iDatabase, KThumbnailInsertTempThumbnailInfoData );

   911 #ifdef _DEBUG

   912     msg.Append( iDatabase.LastErrorMessage() );

   913     TN_DEBUG2( "CThumbnailStore::PrepareStatementsL() KThumbnailInsertTempThumbnailInfoData %S" , &msg );

   914     OstTraceExt1( TRACE_FATAL, DUP4_CTHUMBNAILSTORE_PREPARESTATEMENTSL, "CThumbnailStore::PrepareStatementsL - KThumbnailInsertTempThumbnailInfoData;msg=%S", msg );

   915     msg.Zero();

   916 #endif

   917     User::LeaveIfError( err );

   918     

   919     err = iStmt_KThumbnailSelectModifiedByPath.Prepare( iDatabase, KThumbnailSelectModifiedByPath );

   920 #ifdef _DEBUG

   921     msg.Append( iDatabase.LastErrorMessage() );

   922     TN_DEBUG2( "CThumbnailStore::PrepareStatementsL() KThumbnailSelectModifiedByPath %S" , &msg );

   923     OstTraceExt1( TRACE_FATAL, DUP5_CTHUMBNAILSTORE_PREPARESTATEMENTSL, "CThumbnailStore::PrepareStatementsL;msg=%S", msg );

   924     msg.Zero();

   925 #endif

   926     User::LeaveIfError( err );

   927     

   928     err = iStmt_KThumbnailSelectTempModifiedByPath.Prepare( iDatabase, KThumbnailSelectTempModifiedByPath );

   929 #ifdef _DEBUG

   930     msg.Append( iDatabase.LastErrorMessage() );

   931     TN_DEBUG2( "CThumbnailStore::PrepareStatementsL() KThumbnailSelectTempModifiedByPath %S" , &msg );

   932     OstTraceExt1( TRACE_FATAL, DUP6_CTHUMBNAILSTORE_PREPARESTATEMENTSL, "CThumbnailStore::PrepareStatementsL - KThumbnailSelectTempModifiedByPath;msg=%S", msg );

   933     msg.Zero();

   934 #endif

   935     User::LeaveIfError( err );

   936     

   937     err = iStmt_KThumbnailFindDuplicate.Prepare( iDatabase, KThumbnailFindDuplicate );

   938 #ifdef _DEBUG

   939     msg.Append( iDatabase.LastErrorMessage() );

   940     TN_DEBUG2( "CThumbnailStore::PrepareStatementsL() KThumbnailFindDuplicate %S" , &msg );

   941     OstTraceExt1( TRACE_FATAL, DUP7_CTHUMBNAILSTORE_PREPARESTATEMENTSL, "CThumbnailStore::PrepareStatementsL - KThumbnailFindDuplicate;msg=%S", msg );

   942     msg.Zero();

   943 #endif

   944     User::LeaveIfError( err );

   945     

   946     err = iStmt_KThumbnailTempFindDuplicate.Prepare( iDatabase, KThumbnailTempFindDuplicate );

   947 #ifdef _DEBUG

   948     msg.Append( iDatabase.LastErrorMessage() );

   949     TN_DEBUG2( "CThumbnailStore::PrepareStatementsL() KThumbnailTempFindDuplicate %S" , &msg );

   950     OstTraceExt1( TRACE_FATAL, DUP8_CTHUMBNAILSTORE_PREPARESTATEMENTSL, "CThumbnailStore::PrepareStatementsL - KThumbnailTempFindDuplicate;msg=%S", msg );

   951     msg.Zero();

   952 #endif

   953     User::LeaveIfError( err );

   954     

   955     err = iStmt_KThumbnailSqlFindDeleted.Prepare( iDatabase, KThumbnailSqlFindDeleted );

   956 #ifdef _DEBUG

   957     msg.Append( iDatabase.LastErrorMessage() );

   958     TN_DEBUG2( "CThumbnailStore::PrepareStatementsL() KThumbnailSqlFindDeleted %S" , &msg );

   959     OstTraceExt1( TRACE_FATAL, DUP9_CTHUMBNAILSTORE_PREPARESTATEMENTSL, "CThumbnailStore::PrepareStatementsL - KThumbnailSqlFindDeleted;msg=%S", msg );

   960     msg.Zero();

   961 #endif

   962     User::LeaveIfError( err );

   963     

   964     err = iStmt_KThumbnailSelectSizeByPath.Prepare( iDatabase, KThumbnailSelectSizeByPath );

   965 #ifdef _DEBUG

   966     msg.Append( iDatabase.LastErrorMessage() );

   967     TN_DEBUG2( "CThumbnailStore::PrepareStatementsL() KThumbnailSelectSizeByPath %S" , &msg );

   968     OstTraceExt1( TRACE_FATAL, DUP10_CTHUMBNAILSTORE_PREPARESTATEMENTSL, "CThumbnailStore::PrepareStatementsL - KThumbnailSelectSizeByPath;msg=%S", msg );

   969     msg.Zero();

   970 #endif

   971     User::LeaveIfError( err );

   972     

   973     err = iStmt_KThumbnailSelectTempSizeByPath.Prepare( iDatabase, KThumbnailSelectTempSizeByPath );

   974 #ifdef _DEBUG

   975     msg.Append( iDatabase.LastErrorMessage() );

   976     TN_DEBUG2( "CThumbnailStore::PrepareStatementsL() KThumbnailSelectTempSizeByPath %S" , &msg );

   977     OstTraceExt1( TRACE_FATAL, DUP11_CTHUMBNAILSTORE_PREPARESTATEMENTSL, "CThumbnailStore::PrepareStatementsL - KThumbnailSelectTempSizeByPath;msg=%S", msg );

   978     msg.Zero();

   979 #endif

   980     User::LeaveIfError( err );

   981     

   982     err = iStmt_KThumbnailSqlSelectRowIDInfoByPath.Prepare( iDatabase, KThumbnailSqlSelectRowIDInfoByPath );

   983 #ifdef _DEBUG

   984     msg.Append( iDatabase.LastErrorMessage() );

   985     TN_DEBUG2( "CThumbnailStore::PrepareStatementsL() KThumbnailSqlSelectRowIDInfoByPath %S" , &msg );

   986     OstTraceExt1( TRACE_FATAL, DUP12_CTHUMBNAILSTORE_PREPARESTATEMENTSL, "CThumbnailStore::PrepareStatementsL - KThumbnailSqlSelectRowIDInfoByPath;msg=%S", msg );

   987     msg.Zero();

   988 #endif

   989     User::LeaveIfError( err );

   990     

   991     err = iStmt_KThumbnailSqlDeleteInfoByPath.Prepare( iDatabase, KThumbnailSqlDeleteInfoByPath );

   992 #ifdef _DEBUG

   993     msg.Append( iDatabase.LastErrorMessage() );

   994     TN_DEBUG2( "CThumbnailStore::PrepareStatementsL() KThumbnailSqlDeleteInfoByPath %S" , &msg );

   995     OstTraceExt1( TRACE_FATAL, DUP13_CTHUMBNAILSTORE_PREPARESTATEMENTSL, "CThumbnailStore::PrepareStatementsL - KThumbnailSqlDeleteInfoByPath;msg=%S", msg );

   996     msg.Zero();

   997 #endif

   998     User::LeaveIfError( err );

   999 

  1000     err = iStmt_KThumbnailSqlDeleteInfoDataByPath.Prepare( iDatabase, KThumbnailSqlDeleteInfoDataByPath );

  1001 #ifdef _DEBUG

  1002     msg.Append( iDatabase.LastErrorMessage() );

  1003     TN_DEBUG2( "CThumbnailStore::PrepareStatementsL() KThumbnailSqlDeleteInfoDataByPath %S" , &msg );

  1004     OstTraceExt1( TRACE_FATAL, DUP14_CTHUMBNAILSTORE_PREPARESTATEMENTSL, "CThumbnailStore::PrepareStatementsL - KThumbnailSqlDeleteInfoDataByPath;msg=%S", msg );

  1005     msg.Zero();

  1006 #endif

  1007     User::LeaveIfError( err );

  1008 

  1009     err = iStmt_KTempThumbnailSqlSelectRowIDInfoByPath.Prepare( iDatabase, KTempThumbnailSqlSelectRowIDInfoByPath );

  1010 #ifdef _DEBUG

  1011     msg.Append( iDatabase.LastErrorMessage() );

  1012     TN_DEBUG2( "CThumbnailStore::PrepareStatementsL() KTempThumbnailSqlSelectRowIDInfoByPath %S" , &msg );

  1013     OstTraceExt1( TRACE_FATAL, DUP15_CTHUMBNAILSTORE_PREPARESTATEMENTSL, "CThumbnailStore::PrepareStatementsL - KTempThumbnailSqlSelectRowIDInfoByPath;msg=%S", msg );

  1014     msg.Zero();

  1015 #endif

  1016     User::LeaveIfError( err );

  1017 

  1018     err = iStmt_KTempThumbnailSqlDeleteInfoByPath.Prepare( iDatabase, KTempThumbnailSqlDeleteInfoByPath );

  1019 #ifdef _DEBUG

  1020     msg.Append( iDatabase.LastErrorMessage() );

  1021     TN_DEBUG2( "CThumbnailStore::PrepareStatementsL() KTempThumbnailSqlDeleteInfoByPath %S" , &msg );

  1022     OstTraceExt1( TRACE_FATAL, DUP16_CTHUMBNAILSTORE_PREPARESTATEMENTSL, "CThumbnailStore::PrepareStatementsL - KTempThumbnailSqlDeleteInfoByPath;msg=%S", msg );

  1023     msg.Zero();

  1024 #endif

  1025     User::LeaveIfError( err );

  1026 

  1027     err = iStmt_KTempThumbnailSqlDeleteInfoDataByPath.Prepare( iDatabase, KTempThumbnailSqlDeleteInfoDataByPath );

  1028 #ifdef _DEBUG

  1029     msg.Append( iDatabase.LastErrorMessage() );

  1030     TN_DEBUG2( "CThumbnailStore::PrepareStatementsL() KTempThumbnailSqlDeleteInfoDataByPath %S" , &msg );

  1031     OstTraceExt1( TRACE_FATAL, DUP17_CTHUMBNAILSTORE_PREPARESTATEMENTSL, "CThumbnailStore::PrepareStatementsL - KTempThumbnailSqlDeleteInfoDataByPath;msg=%S", msg );

  1032     msg.Zero();

  1033 #endif

  1034     User::LeaveIfError( err );

  1035 

  1036     err = iStmt_KThumbnailSqlInsertDeleted.Prepare( iDatabase, KThumbnailSqlInsertDeleted );

  1037 #ifdef _DEBUG

  1038     msg.Append( iDatabase.LastErrorMessage() );

  1039     TN_DEBUG2( "CThumbnailStore::PrepareStatementsL() KThumbnailSqlInsertDeleted %S" , &msg );

  1040     OstTraceExt1( TRACE_FATAL, DUP18_CTHUMBNAILSTORE_PREPARESTATEMENTSL, "CThumbnailStore::PrepareStatementsL - KThumbnailSqlInsertDeleted;msg=%S", msg );

  1041     msg.Zero();

  1042 #endif

  1043     User::LeaveIfError( err );

  1044     

  1045     err = iStmt_KThumbnailSqlSelectMarked.Prepare( iDatabase, KThumbnailSqlSelectMarked );

  1046 #ifdef _DEBUG

  1047     msg.Append( iDatabase.LastErrorMessage() );

  1048     TN_DEBUG2( "CThumbnailStore::PrepareStatementsL() KThumbnailSqlSelectMarked %S" , &msg );

  1049     OstTraceExt1( TRACE_NORMAL, DUP19_CTHUMBNAILSTORE_PREPARESTATEMENTSL, "CThumbnailStore::PrepareStatementsL - KThumbnailSqlSelectMarked;msg=%S", msg );

  1050     msg.Zero();

  1051 #endif

  1052     User::LeaveIfError( err );

  1053 

  1054     err = iStmt_KThumbnailSqlDeleteInfoByRowID.Prepare( iDatabase, KThumbnailSqlDeleteInfoByRowID );

  1055 #ifdef _DEBUG

  1056     msg.Append( iDatabase.LastErrorMessage() );

  1057     TN_DEBUG2( "CThumbnailStore::PrepareStatementsL() KThumbnailSqlDeleteInfoByRowID %S" , &msg );

  1058     OstTraceExt1( TRACE_NORMAL, DUP20_CTHUMBNAILSTORE_PREPARESTATEMENTSL, "CThumbnailStore::PrepareStatementsL - KThumbnailSqlDeleteInfoByRowID;msg=%S", msg );

  1059     msg.Zero();

  1060 #endif

  1061     User::LeaveIfError( err );

  1062 

  1063     err = iStmt_KThumbnailSqlDeleteInfoDataByRowID.Prepare( iDatabase, KThumbnailSqlDeleteInfoDataByRowID );

  1064 #ifdef _DEBUG

  1065     msg.Append( iDatabase.LastErrorMessage() );

  1066     TN_DEBUG2( "CThumbnailStore::PrepareStatementsL() KThumbnailSqlDeleteInfoDataByRowID %S" , &msg );

  1067     OstTraceExt1( TRACE_NORMAL, DUP21_CTHUMBNAILSTORE_PREPARESTATEMENTSL, "CThumbnailStore::PrepareStatementsL - KThumbnailSqlDeleteInfoDataByRowID;msg=%S", msg );

  1068     msg.Zero();

  1069 #endif

  1070     User::LeaveIfError( err );

  1071     

  1072     err = iStmt_KThumbnailSelectAllPaths.Prepare( iDatabase, KThumbnailSelectAllPaths );

  1073 #ifdef _DEBUG

  1074     msg.Append( iDatabase.LastErrorMessage() );

  1075     TN_DEBUG2( "CThumbnailStore::PrepareStatementsL() KThumbnailSelectAllPaths %S" , &msg );

  1076     OstTraceExt1( TRACE_NORMAL, DUP22_CTHUMBNAILSTORE_PREPARESTATEMENTSL, "CThumbnailStore::PrepareStatementsL - KThumbnailSelectAllPaths;msg=%S", msg );

  1077     msg.Zero();

  1078 #endif

  1079     User::LeaveIfError( err );

  1080     

  1081     err = iStmt_KThumbnailRename.Prepare( iDatabase, KThumbnailRename );

  1082 #ifdef _DEBUG

  1083     msg.Append( iDatabase.LastErrorMessage() );

  1084     TN_DEBUG2( "CThumbnailStore::PrepareStatementsL() KThumbnailRename %S" , &msg );

  1085     OstTraceExt1( TRACE_NORMAL, DUP23_CTHUMBNAILSTORE_PREPARESTATEMENTSL, "CThumbnailStore::PrepareStatementsL - KThumbnailRename;msg=%S", msg );

  1086     msg.Zero();

  1087 #endif

  1088     User::LeaveIfError( err );

  1089     

  1090     err = iStmt_KThumbnailTempRename.Prepare( iDatabase, KThumbnailTempRename );

  1091 #ifdef _DEBUG

  1092     msg.Append( iDatabase.LastErrorMessage() );

  1093     TN_DEBUG2( "CThumbnailStore::PrepareStatementsL() KThumbnailTempRename %S" , &msg );

  1094     OstTraceExt1( TRACE_NORMAL, DUP24_CTHUMBNAILSTORE_PREPARESTATEMENTSL, "CThumbnailStore::PrepareStatementsL - KThumbnailTempRename;msg=%S", msg );

  1095     msg.Zero();

  1096 #endif

  1097     User::LeaveIfError( err );

  1098     

  1099     TN_DEBUG1("CThumbnailStore::PrepareStatementsL() end");

  1100     OstTrace0( TRACE_NORMAL, DUP25_CTHUMBNAILSTORE_PREPARESTATEMENTSL, "CThumbnailStore::PrepareStatementsL - end" );

  1101     }

  1102 

  1103 // ---------------------------------------------------------------------------

  1104 // CThumbnailStore::ResetStatement()

  1105 // ---------------------------------------------------------------------------

  1106 //

  1107 void CThumbnailStore::ResetStatement( TAny* aStmt )

  1108     {

  1109     // called by CleanupStack::PopAndDestroy()

  1110     // just reset so that there's no need to prepare again

  1111     ((RSqlStatement*)aStmt)->Reset();

  1112     }

  1113 

  1114 // ---------------------------------------------------------------------------

  1115 // CThumbnailStore::CloseStatements()

  1116 // ---------------------------------------------------------------------------

  1117 //

  1118 void CThumbnailStore::CloseStatements()

  1119     {

  1120     TN_DEBUG1("CThumbnailStore::CloseStatements()");

  1121     OstTrace0( TRACE_NORMAL, CTHUMBNAILSTORE_CLOSESTATEMENTS, "CThumbnailStore::CloseStatements" );

  1122     

  1123     iStmt_KThumbnailSelectInfoByPath.Close();

  1124     iStmt_KThumbnailSelectTempInfoByPath.Close();   

  1125     iStmt_KThumbnailInsertTempThumbnailInfo.Close();

  1126     iStmt_KThumbnailInsertTempThumbnailInfoData.Close();  

  1127     iStmt_KThumbnailSelectModifiedByPath.Close();

  1128     iStmt_KThumbnailSelectTempModifiedByPath.Close();

  1129     iStmt_KThumbnailFindDuplicate.Close();

  1130     iStmt_KThumbnailTempFindDuplicate.Close();

  1131     iStmt_KThumbnailSqlFindDeleted.Close();

  1132     iStmt_KThumbnailSelectSizeByPath.Close();

  1133     iStmt_KThumbnailSelectTempSizeByPath.Close();

  1134     iStmt_KThumbnailSqlSelectRowIDInfoByPath.Close();

  1135     iStmt_KThumbnailSqlDeleteInfoByPath.Close();