/*

* 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 <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_v2.db" );

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

        User::Leave( err );

        }

    }

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

// RThumbnailTransaction::Close()

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

//

void RThumbnailTransaction::Close()

    {

    if ( iState != EClosed )

        {

        Rollback();

        }

    }

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

// RThumbnailTransaction::CommitL()

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

//

void RThumbnailTransaction::CommitL()

    {

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

    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_DEBUG1( "CThumbnailStore::~CThumbnailStore()" );

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

    iFs( aFs ), iDrive( aDrive ), iBatchItemCount(0), iImei(aImei), iServer(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();

    TChar driveChar = 0;

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

    pathPtr.Append( driveChar );

    pathPtr.Append( KThumbnailDatabaseName );

    TVolumeInfo volumeinfo;

    iFs.Volume(volumeinfo, iDrive);

    TUint id = volumeinfo.iUniqueID;

    TBuf<50> mediaid;

    mediaid.Num(id);

    TBool newDatabase(EFalse);

    TInt error = KErrNone;

    TInt err = iDatabase.Open( pathPtr );

    if ( err == KErrNotFound )

        {

        // db not found, create new

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

        const TDesC8& config = KThumbnailSqlConfig;

        RSqlSecurityPolicy securityPolicy;

        CleanupClosePushL( securityPolicy );

        securityPolicy.Create( KThumbnailDatabaseSecurityPolicy );

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

        CleanupStack::PopAndDestroy( &securityPolicy );

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

        RFile64 file;

        file.Create(iFs, mediaid, EFileShareReadersOrWriters );

        file.Close();

        newDatabase = ETrue;

        }

    else if ( err == KErrNone)

        {

        // db found, check version and rowids

        error = CheckVersionL();

        if(error == KErrNone)

            {

            error = CheckRowIDsL();

            }

        }

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

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

        {

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

        // delete db and create new

        iDatabase.Close();

        iDatabase.Delete(pathPtr);

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

        const TDesC8& config = KThumbnailSqlConfig;

        RSqlSecurityPolicy securityPolicy;

        CleanupClosePushL( securityPolicy );

        securityPolicy.Create( KThumbnailDatabaseSecurityPolicy );

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

        CleanupStack::PopAndDestroy( &securityPolicy );

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

        RFile64 file;

        file.Create(iFs, mediaid, EFileShareReadersOrWriters );

        file.Close();

        }

    else if(!newDatabase)

        {

        //check ownership

        if(CheckImeiL() != KErrNone)

            {

            ResetThumbnailIDs();

            //take ownership

            UpdateImeiL();

            //Remove blacklist markings

            TRAP_IGNORE( RemoveDbFlagL( KThumbnailDbFlagBlacklisted ) );

            }

        //check is MMC known

        if(CheckMediaIDL() != KErrNone )

            {

            ResetThumbnailIDs();

            //Remove blacklist markings

            TRAP_IGNORE( RemoveDbFlagL( KThumbnailDbFlagBlacklisted ) );

            }

        }

    CleanupStack::PopAndDestroy( databasePath );

    // add tables

    TRAPD(tableError, CreateTablesL() );

    if(!tableError)

        {

        AddVersionAndImeiL();

        }

    err = iDatabase.Exec( KThumbnailCreateTempInfoTable );

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

    User::LeaveIfError( err );

    err = iDatabase.Exec( KThumbnailCreateTempInfoDataTable );

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

    User::LeaveIfError( err );

    }

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

// 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, TThumbnailId aThumbnailId, 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 );

    User::LeaveIfError( paramIndex );

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

    paramIndex = stmt.ParameterIndex( KThumbnailSqlParamWidth );

    User::LeaveIfError( paramIndex );

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

    paramIndex = stmt.ParameterIndex( KThumbnailSqlParamHeight );

    User::LeaveIfError( paramIndex );

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

    paramIndex = stmt.ParameterIndex( KThumbnailSqlParamOriginalWidth );

    User::LeaveIfError( paramIndex );

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

    paramIndex = stmt.ParameterIndex( KThumbnailSqlParamOriginalHeight );

    User::LeaveIfError( paramIndex );

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

    paramIndex = stmt.ParameterIndex( KThumbnailSqlParamFormat );

    User::LeaveIfError( paramIndex );

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

    paramIndex = stmt.ParameterIndex( KThumbnailSqlParamFlags );

    User::LeaveIfError( paramIndex );

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

    paramIndex = stmt.ParameterIndex( KThumbnailSqlParamSize );

    User::LeaveIfError( paramIndex );

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

    if( aThumbnailId > 0 )

        {

        paramIndex = stmt.ParameterIndex( KThumbnailSqlParamId );

        User::LeaveIfError( paramIndex );

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

        }

    else

        {

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

        }

    // orientation temporarily to 0

    paramIndex = stmt.ParameterIndex( KThumbnailSqlParamOrientation );

    User::LeaveIfError( paramIndex );

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

    // thumb from associated path

    TInt fromPath = aThumbFromPath;

    paramIndex = stmt.ParameterIndex( KThumbnailSqlParamThumbFromPath );

    User::LeaveIfError( paramIndex );

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

    // try getting modification time from file

    TTime timeStamp;

    if (aPath.Length())

        {

        iFs.Modified(aPath, timeStamp);

        }

    else

        {

        // otherwise current time

        timeStamp.UniversalTime();

        }

    paramIndex = stmt.ParameterIndex( KThumbnailSqlParamModified );

    User::LeaveIfError( paramIndex );

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

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

    CleanupStack::PopAndDestroy( &stmt );

    RSqlStatement stmtData;

    CleanupClosePushL( stmtData );

    // Insert into ThumbnailInfoData

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

#ifdef _DEBUG

    TPtrC errorMsg = iDatabase.LastErrorMessage();

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

#endif    

    User::LeaveIfError( err );

    paramIndex = stmtData.ParameterIndex( KThumbnailSqlParamData );

    User::LeaveIfError( paramIndex );

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

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

    CleanupStack::PopAndDestroy( &stmtData );

    // Commit transaction

    transaction.CommitL();

    CleanupStack::PopAndDestroy( &transaction );

    iBatchItemCount++;

    FlushCacheTable();

#ifdef _DEBUG

    iThumbCounter++;

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

    aStop.UniversalTime();

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

#endif 

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

    }

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

// CThumbnailStore::StoreThumbnailL()

// Stores thumbnail image.

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

//

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

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

    const TThumbnailId aThumbnailId, const TBool aThumbFromPath, TBool aBlackListed )

    {

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

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

    // check for duplicates

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

    TSize thumbSize = aThumbnail->SizeInPixels();

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

        {

        TThumbnailPersistentSize & persistentSize = iPersistentSizes[i];

        // don't store duplicates or custom sizes

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

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

            {

            TInt flags = 0;

            if ( persistentSize.iCrop )

                {

                flags |= KThumbnailDbFlagCropped;

                }

            if( aBlackListed )

                {

                flags |= KThumbnailDbFlagBlacklisted;

                }

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

                 aThumbnailSize == EAudioFullScreenThumbnailSize) && !aBlackListed )

                {

                HBufC8* data = NULL;

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

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

                // Set some format specific data

                imageData->iSampleScheme = TJpegImageData::EColor444;

                imageData->iQualityFactor = 75; //?

                CFrameImageData* iFrameImageData = CFrameImageData::NewL();

                // frameData - ownership passed to iFrameImageData after AppendImageData

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

#ifdef _DEBUG

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

                aThumbnail->SizeInPixels().iWidth, 

                aThumbnail->SizeInPixels().iHeight, 

                aThumbnail->DisplayMode());

#endif

                TRequestStatus request;

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

                User::WaitForRequest( request);

                if(request== KErrNone)

                  {

                  TPtr8 ptr  = data->Des(); 

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

                          EThumbnailFormatJpeg, flags, aThumbnailSize, aThumbnailId, aThumbFromPath  );

                  }

                delete iFrameImageData;

                iFrameImageData = NULL;          

                delete iEncoder;

                iEncoder = NULL;    

                delete data;

                data = NULL;                

                }

            else

                {

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

                CleanupStack::PushL( buf );

                RBufWriteStream stream;

                stream.Open( *buf );

                aThumbnail->ExternalizeL( stream );

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

                    aOriginalSize, EThumbnailFormatFbsBitmap, flags, aThumbnailSize, aThumbnailId );