/*

* 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"

const TInt KStreamBufferSize = 1024 * 8;

const TInt KMajor = 3;

const TInt KMinor = 2;

const TInt KStoreUnrecoverableErr = KErrCorrupt;

// Database path without drive letter

_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()

    {

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

    if(iActivityManager)

        {

        delete iActivityManager;

        iActivityManager = NULL;

        }

    if(iDiskFullNotifier)

        {

        delete iDiskFullNotifier;

        iDiskFullNotifier = NULL;

        }

    if( iAutoFlushTimer )

        {

        iAutoFlushTimer->Cancel();

        delete iAutoFlushTimer;

        iAutoFlushTimer = NULL;

        }

    CloseStatements();   

    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 ): 

    iFs( aFs ), iDrive( aDrive ), iDriveChar( 0 ), iBatchItemCount(0), iImei(aImei), 

    {

    // 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();

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

    pathPtr.Append( iDriveChar );

    pathPtr.Append( KThumbnailDatabaseName );

	//start disk space monitor

    iDiskFullNotifier = CThumbnailStoreDiskSpaceNotifierAO::NewL( *this, 

                                            KDiskFullThreshold,

                                            pathPtr );

    CleanupStack::PopAndDestroy( databasePath );

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

    OpenDatabaseL();

    // to monitor device activity

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

    iActivityManager->Start();

    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( TBool aNewDatabase )

    {

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

    iDatabase.Close();

    iUnrecoverable = ETrue;

    TInt checkError = KErrNone;

    TInt blistError = KErrNone;

    TInt blistError2 = KErrNone;

    TInt imeiError = KErrNone;

    TInt err = KErrNone;

    if (aNewDatabase)

        {

        // delete existing and create new

        CleanupClosePushL(iDatabase);

        RecreateDatabaseL(ETrue);

        CleanupStack::Pop(&iDatabase);

        }

    else

        {

        // just open old

        err = OpenDatabaseFileL();

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

        if ( err == KErrNone)

            {

            // db found, check version and rowids

            checkError = CheckVersion();

            if(checkError == KErrNone)

                {

                checkError = CheckRowIDs();

                }

            }

            {

        }    

    // opened existing database file

    if(!aNewDatabase)

        {       

        // add temp tables

        CreateTempTablesL();

        //check ownership

        imeiError = CheckImei();

        if(imeiError != KErrNone)

            {

            //take ownership

            //Touch blacklisted items

            TRAP(blistError, PrepareBlacklistedItemsForRetryL() );

            }

        //check if MMC is known

        if(CheckMediaIDL() != KErrNone)

            {

            //Touch blacklisted items

            TRAP(blistError2, PrepareBlacklistedItemsForRetryL() );

            }

            {

            CleanupClosePushL(iDatabase);

            RecreateDatabaseL(ETrue);

            CleanupStack::Pop(&iDatabase);

            }

        }

    PrepareStatementsL();

    // database now usable

    iUnrecoverable = EFalse;

    return KErrNone;

    }

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

// PrepareDbL database tables

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

//

void CThumbnailStore::PrepareDbL()

    {

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

    // add persistent tables

    CreateTablesL();

    AddVersionAndImeiL();

    // add temp tables

    CreateTempTablesL();

    }

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

// Create database tables

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

//

void CThumbnailStore::CreateTablesL()

    {

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

    TInt err = KErrNone;

    err = iDatabase.Exec( KThumbnailCreateInfoTable );

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

    User::LeaveIfError( err );

    err = iDatabase.Exec( KThumbnailCreateInfoDataTable );

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

    User::LeaveIfError( err );

    err = iDatabase.Exec(KThumbnailDeletedTable);

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

    User::LeaveIfError( err );

    err = iDatabase.Exec( KThumbnailCreateInfoTableIndex1 );

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

    User::LeaveIfError( err );

    err = iDatabase.Exec( KThumbnailCreateDeletedTableIndex );

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

    User::LeaveIfError( err );

    err = iDatabase.Exec(KThumbnailVersionTable);

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

    User::LeaveIfError( err );

    }

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

// Create temp tables

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

//

void CThumbnailStore::CreateTempTablesL()

    {

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

    TInt err = iDatabase.Exec( KThumbnailCreateTempInfoTable );

#ifdef _DEBUG

    if(err < 0)

        {

        TPtrC errorMsg = iDatabase.LastErrorMessage();

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

        }

#endif

    User::LeaveIfError( err );

    err = iDatabase.Exec( KThumbnailCreateTempInfoDataTable );

#ifdef _DEBUG

    if(err < 0)

        {

        TPtrC errorMsg = iDatabase.LastErrorMessage();

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

        }

#endif

    User::LeaveIfError( err );

    }

void CThumbnailStore::RecreateDatabaseL(const TBool aDelete)

    {

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

    TVolumeInfo volumeinfo;

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

    TUint id = volumeinfo.iUniqueID;

    TBuf<50> mediaid;

    mediaid.Num(id);

    iDatabase.Close();

    iUnrecoverable = ETrue;

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

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

    TPtr pathPtr = databasePath->Des();

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

    pathPtr.Append( iDriveChar );

    pathPtr.Append( KThumbnailDatabaseName );

    TInt err(KErrNone);

    // delete old if necessary

    if(aDelete)

        {

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

        TInt del = iDatabase.Delete(pathPtr);     

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

        }

    const TDesC8& config = KThumbnailSqlConfig;

    RSqlSecurityPolicy securityPolicy;

    CleanupClosePushL( securityPolicy );

    securityPolicy.CreateL( KThumbnailDatabaseSecurityPolicy );

    // create new

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

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

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

    User::LeaveIfError(err);

    CleanupStack::PopAndDestroy( &securityPolicy );

    // add tables

    TRAPD(prepareErr, PrepareDbL() );

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

    TInt mediaidErr(KErrNone);

    // write media id file if doesn't exist

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

        {

        RFile64 file;

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

        file.Close();