/*

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

* All rights reserved.

* This component and the accompanying materials are made available

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

* which accompanies this distribution, and is available

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

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  Store for thumbnails.

 *

*/

#include <s32mem.h>

#include <e32cmn.h>

#include <fbs.h>

#include <imageconversion.h>

#include <e32base.h>

#include <exifread.h>

#include <bautils.h>  

#include <IclExtJpegApi.h>

#include "thumbnailstore.h"

#include "thumbnailsql.h"

#include "thumbnaillog.h"

#include "thumbnailmanageruids.hrh"

#include "thumbnailcenrep.h"

#include "thumbnailpanic.h"

#include "thumbnailmanagerconstants.h"

#include "thumbnailserver.h"

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

const TInt KStreamBufferSize = 1024 * 8;

const TInt KMajor = 3;

const TInt KMinor = 2;

// Database path without drive letter

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

_LIT( KDrv, ":");

// Allow access to database only for the server process

const TSecurityPolicy KThumbnailDatabaseSecurityPolicy( TSecureId(

    THUMBNAIL_MANAGER_SERVER_UID ));

// ---------------------------------------------------------------------------

// RThumbnailTransaction::RThumbnailTransaction::TThumbnailPersistentSize

// ---------------------------------------------------------------------------

//

RThumbnailTransaction::RThumbnailTransaction( RSqlDatabase& aDatabase ):

    iDatabase( aDatabase ), iState( EClosed )

    {

    // No implementation required

    }

// ---------------------------------------------------------------------------

// RThumbnailTransaction::BeginL()

// ---------------------------------------------------------------------------

//

void RThumbnailTransaction::BeginL()

    {

    const TInt err = iDatabase.Exec( KThumbnailBeginTransaction );

    if ( err >= 0 )

        {

        iState = EOpen;

        }

    else

        {

        iState = EError;

#ifdef _DEBUG

    TPtrC errorMsg = iDatabase.LastErrorMessage();

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

#endif

        User::Leave( err );

        }

    }

// ---------------------------------------------------------------------------

// RThumbnailTransaction::Close()

// ---------------------------------------------------------------------------

//

void RThumbnailTransaction::Close()

    {

    if ( iState != EClosed )

        {

        Rollback();

        }

    }

// ---------------------------------------------------------------------------

// RThumbnailTransaction::CommitL()

// ---------------------------------------------------------------------------

//

void RThumbnailTransaction::CommitL()

    {

    TInt ret = iDatabase.Exec( KThumbnailCommitTransaction );

#ifdef _DEBUG

    TPtrC errorMsg = iDatabase.LastErrorMessage();

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

#endif  

    User::LeaveIfError( ret );

    iState = EClosed;

    }

// ---------------------------------------------------------------------------

// RThumbnailTransaction::Rollback()

// ---------------------------------------------------------------------------

//

TInt RThumbnailTransaction::Rollback()

    {

    const TInt err = iDatabase.Exec( KThumbnailRollbackTransaction );

    if ( err >= 0 )

        {

        iState = EClosed;

        }

    return err;

    }

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

// ---------------------------------------------------------------------------

// CThumbnailStore::NewL()

// Two-phased constructor.

// ---------------------------------------------------------------------------

//

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

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// ---------------------------------------------------------------------------

// CThumbnailStore::~CThumbnailStore()

// Destructor.

// ---------------------------------------------------------------------------

//

CThumbnailStore::~CThumbnailStore()

    {

    if(iActivityManager)

        {

        delete iActivityManager;

        iActivityManager = NULL;

        }

    if(iDiskFullNotifier)

        {

        delete iDiskFullNotifier;

        iDiskFullNotifier = NULL;

        }

    if(!iServer->IsFormatting())

        {

 	    FlushCacheTable( ETrue );

        }

    if( iAutoFlushTimer )

        {

        iAutoFlushTimer->Cancel();

        delete iAutoFlushTimer;

        iAutoFlushTimer = NULL;

        }

    iDatabase.Close();

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

    }

// ---------------------------------------------------------------------------

// CThumbnailStore::CThumbnailStore()

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

// ---------------------------------------------------------------------------

//

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

    {

    // no implementation required

    }

// ---------------------------------------------------------------------------

// CThumbnailStore::ConstructL()

// Symbian 2nd phase constructor can leave.

// ---------------------------------------------------------------------------

//

void CThumbnailStore::ConstructL()

    {

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

#ifdef _DEBUG

    iThumbCounter = 0;

#endif

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

    TPtr pathPtr = databasePath->Des();

    pathPtr.Append( KThumbnailDatabaseName );

	//start disk space monitor

    iDiskFullNotifier = CThumbnailStoreDiskSpaceNotifierAO::NewL( *this, 

                                            KDiskFullThreshold,

                                            pathPtr );

    CleanupStack::PopAndDestroy( databasePath );

    OpenDatabaseL();

    // to monitor device activity

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

    iActivityManager->Start();

    // once in every mount

    iDeleteThumbs = ETrue;

    iCheckFilesExist = ETrue;

    iLastCheckedRowID = -1;

    }

// ---------------------------------------------------------------------------

// OpenDatabaseL database file

// ---------------------------------------------------------------------------

TInt CThumbnailStore::OpenDatabaseFileL()

    {

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

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

    TPtr pathPtr = databasePath->Des();

    TChar driveChar = 0;

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

    pathPtr.Append( driveChar );

    pathPtr.Append( KThumbnailDatabaseName );

    TInt ret = iDatabase.Open( pathPtr );

    CleanupStack::PopAndDestroy( databasePath );

    return ret;

    }

// ---------------------------------------------------------------------------

// OpenDatabaseL database

// ---------------------------------------------------------------------------

TInt CThumbnailStore::OpenDatabaseL()

    {

    iDatabase.Close();

    TBool newDatabase(EFalse);

    TInt error = KErrNone;

    TInt err = OpenDatabaseFileL();

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

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

       {

       RecreateDatabaseL( ETrue);

       }

   else if(!newDatabase)

       {

       if(ResetThumbnailIDs() == KSqlErrCorrupt)

           {

           RecreateDatabaseL( ETrue);

           }

       //check ownership

       error = CheckImeiL();

       if(error != KErrNone)

           {

           if(error == KSqlErrCorrupt)

               {

               RecreateDatabaseL( ETrue);

               }

           //take ownership

           error = UpdateImeiL();

           if(error == KSqlErrCorrupt)

               {

               RecreateDatabaseL( ETrue);

               }

           //Touch blacklisted items

           TRAP(error, PrepareBlacklistedItemsForRetryL( ) );

           if(error == KSqlErrCorrupt)

               {

               RecreateDatabaseL( ETrue);

               }

           }

       //check is MMC known

       if(CheckMediaIDL() != KErrNone )

           {

           //Touch blacklisted items

           TRAP(error, PrepareBlacklistedItemsForRetryL() );

           if(error == KSqlErrCorrupt)

               {

               RecreateDatabaseL( ETrue);

               }

           }

       }

   PrepareDbL();

   return KErrNone;

    }

// ---------------------------------------------------------------------------

// PrepareDbL database tables

// ---------------------------------------------------------------------------

//

void CThumbnailStore::PrepareDbL()

    {

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

    TInt err(KErrNone);

    // add tables

    TRAPD(tableError, CreateTablesL() );

    if(!tableError)

#ifdef _DEBUG

#endif

    User::LeaveIfError( err );

#ifdef _DEBUG

#endif

}

// ---------------------------------------------------------------------------

// Create database tables

// ---------------------------------------------------------------------------

//

void CThumbnailStore::CreateTablesL()

    {

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

    TInt err = 0;

    err = iDatabase.Exec( KThumbnailCreateInfoTable );

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

    err = iDatabase.Exec( KThumbnailCreateInfoDataTable );

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

    err = iDatabase.Exec(KThumbnailDeletedTable);

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

    err = iDatabase.Exec(KThumbnailVersionTable);

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

    err = iDatabase.Exec( KThumbnailCreateInfoTableIndex1 );

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

    err = iDatabase.Exec( KThumbnailCreateDeletedTableIndex );

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

    User::LeaveIfError( err );

    }

void CThumbnailStore::RecreateDatabaseL(const TBool aDelete)

    {

    TVolumeInfo volumeinfo;

    iFs.Volume(volumeinfo, iDrive);

    TUint id = volumeinfo.iUniqueID;

    TBuf<50> mediaid;

    mediaid.Num(id);

    // delete db and create new

    iDatabase.Close();

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

    TPtr pathPtr = databasePath->Des();

    pathPtr.Append( KThumbnailDatabaseName );

    TInt err(KErrNone);

    if(aDelete)

        {

        }

    const TDesC8& config = KThumbnailSqlConfig;

    RSqlSecurityPolicy securityPolicy;

    CleanupClosePushL( securityPolicy );

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

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

    User::LeaveIfError( err );

    RFile64 file;

    file.Create(iFs, mediaid, EFileShareReadersOrWriters );

    file.Close();

    OpenDatabaseFileL();

    }

// ---------------------------------------------------------------------------

// CThumbnailStore::StoreThumbnailL()

// Stores thumbnail image.

// ---------------------------------------------------------------------------

//

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

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

	const TThumbnailSize& aThumbnailSize, const TInt64 aModified, const TBool aThumbFromPath )

    {

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

#ifdef _DEBUG

    TTime aStart, aStop;

    aStart.UniversalTime();

#endif

    //Encapsulate insert to Transaction

    RThumbnailTransaction transaction( iDatabase );

    CleanupClosePushL( transaction );

    transaction.BeginL();

    RSqlStatement stmt;

    CleanupClosePushL( stmt );

    // Insert into ThumbnailInfo

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

    TInt paramIndex = stmt.ParameterIndex( KThumbnailSqlParamPath );