/*

* Copyright (c) 2008-2009 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:    Thumbnail storage implementation

*

*/

/**

 * @internal reviewed 31/07/2007 by Simon Brooks

 */

// INCLUDE FILES

#include "glxtndatabase.h"

#include <glxassert.h>

#include <glxtracer.h>

#include <glxlog.h>

#include <driveinfo.h>

#include <pathinfo.h>

#include <e32des16.h>

#include <e32std.h>

#include <bautils.h>

#include <centralrepository.h>

#include "glxtnfileinfo.h"

#include "glxtnvolumedatabase.h"

// ============================ CONSTANTS ===============================

_LIT(KDriveNameFormat, "%c:\\");

const TInt KLoggingDriveLetterLength = 8;

const TInt KGlxmediaSerialIdLength = 64;

const TUint32 KGlxTnMassStorageNotFreshlyFlashed    = 0x00000001 ;

const TUint32 KGlxTnSDCardVolumeId                  = 0x00000001 ;

const TUint32 KGlxTnHardDriveFlashState             = 0x00000002 ;

const TInt KRepositoryId    = 0x2000A09 ; 

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

// CGlxtnThumbnailDatabase::CGlxtnThumbnailDatabase

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

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

//

CGlxtnThumbnailDatabase::CGlxtnThumbnailDatabase()

    {

    TRACER("CGlxtnThumbnailDatabase::CGlxtnThumbnailDatabase()");

    iInternalDrive = PathInfo::PhoneMemoryRootPath().Left( KMaxDriveName );

    }

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

// CGlxtnThumbnailDatabase::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CGlxtnThumbnailDatabase::ConstructL(const TDesC& aDbFilename,

                             MGlxtnThumbnailStorageObserver* aStorageObserver)

    {

    TRACER("void CGlxtnThumbnailDatabase::ConstructL()");

    User::LeaveIfError(iFs.Connect());

    User::LeaveIfError(iFs.PrivatePath(iDatabasePath));

    iDatabasePath.Append(aDbFilename);

    iStorageObserver = aStorageObserver;

    }

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

// CGlxtnThumbnailDatabase::NewL

// Two-phased constructor.

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

//

EXPORT_C CGlxtnThumbnailDatabase* CGlxtnThumbnailDatabase::NewL(

                             const TDesC& aDbFilename,

                             MGlxtnThumbnailStorageObserver* aStorageObserver)

    {

    TRACER("CGlxtnThumbnailDatabase* CGlxtnThumbnailDatabase::NewL()");

    CGlxtnThumbnailDatabase* self = new (ELeave) CGlxtnThumbnailDatabase;

    CleanupStack::PushL(self);

    self->ConstructL(aDbFilename, aStorageObserver);

    CleanupStack::Pop( self );

    return self;

    }

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

// Destructor

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

//

CGlxtnThumbnailDatabase::~CGlxtnThumbnailDatabase()

    {

    TRACER("CGlxtnThumbnailDatabase::~CGlxtnThumbnailDatabase()");

    iDatabaseArray.ResetAndDestroy();

    iFs.Close();

    }

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

// LoadThumbnailDataL

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

//

void CGlxtnThumbnailDatabase::LoadThumbnailDataL(HBufC8*& aData,

                        TGlxImageDataFormat& aFormat, const TGlxMediaId& aId,

                        const CGlxtnFileInfo& aFileInfo, const TSize& aSize,

                        TRequestStatus* aStatus)

    {

    TRACER("void CGlxtnThumbnailDatabase::LoadThumbnailDataL()");

    if ( iClientStatus )

        {

        User::Leave(KErrNotReady);

        }

    iCurrentOperation = ELoading;

    iLoadData = &aData;

    iLoadFormat = &aFormat;

    iMediaId = aId;

    iFileInfo = &aFileInfo;

    iSize = aSize;

    OpenDatabaseL( iInternalDrive )->GetThumbnailIdL( iMediaId );

    iClientStatus = aStatus;

    *iClientStatus = KRequestPending;

    }

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

// SaveThumbnailDataL

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

//

void CGlxtnThumbnailDatabase::SaveThumbnailDataL(const TDesC8& aData,

                        TGlxImageDataFormat aFormat, const TGlxMediaId& aId,

                        const CGlxtnFileInfo& aFileInfo, const TSize& aSize,

                        TRequestStatus* aStatus)

    {

    TRACER("void CGlxtnThumbnailDatabase::SaveThumbnailDataL()");

    if ( iClientStatus )

        {

        User::Leave(KErrNotReady);

        }

    iCurrentOperation = ESaving;

    iSaveData.Set(aData);

    ASSERT(iSaveData.Length() == aData.Length());

    iSaveFormat = aFormat;

    iMediaId = aId;

    iFileInfo = &aFileInfo;

    iSize = aSize;

    OpenDatabaseL( iInternalDrive )->GetThumbnailIdL( iMediaId );

    iClientStatus = aStatus;

    *iClientStatus = KRequestPending;

    }

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

// DeleteThumbnailsL

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

//

void CGlxtnThumbnailDatabase::DeleteThumbnailsL(const TGlxMediaId& aId,

                const CGlxtnFileInfo& aFileInfo, TRequestStatus* aStatus)

    {

    TRACER("void CGlxtnThumbnailDatabase::DeleteThumbnailsL()");

    if ( iClientStatus )

        {

        User::Leave(KErrNotReady);

        }

    iCurrentOperation = EDeleting;

    iMediaId = aId;

    iFileInfo = &aFileInfo;

    OpenDatabaseL( iInternalDrive )->GetThumbnailIdL( iMediaId );

    iClientStatus = aStatus;

    *iClientStatus = KRequestPending;

    }

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

// CleanupThumbnailsL

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

//

void CGlxtnThumbnailDatabase::CleanupThumbnailsL(TRequestStatus* aStatus)

    {

    TRACER("void CGlxtnThumbnailDatabase::CleanupThumbnailsL()");

    if ( iClientStatus )

        {

        User::Leave(KErrNotReady);

        }

    OpenDatabaseL( iInternalDrive );

    GLX_ASSERT_ALWAYS( iDatabaseArray.Count() > 0,

                    Panic( EGlxPanicLogicError ), "No databases to clean" );

    iDatabaseIndex = 0;

    iDatabaseArray[iDatabaseIndex]->CleanupDatabaseL();

    iClientStatus  = aStatus;

    *iClientStatus = KRequestPending;

    }

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

// IsThumbnailAvailableL

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

//

void CGlxtnThumbnailDatabase::IsThumbnailAvailableL(const TGlxMediaId& aId,

                        const CGlxtnFileInfo& aFileInfo,

                        const TSize& aSize, TRequestStatus* aStatus)

    {

    TRACER("void CGlxtnThumbnailDatabase::IsThumbnailAvailableL()");

    if ( iClientStatus )

        {

        User::Leave(KErrNotReady);

        }

    iCurrentOperation = ECheckingAvailable;

    iMediaId = aId;

    iFileInfo = &aFileInfo;

    iSize = aSize;

    OpenDatabaseL( iInternalDrive )->GetThumbnailIdL( iMediaId );

    iClientStatus = aStatus;

    *iClientStatus = KRequestPending;

    }

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

// StorageCancel

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

//

void CGlxtnThumbnailDatabase::StorageCancel()

    {

    TRACER("void CGlxtnThumbnailDatabase::StorageCancel()");

    TInt count = iDatabaseArray.Count();

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

        {

        iDatabaseArray[i]->Cancel();

        }

    if ( iClientStatus )

        {

        User::RequestComplete(iClientStatus, KErrCancel);

        }

    }

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

// NotifyBackgroundError

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

//

void CGlxtnThumbnailDatabase::NotifyBackgroundError(

                                        const TGlxMediaId& aId, TInt aError )

    {

    TRACER("void CGlxtnThumbnailDatabase::NotifyBackgroundError()");

    if ( iStorageObserver )

        {

        iStorageObserver->BackgroundThumbnailError(aId, aError);

        }

    }

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

// HandleDatabaseError

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

//

void CGlxtnThumbnailDatabase::HandleDatabaseError(TInt aError)

    {

    TRACER("void CGlxtnThumbnailDatabase::HandleDatabaseError()");

    __ASSERT_DEBUG(KErrNone != aError, Panic(EGlxPanicIllegalArgument));

    __ASSERT_DEBUG(iClientStatus, Panic(EGlxPanicNotInitialised));

		// Recover from database file corruption 

		// though the database file opening is successful

		if (aError == KErrCorruptThumbnailDatabase)

	        {

	        RecoverFromDatabaseError();

	        aError = KErrCorrupt;

	        }

		else if (aError == KErrEofThumbnailDatabase)

            {

            RecoverFromDatabaseError();

            aError = KErrEof;

            }

    if ( iClientStatus )

        {

        User::RequestComplete(iClientStatus, aError);

        }

    }

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

// RecoverFromDatabaseError

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

//

void CGlxtnThumbnailDatabase::RecoverFromDatabaseError()

	{

    TRACER("void CGlxtnThumbnailDatabase::RecoverFromDatabaseError()");

    GLX_LOG_INFO("*** Database Corrupted ***");

    TFileName path(iFileInfo->FilePath().Left(KMaxDriveName));

    TInt count = iDatabaseArray.Count();

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

	    {

	    if ( 0 == path.CompareF(iDatabaseArray[i]->Drive()) )

	        {

	        CGlxtnVolumeDatabase* volDb = iDatabaseArray[i];

	        iDatabaseArray.Remove(i);

	        delete volDb;

	        volDb = NULL;

	        break;

            }

        }

    path.Append(iDatabasePath);

    DeleteFile(path);

    }

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

// HandleThumbnailIdFromMediaIdL

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

//

void CGlxtnThumbnailDatabase::HandleThumbnailIdFromMediaIdL(

                                        const TGlxtnThumbnailId& aThumbId )

    {

    TRACER("void CGlxtnThumbnailDatabase::HandleThumbnailIdFromMediaIdL()");

    if ( aThumbId == KGlxIdNone )

        {

        CGlxtnVolumeDatabase* db = OpenDatabaseL(iInternalDrive);

        iThumbId = db->GetThumbnailId();

        // Store thumbnail ID to speed up future lookups

        db->StoreThumbnailIdL(iMediaId, iThumbId);

        }

    else

        {

        iThumbId = aThumbId;

        if(iCurrentOperation == EDeleting)

            {

            OpenDatabaseL( iInternalDrive )->DeleteIdL( iMediaId );

            }

        else

            {

            DoHandleThumbnailIdL();

            }

        }

    }

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

// HandleMediaIdDeletedL

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

//

void CGlxtnThumbnailDatabase::HandleMediaIdDeletedL()

    {

    TRACER("void CGlxtnThumbnailDatabase::HandleMediaIdDeletedL()");

    OpenDatabaseL(iFileInfo->FilePath())->DeleteThumbnailsL(iThumbId);

    }

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

// HandleThumbnailsDeletedL

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

//

void CGlxtnThumbnailDatabase::HandleThumbnailsDeletedL()

    {

    TRACER("void CGlxtnThumbnailDatabase::HandleThumbnailsDeletedL()");

    OpenDatabaseL(iFileInfo->FilePath())->DeleteItemL(iThumbId);

    }

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

// HandleItemsDeletedL

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

//

void CGlxtnThumbnailDatabase::HandleItemDeletedL()

    {

    TRACER("void CGlxtnThumbnailDatabase::HandleItemDeletedL()");

    __ASSERT_DEBUG(iClientStatus, Panic(EGlxPanicNotInitialised));

    if ( iClientStatus )

        {

        User::RequestComplete(iClientStatus, KErrNone);

        }

    }

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

// HandleThumbnailIdFromFilenameL

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

//

void CGlxtnThumbnailDatabase::HandleThumbnailIdFromFilenameL(

                                        const TGlxtnThumbnailId& aThumbId )

    {

    TRACER("void CGlxtnThumbnailDatabase::HandleThumbnailIdFromFilenameL()");

    iThumbId = aThumbId;

    if(iCurrentOperation == EDeleting)

        {

        GLX_LOG_INFO1("GlxtnThumbnailDatabase::HandleThumbnailIdFromFilenameL Current Operation Deleting. aThumbId = %d", aThumbId.Value());

        OpenDatabaseL(iFileInfo->FilePath())->DeleteThumbnailsL(iThumbId);

        }

    else

        {

        GLX_LOG_INFO1("GlxtnThumbnailDatabase::HandleThumbnailIdFromFilenameL Current Operation NOT Deleting. aThumbId = %d", aThumbId.Value());

        // Store thumbnail ID to speed up future lookups

        OpenDatabaseL( iInternalDrive )->StoreThumbnailIdL(

                                                        iMediaId, iThumbId );

        }

    }

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

// HandleThumbnailIdStoredL

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

//

void CGlxtnThumbnailDatabase::HandleThumbnailIdStoredL()

    {

    TRACER("void CGlxtnThumbnailDatabase::HandleThumbnailIdStoredL()");

    DoHandleThumbnailIdL();

    }

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

// HandleThumbnail

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

//

void CGlxtnThumbnailDatabase::HandleThumbnail(

                                TGlxImageDataFormat aFormat, HBufC8* aData )

    {

    TRACER("void CGlxtnThumbnailDatabase::HandleThumbnail()");

    __ASSERT_DEBUG(iClientStatus, Panic(EGlxPanicNotInitialised));

    if ( iClientStatus )

        {

        *iLoadData = aData;

        *iLoadFormat = aFormat;

        User::RequestComplete(iClientStatus, KErrNone);

        }

    else

        {

        // Data loaded, but client doesn't want it (shouldn't ever happen)

        delete aData;

        }

    }

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

// HandleThumbnailStored

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

//

void CGlxtnThumbnailDatabase::HandleThumbnailStored()

    {

    TRACER("void CGlxtnThumbnailDatabase::HandleThumbnailStored()");

    if ( iStorageObserver )

        {

        iStorageObserver->ThumbnailAvailable(iMediaId, iSize);

        }

    __ASSERT_DEBUG(iClientStatus, Panic(EGlxPanicNotInitialised));

    if ( iClientStatus )

        {

        User::RequestComplete(iClientStatus, KErrNone);

        }

    }

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

// HandleAvailabilityChecked

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

//

void CGlxtnThumbnailDatabase::HandleAvailabilityChecked(TInt aResult)

    {

    TRACER("void CGlxtnThumbnailDatabase::HandleAvailabilityChecked()");

    __ASSERT_DEBUG(iClientStatus, Panic(EGlxPanicNotInitialised));

    if ( iClientStatus )

        {

       	GLX_LOG_INFO1("HandleAvailabilityChecked+ aResult= %d [0-Av / 1-NotAv]", aResult);

        User::RequestComplete(iClientStatus, aResult);

        }

    }

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

// HandleDatabaseCleanedL

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

//

void CGlxtnThumbnailDatabase::HandleDatabaseCleanedL()

    {

    TRACER("void CGlxtnThumbnailDatabase::HandleDatabaseCleanedL()");

    // the following three lines of code make the assumption that (in the worst case) (atleast) 

    // some databases are not present in the iDatabaseArray. This would then prevent those 

    // from being cleaned, since only the databases contained in the iDatabaseArray will be cleaned.

    // this will in effect cause those databases to keep growing.

    // The OpenDatabaseL method also adds the database into iDatabaseArray if it 

    // already was not part of it. Here we are using this behaviour of the method

    OpenDatabaseL(DriveInfo::EDefaultPhoneMemory);

    OpenDatabaseL(DriveInfo::EDefaultMassStorage);

    OpenDatabaseL(DriveInfo::EDefaultRemovableMassStorage);

    iDatabaseIndex++;

    if(iDatabaseIndex < iDatabaseArray.Count())

        {

        // cleanup next database

        iDatabaseArray[iDatabaseIndex]->CleanupDatabaseL();

        }

    else

        {

        // Finished cleanup

        __ASSERT_DEBUG(iClientStatus, Panic(EGlxPanicNotInitialised));

        if ( iClientStatus )

            {

            User::RequestComplete(iClientStatus, KErrNone);

            }

        }

    }

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

// DoHandleThumbnailIdL

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

//

void CGlxtnThumbnailDatabase::DoHandleThumbnailIdL()

    {

    TRACER("void CGlxtnThumbnailDatabase::DoHandleThumbnailIdL()");

    CGlxtnVolumeDatabase* db = OpenDatabaseL(iFileInfo->FilePath());

    switch ( iCurrentOperation )

        {