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 

    26 #include <iclextjpegapi.h>

    27 #include "thumbnailstore.h"

    28 #include "thumbnailsql.h"

    29 #include "thumbnaillog.h"

    30 #include "thumbnailmanageruids.hrh"

    31 #include "thumbnailcenrep.h"

    32 #include "thumbnailpanic.h"

    33 #include "thumbnailmanagerconstants.h"

    34 #include "thumbnailserver.h"

    35 

    36 

    37 

    38 _LIT8( KThumbnailSqlConfig, "page_size=16384; cache_size=32;" );

    39 

    40 const TInt KStreamBufferSize = 1024 * 8;

    41 const TInt KMajor = 3;

    42 const TInt KMinor = 2;

    43 

    44 // Database path without drive letter

    45 _LIT( KThumbnailDatabaseName, ":[102830AB]thumbnail_v2.db" );

    46 

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

    48 const TSecurityPolicy KThumbnailDatabaseSecurityPolicy( TSecureId(

    49     THUMBNAIL_MANAGER_SERVER_UID ));

    50 

    51 

    52 // ---------------------------------------------------------------------------

    53 // RThumbnailTransaction::RThumbnailTransaction::TThumbnailPersistentSize

    54 // ---------------------------------------------------------------------------

    55 //

    56 RThumbnailTransaction::RThumbnailTransaction( RSqlDatabase& aDatabase ):

    57     iDatabase( aDatabase ), iState( EClosed )

    58     {

    59     // No implementation required

    60     }

    61 

    62 

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

    64 // RThumbnailTransaction::BeginL()

    65 // ---------------------------------------------------------------------------

    66 //

    67 void RThumbnailTransaction::BeginL()

    68     {

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

    70     if ( err >= 0 )

    71         {

    72         iState = EOpen;

    73         }

    74     else

    75         {

    76         iState = EError;

    77         User::Leave( err );

    78         }

    79     }

    80 

    81 

    82 // ---------------------------------------------------------------------------

    83 // RThumbnailTransaction::Close()

    84 // ---------------------------------------------------------------------------

    85 //

    86 void RThumbnailTransaction::Close()

    87     {

    88     if ( iState != EClosed )

    89         {

    90         Rollback();

    91         }

    92     }

    93 

    94 

    95 // ---------------------------------------------------------------------------

    96 // RThumbnailTransaction::CommitL()

    97 // ---------------------------------------------------------------------------

    98 //

    99 void RThumbnailTransaction::CommitL()

   100     {

   101     User::LeaveIfError( iDatabase.Exec( KThumbnailCommitTransaction ));

   102     iState = EClosed;

   103     }

   104 

   105 

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

   107 // RThumbnailTransaction::Rollback()

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

   109 //

   110 TInt RThumbnailTransaction::Rollback()

   111     {

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

   113     if ( err >= 0 )

   114         {

   115         iState = EClosed;

   116         }

   117     return err;

   118     }

   119 

   120 // ======== MEMBER FUNCTIONS ========

   121 

   122 // ---------------------------------------------------------------------------

   123 // CThumbnailStore::NewL()

   124 // Two-phased constructor.

   125 // ---------------------------------------------------------------------------

   126 //

   127 CThumbnailStore* CThumbnailStore::NewL( RFs& aFs, TInt aDrive, TDesC& aImei, CThumbnailServer* aServer )

   128     {

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

   130     CleanupStack::PushL( self );

   131     self->ConstructL();

   132     CleanupStack::Pop( self );

   133     return self;

   134     }

   135 

   136 

   137 // ---------------------------------------------------------------------------

   138 // CThumbnailStore::~CThumbnailStore()

   139 // Destructor.

   140 // ---------------------------------------------------------------------------

   141 //

   142 CThumbnailStore::~CThumbnailStore()

   143     {

   144     TN_DEBUG1( "CThumbnailStore::~CThumbnailStore()" );

   145 

   146     if(!iServer->IsFormatting())

   147         {

   148  	    FlushCacheTable( ETrue );

   149         }

   150     if( iAutoFlushTimer )

   151         {

   152         iAutoFlushTimer->Cancel();

   153         delete iAutoFlushTimer;

   154         iAutoFlushTimer = NULL;

   155         }

   156     

   157     iDatabase.Close();

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

   159     }

   160 

   161 

   162 // ---------------------------------------------------------------------------

   163 // CThumbnailStore::CThumbnailStore()

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

   165 // ---------------------------------------------------------------------------

   166 //

   167 CThumbnailStore::CThumbnailStore( RFs& aFs, TInt aDrive, TDesC& aImei,  CThumbnailServer* aServer ): 

   168     iFs( aFs ), iDrive( aDrive ), iBatchItemCount(0), iImei(aImei), iServer(aServer)

   169     {

   170     // no implementation required

   171     }

   172 

   173 

   174 // ---------------------------------------------------------------------------

   175 // CThumbnailStore::ConstructL()

   176 // Symbian 2nd phase constructor can leave.

   177 // ---------------------------------------------------------------------------

   178 //

   179 void CThumbnailStore::ConstructL()

   180     {

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

   182 

   183 #ifdef _DEBUG

   184     iThumbCounter = 0;

   185 #endif

   186     

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

   188     TPtr pathPtr = databasePath->Des();

   189     TChar driveChar = 0;

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

   191     pathPtr.Append( driveChar );

   192     pathPtr.Append( KThumbnailDatabaseName );

   193 

   194     TVolumeInfo volumeinfo;

   195     iFs.Volume(volumeinfo, iDrive);

   196     TUint id = volumeinfo.iUniqueID;

   197     TBuf<50> mediaid;

   198     mediaid.Num(id);

   199     TBool newDatabase(EFalse);

   200     

   201     TInt error = KErrNone;

   202     

   203     TInt err = iDatabase.Open( pathPtr );

   204     if ( err == KErrNotFound )

   205         {

   206         // db not found, create new

   207         TN_DEBUG1( "CThumbnailStore::ConstructL() -- 1 creating database" );

   208         const TDesC8& config = KThumbnailSqlConfig;

   209 

   210         RSqlSecurityPolicy securityPolicy;

   211         CleanupClosePushL( securityPolicy );

   212         securityPolicy.Create( KThumbnailDatabaseSecurityPolicy );

   213 

   214         iDatabase.CreateL( pathPtr, securityPolicy, &config );

   215         CleanupStack::PopAndDestroy( &securityPolicy );

   216 

   217         TN_DEBUG1( "CThumbnailStore::ConstructL() -- 1 database created ok" );

   218                 

   219         RFile64 file;

   220         file.Create(iFs, mediaid, EFileShareReadersOrWriters );

   221         file.Close();

   222         newDatabase = ETrue;

   223         }

   224     else if ( err == KErrNone)

   225         {

   226         // db found, check version and rowids

   227         error = CheckVersionL();

   228         if(error == KErrNone)

   229             {

   230             error = CheckRowIDsL();

   231             }

   232         

   233         }

   234     

   235     // if wrong version, corrupted database or other error opening db

   236     if ( error == KErrNotSupported || (err != KErrNone && err != KErrNotFound) )

   237         {

   238         TN_DEBUG1( "CThumbnailStore::ConstructL() -- delete databases" );

   239         

   240         // delete db and create new

   241         iDatabase.Close();

   242         iDatabase.Delete(pathPtr);

   243         

   244         TN_DEBUG1( "CThumbnailStore::ConstructL() -- 2 creating database" );

   245         

   246         const TDesC8& config = KThumbnailSqlConfig;

   247 

   248         RSqlSecurityPolicy securityPolicy;

   249         CleanupClosePushL( securityPolicy );

   250         securityPolicy.Create( KThumbnailDatabaseSecurityPolicy );

   251 

   252         iDatabase.CreateL( pathPtr, securityPolicy, &config );

   253         CleanupStack::PopAndDestroy( &securityPolicy );

   254 

   255         TN_DEBUG1( "CThumbnailStore::ConstructL() -- 2 database created ok" );

   256         

   257         RFile64 file;

   258         file.Create(iFs, mediaid, EFileShareReadersOrWriters );

   259         file.Close();

   260         }

   261     else if(!newDatabase)

   262         {

   263         //check ownership

   264         if(CheckImeiL() != KErrNone)

   265             {

   266             ResetThumbnailIDs();

   267             

   268             //take ownership

   269             UpdateImeiL();

   270             

   271             //Remove blacklist markings

   272             TRAP_IGNORE( RemoveDbFlagL( KThumbnailDbFlagBlacklisted ) );

   273             }

   274         

   275         //check is MMC known

   276         if(CheckMediaIDL() != KErrNone )

   277             {

   278             ResetThumbnailIDs();

   279             

   280             //Remove blacklist markings

   281             TRAP_IGNORE( RemoveDbFlagL( KThumbnailDbFlagBlacklisted ) );

   282             }

   283         }

   284               

   285     CleanupStack::PopAndDestroy( databasePath );

   286     

   287     // add tables

   288     TRAPD(tableError, CreateTablesL() );

   289     

   290     if(!tableError)

   291         {

   292         AddVersionAndImeiL();

   293         }

   294     

   295     err = iDatabase.Exec( KThumbnailCreateTempInfoTable );

   296     TN_DEBUG2("CThumbnailStore::CreateTablesL() KThumbnailCreateTempInfoTable %d", err);

   297     User::LeaveIfError( err );

   298     err = iDatabase.Exec( KThumbnailCreateTempInfoDataTable );

   299     TN_DEBUG2("CThumbnailStore::CreateTablesL() KThumbnailCreateTempInfoDataTable %d", err);

   300     User::LeaveIfError( err );

   301     }

   302 

   303 

   304 // ---------------------------------------------------------------------------

   305 // CThumbnailStore::StoreThumbnailL()

   306 // Stores thumbnail image.

   307 // ---------------------------------------------------------------------------

   308 //

   309 void CThumbnailStore::StoreThumbnailL( const TDesC& aPath, const TDes8& aData,

   310     const TSize& aSize, const TSize& aOriginalSize, const TThumbnailFormat& aFormat, TInt aFlags, 

   311 	const TThumbnailSize& aThumbnailSize, TThumbnailId aThumbnailId, const TBool aThumbFromPath )

   312     {

   313     TN_DEBUG1( "CThumbnailStore::StoreThumbnailL( const TDes8& ) in" );

   314 

   315 #ifdef _DEBUG

   316     TTime aStart, aStop;

   317     aStart.UniversalTime();

   318 #endif

   319 

   320     //Encapsulate insert to Transaction

   321     RThumbnailTransaction transaction( iDatabase );

   322     CleanupClosePushL( transaction );

   323     transaction.BeginL();

   324     

   325     RSqlStatement stmt;

   326     CleanupClosePushL( stmt );

   327     // Insert into ThumbnailInfo

   328     User::LeaveIfError( stmt.Prepare( iDatabase, KThumbnailInsertThumbnailInfoByPathAndId ));

   329 

   330     TInt paramIndex = stmt.ParameterIndex( KThumbnailSqlParamPath );

   331     User::LeaveIfError( paramIndex );

   332     User::LeaveIfError( stmt.BindText( paramIndex, aPath ));

   333 

   334     paramIndex = stmt.ParameterIndex( KThumbnailSqlParamWidth );

   335     User::LeaveIfError( paramIndex );

   336     User::LeaveIfError( stmt.BindInt( paramIndex, aSize.iWidth ));

   337 

   338     paramIndex = stmt.ParameterIndex( KThumbnailSqlParamHeight );

   339     User::LeaveIfError( paramIndex );

   340     User::LeaveIfError( stmt.BindInt( paramIndex, aSize.iHeight ));

   341 

   342     paramIndex = stmt.ParameterIndex( KThumbnailSqlParamOriginalWidth );

   343     User::LeaveIfError( paramIndex );

   344     User::LeaveIfError( stmt.BindInt( paramIndex, aOriginalSize.iWidth ));

   345 

   346     paramIndex = stmt.ParameterIndex( KThumbnailSqlParamOriginalHeight );

   347     User::LeaveIfError( paramIndex );

   348     User::LeaveIfError( stmt.BindInt( paramIndex, aOriginalSize.iHeight ));

   349 

   350     paramIndex = stmt.ParameterIndex( KThumbnailSqlParamFormat );

   351     User::LeaveIfError( paramIndex );

   352     User::LeaveIfError( stmt.BindInt( paramIndex, aFormat ));

   353 

   354     paramIndex = stmt.ParameterIndex( KThumbnailSqlParamFlags );

   355     User::LeaveIfError( paramIndex );

   356     User::LeaveIfError( stmt.BindInt( paramIndex, aFlags ));

   357 

   358     paramIndex = stmt.ParameterIndex( KThumbnailSqlParamSize );

   359     User::LeaveIfError( paramIndex );

   360     User::LeaveIfError( stmt.BindInt( paramIndex, aThumbnailSize ));

   361     

   362     if( aThumbnailId > 0 )

   363         {

   364         paramIndex = stmt.ParameterIndex( KThumbnailSqlParamId );

   365         User::LeaveIfError( paramIndex );

   366         User::LeaveIfError( stmt.BindInt( paramIndex, aThumbnailId ));

   367         }

   368     else

   369         {

   370         TN_DEBUG1( "CThumbnailStore::StoreThumbnailL( ) aThumbnailId == 0" );

   371         }

   372     

   373     // orientation temporarily to 0

   374     paramIndex = stmt.ParameterIndex( KThumbnailSqlParamOrientation );

   375     User::LeaveIfError( paramIndex );

   376     User::LeaveIfError( stmt.BindInt( paramIndex, 0 ));

   377     

   378     // thumb from associated path

   379     TInt fromPath = aThumbFromPath;

   380     paramIndex = stmt.ParameterIndex( KThumbnailSqlParamThumbFromPath );

   381     User::LeaveIfError( paramIndex );

   382     User::LeaveIfError( stmt.BindInt( paramIndex, fromPath ));

   383     

   384     // try getting modification time from file

   385     TTime timeStamp;

   386     

   387     if (aPath.Length())

   388         {

   389         iFs.Modified(aPath, timeStamp);

   390         }

   391     else

   392         {

   393         // otherwise current time

   394         timeStamp.UniversalTime();

   395         }

   396     

   397     paramIndex = stmt.ParameterIndex( KThumbnailSqlParamModified );

   398     User::LeaveIfError( paramIndex );

   399     User::LeaveIfError( stmt.BindInt64( paramIndex, timeStamp.Int64() ));

   400     

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

   402     CleanupStack::PopAndDestroy( &stmt );

   403     

   404     RSqlStatement stmtData;

   405     CleanupClosePushL( stmtData );

   406     // Insert into ThumbnailInfoData

   407     TInt err = stmtData.Prepare( iDatabase, KThumbnailInsertTempThumbnailInfoData );

   408        

   409 #ifdef _DEBUG

   410     TPtrC errorMsg = iDatabase.LastErrorMessage();

   411     TN_DEBUG2( "CThumbnailStore::FetchThumbnailL() KThumbnailInsertTempThumbnailInfoData %S" , &errorMsg);

   412 #endif    

   413     User::LeaveIfError( err );

   414     

   415     paramIndex = stmtData.ParameterIndex( KThumbnailSqlParamData );

   416     User::LeaveIfError( paramIndex );

   417     User::LeaveIfError( stmtData.BindBinary( paramIndex, aData ));

   418 

   419     User::LeaveIfError( stmtData.Exec());

   420     CleanupStack::PopAndDestroy( &stmtData );

   421 	

   422     // Commit transaction

   423     transaction.CommitL();

   424     CleanupStack::PopAndDestroy( &transaction );

   425 

   426     iBatchItemCount++;

   427     

   428     FlushCacheTable();

   429 

   430 #ifdef _DEBUG

   431     iThumbCounter++;

   432     TN_DEBUG2( "CThumbnailStore::THUMBSTORE-COUNTER----------, Thumbs = %d", iThumbCounter );

   433     

   434     aStop.UniversalTime();

   435     TN_DEBUG2( "CThumbnailStore::StoreThumbnailL() insert to table %d ms", (TInt)aStop.MicroSecondsFrom(aStart).Int64()/1000);

   436 #endif 

   437     TN_DEBUG1( "CThumbnailStore::StoreThumbnailL( const TDes8& ) out" );

   438     }

   439 

   440 

   441 // ---------------------------------------------------------------------------

   442 // CThumbnailStore::StoreThumbnailL()

   443 // Stores thumbnail image.

   444 // ---------------------------------------------------------------------------

   445 //

   446 void CThumbnailStore::StoreThumbnailL( const TDesC& aPath, CFbsBitmap*

   447     aThumbnail, const TSize& aOriginalSize, TBool /*aCropped*/, const TThumbnailSize aThumbnailSize, 

   448     const TThumbnailId aThumbnailId, const TBool aThumbFromPath, TBool aBlackListed )

   449     {

   450     TN_DEBUG1( "CThumbnailStore::StoreThumbnailL( CFbsBitmap* ) in" );

   451 

   452     __ASSERT_DEBUG(( aThumbnail ), ThumbnailPanic( EThumbnailNullPointer ));

   453 

   454     // check for duplicates

   455     TBool exists = FindDuplicateL(aPath, aThumbnailId, aThumbnailSize);

   456     

   457     TSize thumbSize = aThumbnail->SizeInPixels();

   458     for ( TInt i = iPersistentSizes.Count(); --i >= 0; )

   459         {

   460         TThumbnailPersistentSize & persistentSize = iPersistentSizes[i];

   461         

   462         // don't store duplicates or custom sizes

   463         if ( !exists && (aThumbnailSize != ECustomThumbnailSize && 

   464                          thumbSize.iWidth > 0 && thumbSize.iHeight > 0 ))

   465             {

   466             TInt flags = 0;

   467             if ( persistentSize.iCrop )

   468                 {

   469                 flags |= KThumbnailDbFlagCropped;

   470                 }

   471             

   472             if( aBlackListed )

   473                 {

   474                 flags |= KThumbnailDbFlagBlacklisted;

   475                 }

   476             

   477             if( (aThumbnailSize == EImageFullScreenThumbnailSize || aThumbnailSize == EVideoFullScreenThumbnailSize ||

   478                  aThumbnailSize == EAudioFullScreenThumbnailSize) && !aBlackListed )

   479                 {

   480                 HBufC8* data = NULL;

   481                 CImageEncoder* iEncoder = CImageEncoder::DataNewL( data,  KJpegMime(), CImageEncoder::EOptionAlwaysThread );

   482                 TJpegImageData* imageData = new (ELeave) TJpegImageData();

   483              

   484                 // Set some format specific data

   485                 imageData->iSampleScheme = TJpegImageData::EColor444;

   486                 imageData->iQualityFactor = 75; //?

   487              

   488                 CFrameImageData* iFrameImageData = CFrameImageData::NewL();

   489              

   490                 // frameData - ownership passed to iFrameImageData after AppendImageData

   491                 User::LeaveIfError(iFrameImageData->AppendImageData(imageData));

   492                 

   493 #ifdef _DEBUG

   494         TN_DEBUG4( "CThumbnailStore::StoreThumbnailL() size %d x %d displaymode %d ", 

   495                 aThumbnail->SizeInPixels().iWidth, 

   496                 aThumbnail->SizeInPixels().iHeight, 

   497                 aThumbnail->DisplayMode());

   498 #endif

   499                 

   500                 TRequestStatus request;

   501                 iEncoder->Convert( &request, *aThumbnail, iFrameImageData);

   502                 User::WaitForRequest( request);

   503                   

   504                 if(request== KErrNone)

   505                   {

   506                   TPtr8 ptr  = data->Des(); 

   507                   StoreThumbnailL( aPath, ptr, aThumbnail->SizeInPixels(), aOriginalSize,

   508                           EThumbnailFormatJpeg, flags, aThumbnailSize, aThumbnailId, aThumbFromPath  );

   509                   }

   510              

   511                 delete iFrameImageData;

   512                 iFrameImageData = NULL;          

   513                 

   514                 delete iEncoder;

   515                 iEncoder = NULL;    

   516                 delete data;

   517                 data = NULL;                

   518                 }

   519             else

   520                 {

   521                 CBufFlat* buf = CBufFlat::NewL( KStreamBufferSize );

   522                 CleanupStack::PushL( buf );

   523                 RBufWriteStream stream;

   524                 stream.Open( *buf );

   525                 aThumbnail->ExternalizeL( stream );

   526             

   527                 StoreThumbnailL( aPath, buf->Ptr( 0 ), aThumbnail->SizeInPixels(),

   528                     aOriginalSize, EThumbnailFormatFbsBitmap, flags, aThumbnailSize, aThumbnailId );

   529   

   530                 CleanupStack::PopAndDestroy( buf );

   531                 }

   532             

   533             break;

   534             }

   535         }

   536     

   537     TN_DEBUG1( "CThumbnailStore::StoreThumbnailL( CFbsBitmap* ) out" );

   538     }

   539 

   540 

   541 // ---------------------------------------------------------------------------

   542 // Finds possible existing duplicate thumbnail.

   543 // ---------------------------------------------------------------------------

   544 //

   545 TBool CThumbnailStore::FindDuplicateL( const TDesC& aPath, const TThumbnailId aThumbnailId,

   546                                        const TThumbnailSize& aThumbnailSize )

   547     {

   548     TN_DEBUG1( "CThumbnailStore::FindDuplicateL()" );

   549     

   550     TInt rowStatus = 0;

   551     TInt paramIndex = 0;

   552     TInt found = EFalse;

   553     

   554     RSqlStatement stmt;

   555     CleanupClosePushL( stmt );     

   556     

   557     User::LeaveIfError( stmt.Prepare( iDatabase, KTempFindDuplicate ));

   558     paramIndex = stmt.ParameterIndex( KThumbnailSqlParamPath );

   559     User::LeaveIfError( paramIndex );

   560     User::LeaveIfError( stmt.BindText( paramIndex, aPath ));

   561         

   562     paramIndex = stmt.ParameterIndex( KThumbnailSqlParamId );

   563     User::LeaveIfError( paramIndex );

   564     User::LeaveIfError( stmt.BindInt( paramIndex, aThumbnailId ));

   565     

   566     paramIndex = stmt.ParameterIndex( KThumbnailSqlParamSize );

   567     User::LeaveIfError( paramIndex );

   568     User::LeaveIfError( stmt.BindInt( paramIndex, aThumbnailSize ));

   569     

   570     rowStatus = stmt.Next();

   571     

   572     //if not found from temp table, look from real table

   573     if(rowStatus != KSqlAtRow)

   574         {

   575         stmt.Close();

   576         CleanupStack::PopAndDestroy( &stmt );

   577         CleanupClosePushL( stmt );

   578            

   579         User::LeaveIfError( stmt.Prepare( iDatabase, KFindDuplicate ));

   580         paramIndex = stmt.ParameterIndex( KThumbnailSqlParamPath );

   581         User::LeaveIfError( paramIndex );

   582         User::LeaveIfError( stmt.BindText( paramIndex, aPath ));

   583             

   584         paramIndex = stmt.ParameterIndex( KThumbnailSqlParamId );

   585         User::LeaveIfError( paramIndex );

   586         User::LeaveIfError( stmt.BindInt( paramIndex, aThumbnailId ));

   587         

   588         paramIndex = stmt.ParameterIndex( KThumbnailSqlParamSize );

   589         User::LeaveIfError( paramIndex );

   590         User::LeaveIfError( stmt.BindInt( paramIndex, aThumbnailSize ));

   591         

   592         rowStatus = stmt.Next();

   593         

   594         if(rowStatus == KSqlAtRow)

   595             {

   596             TN_DEBUG1( "CThumbnailStore::FindDuplicateL() - duplicate in main table" );

   597             

   598             found = ETrue;

   599             }

   600         else

   601             {

   602             TN_DEBUG1( "CThumbnailStore::FindDuplicateL() - no duplicate" );

   603             }

   604         }

   605     else

   606         {

   607         TN_DEBUG1( "CThumbnailStore::FindDuplicateL() - duplicate in temp table" );

   608         

   609         found = ETrue;

   610         }

   611     

   612     stmt.Close();

   613     CleanupStack::PopAndDestroy( &stmt );

   614     

   615     return found;

   616     }

   617 

   618 

   619 // ---------------------------------------------------------------------------

   620 // Create database tables

   621 // ---------------------------------------------------------------------------

   622 //

   623 void CThumbnailStore::CreateTablesL()

   624     {

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

   626     TInt err = 0;

   627     err = iDatabase.Exec( KThumbnailCreateInfoTable );

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

   629     err = iDatabase.Exec( KThumbnailCreateInfoDataTable );

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

   631     err = iDatabase.Exec( KThumbnailCreateInfoTableIndex1 );

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

   633     err = iDatabase.Exec( KThumbnailCreateInfoTableIndex2 );

   634     TN_DEBUG2( "CThumbnailStore::CreateTablesL() KThumbnailCreateInfoTableIndex2 err=%d", err );

   635     err = iDatabase.Exec(KThumbnailVersionTable);

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

   637     User::LeaveIfError( err );

   638     }

   639 

   640 

   641 // ---------------------------------------------------------------------------

   642 // Get missing sizes by Path

   643 // ---------------------------------------------------------------------------

   644 //     

   645 void CThumbnailStore::GetMissingSizesAndIDsL( const TDesC& aPath, TInt aSourceType, RArray <

   646     TThumbnailPersistentSize > & aMissingSizes, TBool& aMissingIDs )

   647     {

   648     TN_DEBUG2( "CThumbnailStore::GetMissingSizesAndIDsL() aSourceType == %d", aSourceType );

   649     // define sizes to be checked

   650     const TInt count = iPersistentSizes.Count();

   651     

   652     for ( TInt i = 0 ; i < count; i++ )

   653         {

   654         if ( iPersistentSizes[ i ].iSourceType == aSourceType && iPersistentSizes[ i ].iAutoCreate)

   655             {

   656             aMissingSizes.Append( iPersistentSizes[ i ] );

   657             }

   658         }

   659     

   660     TInt missingSizeCount = aMissingSizes.Count();

   661     aMissingIDs = EFalse;

   662         

   663     TN_DEBUG3( "CThumbnailStore::GetMissingSizesAndIDsL() missingSizeCount == %d, missingIDs == %d", missingSizeCount, aMissingIDs );

   664     

   665     // check temp table first

   666     RSqlStatement stmt;

   667     CleanupClosePushL( stmt );

   668     User::LeaveIfError( stmt.Prepare( iDatabase, KThumbnailSelectTempSizeByPath ));

   669     TInt paramIndex = stmt.ParameterIndex( KThumbnailSqlParamPath );

   670     User::LeaveIfError( paramIndex );

   671     User::LeaveIfError( stmt.BindText( paramIndex, aPath ));

   672        

   673     TInt rowStatus = stmt.Next();

   674 

   675     TInt round = 1;

   676     TInt size = 0;

   677     TInt id = 0;

   678     

   679     while (round <= 2)

   680         {

   681         while ( rowStatus == KSqlAtRow && missingSizeCount > 0 )

   682             {

   683             size = stmt.ColumnInt( 0 );

   684             id = stmt.ColumnInt( 1 );

   685 			

   686 			TN_DEBUG2( "CThumbnailStore::GetMissingSizesAndIDsL() id == %d", id );

   687             

   688 			//if TNId is not valid mark that some are missing so that UpdateDb is run later

   689             if ( id <= 0)

   690                 {

   691                 TN_DEBUG1( "CThumbnailStore::GetMissingSizesAndIDsL() missing ID");

   692                 aMissingIDs = ETrue;

   693                 }

   694             

   695             missingSizeCount = aMissingSizes.Count();

   696             for ( TInt i = 0; i < missingSizeCount; i++ )

   697                 {

   698                 if ( aMissingSizes[ i ].iType == size )

   699                     {

   700                     TN_DEBUG1( "CThumbnailStore::GetMissingSizesL() -- thumbnail found" );

   701                     aMissingSizes.Remove( i );

   702                     missingSizeCount--;

   703                     break;

   704                     }

   705                 }

   706                 

   707             rowStatus = stmt.Next();

   708             }

   709         stmt.Close();

   710         CleanupStack::PopAndDestroy( &stmt );

   711         

   712         // all found

   713         if (missingSizeCount == 0)

   714             {

   715             return;

   716             }

   717         else if (round == 1)

   718             {

   719             // change to real table

   720             CleanupClosePushL( stmt );

   721             User::LeaveIfError( stmt.Prepare( iDatabase, KThumbnailSelectSizeByPath ));

   722             paramIndex = stmt.ParameterIndex( KThumbnailSqlParamPath );

   723             User::LeaveIfError( paramIndex );

   724             User::LeaveIfError( stmt.BindText( paramIndex, aPath ));

   725             rowStatus = stmt.Next();    

   726             }

   727         

   728         round++;

   729         }

   730     }

   731 

   732 

   733 // ---------------------------------------------------------------------------

   734 // CThumbnailStore::FetchThumbnailL()

   735 // Fetches thumbnail image.

   736 // ---------------------------------------------------------------------------

   737 //

   738 TInt CThumbnailStore::FetchThumbnailL( TThumbnailId aThumbnailId, 

   739         CFbsBitmap*& aThumbnail, TDesC8* & aData, TThumbnailSize aThumbnailSize, TSize &aThumbnailRealSize )

   740     {

   741     TN_DEBUG3( "CThumbnailStore::FetchThumbnailL(%d) aThumbnailSize == %d", aThumbnailId, aThumbnailSize );

   742      delete aThumbnail;

   743      aThumbnail = NULL;

   744 

   745      RSqlStatement stmt;

   746      CleanupClosePushL( stmt );

   747      

   748      TInt paramIndex = 0;

   749      TInt found = KErrNotFound;

   750      TInt rowStatus = 0;

   751      TInt column = 0;

   752      TInt count = 0;

   753      TThumbnailSize thumbnailImage = EUnknownThumbnailSize;

   754      TThumbnailSize thumbnailVideo = EUnknownThumbnailSize;

   755      TThumbnailSize thumbnailAudio = EUnknownThumbnailSize;

   756      TBool inTempTable( ETrue );

   757      

   758      if(aThumbnailSize == EFullScreenThumbnailSize)

   759          {

   760          thumbnailImage = EImageFullScreenThumbnailSize;

   761          thumbnailVideo = EVideoFullScreenThumbnailSize;

   762          thumbnailAudio = EAudioFullScreenThumbnailSize;

   763          }

   764      else if(aThumbnailSize == EGridThumbnailSize)

   765          {

   766          thumbnailImage = EImageGridThumbnailSize;

   767          thumbnailVideo = EVideoGridThumbnailSize;

   768          thumbnailAudio = EAudioGridThumbnailSize;

   769          }

   770      else if(aThumbnailSize == EListThumbnailSize)

   771          {

   772          thumbnailImage = EImageListThumbnailSize;

   773          thumbnailVideo = EVideoListThumbnailSize;

   774          thumbnailAudio = EAudioListThumbnailSize;

   775          }

   776      

   777      if(aThumbnailSize == EFullScreenThumbnailSize ||

   778         aThumbnailSize == EGridThumbnailSize ||

   779         aThumbnailSize == EListThumbnailSize )

   780          {

   781          TN_DEBUG1( "CThumbnailStore::FetchThumbnailL() -- No DataType -- TEMP TABLE lookup" );

   782          User::LeaveIfError( stmt.Prepare( iDatabase, KThumbnailSelectTempInfoByIdv2 ));

   783          paramIndex = stmt.ParameterIndex( KThumbnailSqlParamId );

   784          User::LeaveIfError( paramIndex );

   785          User::LeaveIfError( stmt.BindInt( paramIndex, aThumbnailId ));

   786              

   787          paramIndex = stmt.ParameterIndex( KThumbnailSqlParamSizeImage );

   788          User::LeaveIfError( paramIndex );

   789          User::LeaveIfError( stmt.BindInt( paramIndex, thumbnailImage ));

   790          

   791          paramIndex = stmt.ParameterIndex( KThumbnailSqlParamSizeVideo );

   792          User::LeaveIfError( paramIndex );

   793          User::LeaveIfError( stmt.BindInt( paramIndex, thumbnailVideo ));

   794          

   795          paramIndex = stmt.ParameterIndex( KThumbnailSqlParamSizeAudio );

   796          User::LeaveIfError( paramIndex );

   797          User::LeaveIfError( stmt.BindInt( paramIndex, thumbnailAudio ));

   798              

   799          rowStatus = stmt.Next();

   800          //if not found from temp table, look from real table

   801          if(rowStatus != KSqlAtRow)

   802            {

   803            TN_DEBUG1( "CThumbnailStore::FetchThumbnailL() -- No DataType -- MAIN TABLE lookup" );

   804            inTempTable = EFalse;

   805            stmt.Close();

   806            CleanupStack::PopAndDestroy( &stmt );

   807            CleanupClosePushL( stmt );

   808                 

   809            User::LeaveIfError( stmt.Prepare( iDatabase, KThumbnailSelectInfoByIdv2 ));

   810              

   811            paramIndex = stmt.ParameterIndex( KThumbnailSqlParamId );

   812            User::LeaveIfError( paramIndex );

   813            User::LeaveIfError( stmt.BindInt( paramIndex, aThumbnailId ));

   814                  

   815            paramIndex = stmt.ParameterIndex( KThumbnailSqlParamSizeImage );

   816            User::LeaveIfError( paramIndex );

   817            User::LeaveIfError( stmt.BindInt( paramIndex, thumbnailImage ));

   818                     

   819            paramIndex = stmt.ParameterIndex( KThumbnailSqlParamSizeVideo );

   820            User::LeaveIfError( paramIndex );

   821            User::LeaveIfError( stmt.BindInt( paramIndex, thumbnailVideo ));

   822                     

   823            paramIndex = stmt.ParameterIndex( KThumbnailSqlParamSizeAudio );

   824            User::LeaveIfError( paramIndex );

   825            User::LeaveIfError( stmt.BindInt( paramIndex, thumbnailAudio ));

   826              

   827            rowStatus = stmt.Next();

   828            }               

   829          }

   830      else

   831          {

   832          TN_DEBUG1( "CThumbnailStore::FetchThumbnailL() -- TEMP TABLE lookup" );

   833          User::LeaveIfError( stmt.Prepare( iDatabase, KThumbnailSelectTempInfoById ));

   834          paramIndex = stmt.ParameterIndex( KThumbnailSqlParamId );

   835          User::LeaveIfError( paramIndex );

   836          User::LeaveIfError( stmt.BindInt( paramIndex, aThumbnailId ));

   837      

   838          paramIndex = stmt.ParameterIndex( KThumbnailSqlParamSize );

   839          User::LeaveIfError( paramIndex );

   840          User::LeaveIfError( stmt.BindInt( paramIndex, aThumbnailSize ));

   841      

   842          rowStatus = stmt.Next();

   843 

   844          //if not found from temp table, look from real table

   845          if(rowStatus != KSqlAtRow)

   846             {

   847             TN_DEBUG1( "CThumbnailStore::FetchThumbnailL() -- MAIN TABLE lookup" );

   848             inTempTable = EFalse;

   849             stmt.Close();

   850             CleanupStack::PopAndDestroy( &stmt );

   851             CleanupClosePushL( stmt );

   852         

   853             User::LeaveIfError( stmt.Prepare( iDatabase, KThumbnailSelectInfoById ));

   854      

   855             paramIndex = stmt.ParameterIndex( KThumbnailSqlParamId );

   856             User::LeaveIfError( paramIndex );

   857             User::LeaveIfError( stmt.BindInt( paramIndex, aThumbnailId ));

   858          

   859             paramIndex = stmt.ParameterIndex( KThumbnailSqlParamSize );

   860             User::LeaveIfError( paramIndex );

   861             User::LeaveIfError( stmt.BindInt( paramIndex, aThumbnailSize ));

   862      

   863             rowStatus = stmt.Next();

   864             }

   865          }

   866      if(rowStatus == KSqlAtRow)

   867         {

   868          TN_DEBUG1( "CThumbnailStore::FetchThumbnailL() -- thumbnail found" );

   869          // Check whether blacklisted thumbnail entry modified. 

   870          // If thumbnail is marked as blacklisted and timestamp has 

   871          // changed, delete thumbnails from tables and leave with 

   872          // KErrNotFound to get thumbnail regenerated.

   873          column = 4;

   874          TInt flags = stmt.ColumnInt( column );

   875          if( flags & KThumbnailDbFlagBlacklisted )

   876              {

   877              TBool modified = EFalse;

   878              CheckModifiedByIdL( aThumbnailId, inTempTable, modified );

   879              if( modified )

   880                  {

   881                  // Close db to get deletion of thumbnails executed.

   882                  stmt.Close();

   883                  CleanupStack::PopAndDestroy( &stmt );

   884                  DeleteThumbnailsL( aThumbnailId );

   885                  User::Leave( KErrNotFound );

   886                  }

   887              else

   888                  {

   889                  User::Leave( KErrCompletion );

   890                  }

   891              }

   892          

   893          found = KErrNone;

   894          count = 0;

   895          count++;

   896          column = 0;

   897          TInt format = stmt.ColumnInt( column++ );  

   898          if(format == 1 /*TThumbnailFormat::EThumbnailFormatJpeg */ )

   899              {

   900              TPtrC8 ptr = stmt.ColumnBinaryL( column++ );

   901              HBufC8* data = ptr.AllocL() ;

   902              aThumbnail = NULL;

   903              aData = data;     

   904              

   905           } else {

   906              TPtrC8 ptr = stmt.ColumnBinaryL( column );

   907              RDesReadStream stream( ptr );

   908              aThumbnail = new( ELeave )CFbsBitmap();

   909              aThumbnail->InternalizeL( stream );

   910              aData = NULL;

   911           }

   912          

   913         //fetch real size of TN

   914         column = 2;

   915         aThumbnailRealSize.iWidth = stmt.ColumnInt( column++ );

   916         aThumbnailRealSize.iHeight = stmt.ColumnInt( column );

   917         }

   918      else

   919          {

   920          TN_DEBUG1( "CThumbnailStore::FetchThumbnailL() -- thumbnail NOT found" );

   921          }

   922          

   923      stmt.Close();

   924      CleanupStack::PopAndDestroy( &stmt );

   925 

   926      User::LeaveIfError( found );

   927      return found;

   928     }

   929 

   930 

   931 // ---------------------------------------------------------------------------

   932 // CThumbnailStore::FetchThumbnailL()

   933 // Fetches thumbnail image.

   934 // ---------------------------------------------------------------------------

   935 //

   936 void CThumbnailStore::FetchThumbnailL( const TDesC& aPath, CFbsBitmap* &

   937     aThumbnail, TDesC8* & aData, const TThumbnailSize aThumbnailSize, TSize &aThumbnailRealSize )

   938     {

   939     TN_DEBUG3( "CThumbnailStore::FetchThumbnailL(%S) aThumbnailSize==%d", &aPath, aThumbnailSize );

   940     delete aThumbnail;

   941     aThumbnail = NULL;

   942 

   943     RSqlStatement stmt;

   944     CleanupClosePushL( stmt );

   945     

   946     TInt paramIndex = 0;

   947     TInt found = KErrNotFound;

   948     TInt rowStatus = 0;

   949     TInt column = 0;

   950     TBool inTempTable = ETrue;

   951     

   952     TN_DEBUG1( "CThumbnailStore::FetchThumbnailL() -- TEMP TABLE lookup" );

   953     TInt err = stmt.Prepare( iDatabase, KThumbnailSelectTempInfoByPath );

   954 

   955 #ifdef _DEBUG

   956     TPtrC errorMsg = iDatabase.LastErrorMessage();

   957     TN_DEBUG2( "CThumbnailStore::FetchThumbnailL() %S" , &errorMsg);

   958 #endif

   959     User::LeaveIfError( err );

   960     

   961     paramIndex = stmt.ParameterIndex( KThumbnailSqlParamPath );

   962     User::LeaveIfError( paramIndex );

   963     User::LeaveIfError( stmt.BindText( paramIndex, aPath ));

   964     

   965     paramIndex = stmt.ParameterIndex( KThumbnailSqlParamSize );

   966     User::LeaveIfError( paramIndex );

   967     User::LeaveIfError( stmt.BindInt( paramIndex, aThumbnailSize ));

   968     

   969     rowStatus = stmt.Next();

   970 

   971     //if not found from temp table, look from real table

   972     if(rowStatus != KSqlAtRow)

   973        {

   974        TN_DEBUG1( "CThumbnailStore::FetchThumbnailL() -- MAIN TABLE lookup" );

   975        inTempTable = EFalse;

   976        stmt.Close();

   977        CleanupStack::PopAndDestroy( &stmt );

   978        CleanupClosePushL( stmt );

   979        

   980        User::LeaveIfError( stmt.Prepare( iDatabase, KThumbnailSelectInfoByPath ));

   981     

   982         paramIndex = stmt.ParameterIndex( KThumbnailSqlParamPath );

   983         User::LeaveIfError( paramIndex );

   984         User::LeaveIfError( stmt.BindText( paramIndex, aPath ));

   985         

   986         paramIndex = stmt.ParameterIndex( KThumbnailSqlParamSize );

   987         User::LeaveIfError( paramIndex );

   988         User::LeaveIfError( stmt.BindInt( paramIndex, aThumbnailSize ));

   989     

   990         rowStatus = stmt.Next();

   991        }

   992 

   993     if(rowStatus == KSqlAtRow)

   994        {

   995         TN_DEBUG1( "CThumbnailStore::FetchThumbnailL() -- thumbnail found" );

   996         // Check whether blacklisted thumbnail entry modified. 

   997         // If thumbnail is marked as blacklisted and timestamp has 

   998         // changed, delete thumbnails from tables and leave with 

   999         // KErrNotFound to get thumbnail regenerated.

  1000         column = 4;

  1001         TInt flags = stmt.ColumnInt( column );

  1002         if( flags & KThumbnailDbFlagBlacklisted && aPath.Length() )

  1003             {

  1004             TBool modified = EFalse;

  1005             CheckModifiedByPathL( aPath, inTempTable, modified );

  1006             if( modified )

  1007                 {

  1008                 // Close db to get deletion of thumbnails executed.

  1009                 stmt.Close();

  1010                 CleanupStack::PopAndDestroy( &stmt );

  1011                 DeleteThumbnailsL( aPath );

  1012                 User::Leave( KErrNotFound );

  1013                 }

  1014             else

  1015                 {

  1016                 User::Leave( KErrCompletion );

  1017                 }

  1018             }

  1019         else if( !(flags & KThumbnailDbFlagBlacklisted) )

  1020             {

  1021             found = KErrNone;

  1022             column = 0;

  1023             TInt format = stmt.ColumnInt( column++ );  

  1024             if(format == 1 /*TThumbnailFormat::EThumbnailFormatJpeg */ )

  1025                {

  1026                TPtrC8 ptr = stmt.ColumnBinaryL( column++ );

  1027                HBufC8* data = ptr.AllocL() ;

  1028                aThumbnail = NULL;

  1029                aData = data;

  1030                

  1031             } else {

  1032     

  1033                TPtrC8 ptr = stmt.ColumnBinaryL( column++ );

  1034                RDesReadStream stream( ptr );

  1035                aThumbnail = new( ELeave )CFbsBitmap();

  1036                aThumbnail->InternalizeL( stream );

  1037                aData = NULL;

  1038                }

  1039             

  1040             //fetch real size of TN

  1041             column = 2;

  1042             aThumbnailRealSize.iWidth = stmt.ColumnInt( column++ );

  1043             aThumbnailRealSize.iHeight = stmt.ColumnInt( column );

  1044             }

  1045         }

  1046     else

  1047         {

  1048         TN_DEBUG1( "CThumbnailStore::FetchThumbnailL() -- thumbnail NOT found" );

  1049         }

  1050         

  1051     stmt.Close();

  1052     CleanupStack::PopAndDestroy( &stmt );

  1053 

  1054     User::LeaveIfError( found );

  1055     }

  1056 

  1057 // -----------------------------------------------------------------------------

  1058 // Delete thumbnails for given object file by Path

  1059 // -----------------------------------------------------------------------------

  1060 //

  1061 void CThumbnailStore::DeleteThumbnailsL( const TDesC& aPath )

  1062     {

  1063     RThumbnailTransaction transaction( iDatabase );

  1064     CleanupClosePushL( transaction );

  1065     transaction.BeginL();

  1066     RSqlStatement stmt;

  1067     CleanupClosePushL( stmt );

  1068     

  1069     TInt paramIndex = 0;

  1070     TInt paramIndex1 = 0;

  1071     TInt paramIndex2 = 0;

  1072     TInt rowStatus = 0;

  1073     TInt column = 0;

  1074     TInt rowid = 0;

  1075     TInt deleteCount = 0;

  1076     

  1077     TN_DEBUG1( "CThumbnailStore::DeleteThumbnailsByPathL() -- TEMP TABLE lookup" );

  1078     TInt err = stmt.Prepare( iDatabase, KTempThumbnailSqlSelectRowIDInfoByPath);

  1079     User::LeaveIfError( err );

  1080     

  1081     paramIndex = stmt.ParameterIndex( KThumbnailSqlParamPath );

  1082     User::LeaveIfError( paramIndex );

  1083     User::LeaveIfError( stmt.BindText( paramIndex, aPath ));

  1084     

  1085     rowStatus = stmt.Next();

  1086     RSqlStatement stmt_info;

  1087     CleanupClosePushL( stmt_info );

  1088     err = stmt_info.Prepare( iDatabase, KTempThumbnailSqlDeleteInfoByPath);

  1089     RSqlStatement stmt_infodata;

  1090     CleanupClosePushL( stmt_infodata );

  1091     err = stmt_infodata.Prepare( iDatabase, KTempThumbnailSqlDeleteInfoDataByPath);

  1092     

  1093     

  1094     while(rowStatus == KSqlAtRow)

  1095        {  

  1096        rowid = stmt.ColumnInt( column ); 

  1097        paramIndex1 = stmt_info.ParameterIndex( KThumbnailSqlParamRowID );

  1098        User::LeaveIfError( paramIndex1 );

  1099        User::LeaveIfError( stmt_info.BindInt( paramIndex1, rowid ));

  1100        

  1101        deleteCount = stmt_info.Exec();

  1102        stmt_info.Reset();

  1103        User::LeaveIfError( deleteCount );

  1104              

  1105        paramIndex2 = stmt_infodata.ParameterIndex( KThumbnailSqlParamRowID );

  1106        User::LeaveIfError( paramIndex2 );

  1107        User::LeaveIfError( stmt_infodata.BindInt( paramIndex2, rowid ));

  1108              

  1109        deleteCount = stmt_infodata.Exec();

  1110        stmt_infodata.Reset();

  1111        User::LeaveIfError( deleteCount );

  1112        

  1113        TN_DEBUG1( "CThumbnailStore::DeleteThumbnailsByPathL() -- TEMP TABLE lookup - thumbnail deleted" );

  1114        

  1115        // fetch another row (temp table rowIDs are updated immediately)

  1116        stmt.Reset();

  1117        

  1118        paramIndex = stmt.ParameterIndex( KThumbnailSqlParamPath );

  1119        User::LeaveIfError( paramIndex );

  1120        User::LeaveIfError( stmt.BindText( paramIndex, aPath ));

  1121        

  1122        rowStatus = stmt.Next();   

  1123        }

  1124     stmt_infodata.Close();

  1125     stmt_info.Close();

  1126     CleanupStack::PopAndDestroy( &stmt_infodata );

  1127     CleanupStack::PopAndDestroy( &stmt_info );

  1128     

  1129 

  1130     //look from real table 

  1131     TN_DEBUG1( "CThumbnailStore::DeleteThumbnailByPathL() -- MAIN TABLE lookup" );

  1132     stmt.Close();

  1133     CleanupStack::PopAndDestroy( &stmt );

  1134     CleanupClosePushL( stmt );