/*

* 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=32768; cache_size=64;" );

const TInt KStreamBufferSize = 1024 * 8;

const TInt KMajor = 3;

const TInt KMinor = 2;

const TInt KStoreUnrecoverableErr = KErrCorrupt;

// Database path without drive letter

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

    {    

    if (iDatabase.InTransaction())

        {

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

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

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

        iState = EOldOpen;

        return;

        }

    const TInt err = iDatabase.Exec( KThumbnailBeginTransaction );

    if ( err >= 0 )

        {

        iState = EOpen;

        }

    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 && iState != EOldOpen )

        {

        Rollback();

        }

    }

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

// RThumbnailTransaction::CommitL()

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

//

void RThumbnailTransaction::CommitL()

    {

    if ( iState != EOldOpen )

        {

        TInt ret = iDatabase.Exec( KThumbnailCommitTransaction );

#ifdef _DEBUG

    TPtrC errorMsg = iDatabase.LastErrorMessage();

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

#endif  

    User::LeaveIfError( ret );

        }

    iState = EClosed;

    }

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

// RThumbnailTransaction::Rollback()

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

//

TInt RThumbnailTransaction::Rollback()

    {

    if ( iState != EOldOpen )

        {

        // in some cases there could have been automatic rollback

        if (iDatabase.InTransaction())

            {

            const TInt err = iDatabase.Exec( KThumbnailRollbackTransaction );

            if ( err >= 0 )

                {

                iState = EClosed;

                }

            return err;

            }

        else

            {

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

            }

        }

    iState = EClosed;

    return KErrNone;

    }

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

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

// CThumbnailStore::NewL()

// Two-phased constructor.

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

//

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

    {

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

    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;

        }

    if( iMaintenanceTimer )

        {

        iMaintenanceTimer->Cancel();

        delete iMaintenanceTimer;

        iMaintenanceTimer = 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, const TBool aReadOnly ): 

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

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

    {

    // no implementation required

    }

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

// CThumbnailStore::ConstructL()

// Symbian 2nd phase constructor can leave.

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

//

void CThumbnailStore::ConstructL()

    {

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

#ifdef _DEBUG

    iThumbCounter = 0;

#endif

    if(!iReadOnly)

        {

        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;

        }

    else

        {

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

        iDeleteThumbs = EFalse;

        iCheckFilesExist = EFalse;

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

    CloseStatements();

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

                }

            }

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

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

            {

            CleanupClosePushL(iDatabase);

            RecreateDatabaseL(ETrue);

            CleanupStack::Pop(&iDatabase);

            aNewDatabase = ETrue;

            }          

        }    

    // opened existing database file

    if(!aNewDatabase)

        {       

        // add temp tables

        CreateTempTablesL();

        //check ownership

        imeiError = CheckImei();

        if(imeiError != KErrNone)

            {

            //take ownership

            TRAP(imeiError, UpdateImeiL() );

            //Touch blacklisted items

            TRAP(blistError, PrepareBlacklistedItemsForRetryL() );

            }

        //check if MMC is known

        if(CheckMediaIDL() != KErrNone)

            {

            //Touch blacklisted items

            TRAP(blistError2, PrepareBlacklistedItemsForRetryL() );

            }

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

            {

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

    CloseStatements();

    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" );