/*

* 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 <pathinfo.h>

#include "glxtnfileinfo.h"

#include "glxtnvolumedatabase.h"

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

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

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

    if ( iClientStatus )

        {

        User::RequestComplete(iClientStatus, aError);

        }

    }

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

// HandleThumbnailIdFromMediaIdL

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

//

void CGlxtnThumbnailDatabase::HandleThumbnailIdFromMediaIdL(

                                        const TGlxtnThumbnailId& aThumbId )

    {

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

    if ( aThumbId == KGlxIdNone )

        {

        // Not found in Ids table - check the Items table

        OpenDatabaseL(iFileInfo->FilePath())->GetThumbnailIdL(iFileInfo);

        }

    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 )

        {

        User::RequestComplete(iClientStatus, aResult);

        }

    }

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

// HandleDatabaseCleanedL

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

//

void CGlxtnThumbnailDatabase::HandleDatabaseCleanedL()

    {

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

    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 )

        {

        case ELoading:

            db->GetThumbnailL(iThumbId, iSize);

            break;

        case ESaving:

            db->StoreThumbnailL(iThumbId, iSize, iSaveFormat, iSaveData);

            break;

        case ECheckingAvailable:

            db->CheckAvailableL(iThumbId, iSize);

            break;

        default:

            Panic(EGlxPanicIllegalState);

            break;

        }

    }

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

// OpenDatabaseL

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

//

CGlxtnVolumeDatabase* CGlxtnThumbnailDatabase::OpenDatabaseL(const TDesC& aDrive)

    {

    TRACER("CGlxtnVolumeDatabase* CGlxtnThumbnailDatabase::OpenDatabaseL()");

    TPtrC drive(aDrive.Left(KMaxDriveName));

    TInt count = iDatabaseArray.Count();

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

        {

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

            {

            return iDatabaseArray[i];

            }

        }

    // Get path of DB on specified drive

    TFileName path(drive);

    path.Append(iDatabasePath);

    CGlxtnVolumeDatabase* database = CGlxtnVolumeDatabase::NewLC(*this, iFs, path);

    iDatabaseArray.AppendL(database);

    CleanupStack::Pop(database);

    return database;

    }

//  End of File