/*

* 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 background generation task implementation

*

*/

/**

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

 */

// INCLUDE FILES

#include "glxtnbackgroundgenerationtask.h"

#include <fbs.h>

#include <glxassert.h>

#include <glxtracer.h>

#include <glxthumbnail.h>

#include "glxtnfileinfo.h"

#include "glxscreenresolutions.h"

#include "glxtnfileutility.h"

#include "glxtnimageutility.h"

#include "glxtnvideoutility.h"

#include "mglxtnstorage.h"

#include "mglxtnthumbnailcreatorclient.h"

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

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

// CGlxtnBackgroundGenerationTask::CGlxtnBackgroundGenerationTask

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

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

//

CGlxtnBackgroundGenerationTask::CGlxtnBackgroundGenerationTask(

                    const TGlxMediaId& iItemId, CGlxtnFileUtility& aFileUtility,

                    MGlxtnThumbnailCreatorClient& aClient, 

                    CGlxSettingsModel::TSupportedOrientations aSupportedOrientations) :

    CGlxtnSaveThumbnailTask(KGlxtnTaskIdBackgroundThumbnailGeneration,

                            iItemId, aClient.ThumbnailStorage()),

    iClient(&aClient), iFileUtility(aFileUtility),

    iSupportedOrientations(aSupportedOrientations)

    {

    TRACER("CGlxtnBackgroundGenerationTask::CGlxtnBackgroundGenerationTask()");

    // Background task is always low priority

    SetPriority(EPriorityLow);

    }

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

// CGlxtnBackgroundGenerationTask::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CGlxtnBackgroundGenerationTask::ConstructL()

    {

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

    iImageUtility = new (ELeave) CGlxtnImageUtility(iFileUtility.FsSession());

    }

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

// CGlxtnBackgroundGenerationTask::NewL

// Two-phased constructor.

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

//

CGlxtnBackgroundGenerationTask* CGlxtnBackgroundGenerationTask::NewL(

                    const TGlxMediaId& iItemId, CGlxtnFileUtility& aFileUtility,

                    MGlxtnThumbnailCreatorClient& aClient, 

                    CGlxSettingsModel::TSupportedOrientations aSupportedOrientations)

    {

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

    CGlxtnBackgroundGenerationTask* self

            = new (ELeave) CGlxtnBackgroundGenerationTask(

                                                iItemId, aFileUtility, aClient,

                                                aSupportedOrientations);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// Destructor

CGlxtnBackgroundGenerationTask::~CGlxtnBackgroundGenerationTask()

    {

    TRACER("Destructor CGlxtnBackgroundGenerationTask::~CGlxtnBackgroundGenerationTask()");

    delete iImageUtility;

    delete iVideoUtility;

    delete iImage;

    delete iFilteredImage;

    iSizes.Close();

    }

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

// DoStartL

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

//

TBool CGlxtnBackgroundGenerationTask::DoStartL(TRequestStatus& aStatus)

    {

    TRACER("CGlxtnBackgroundGenerationTask::DoStartL()");

    // Sizes to generate, largest first

    iSizes.AppendL(TSize(KGlxThumbnailLargeWidth, KGlxThumbnailLargeHeight));

    iSizes.AppendL(TSize(KGlxThumbnailSmallWidth, KGlxThumbnailSmallHeight));

    if( CGlxSettingsModel::ELandscapeAndPortrait == iSupportedOrientations )

        {

        iSizes.AppendL(TSize(KGlxThumbnailPortraitWidth, KGlxThumbnailPortraitHeight));

        }

    iFileInfo = new (ELeave) CGlxtnFileInfo;

    iClient->FetchFileInfoL(iFileInfo, ItemId(), &aStatus);

    iState = EStateFetchingUri;

    return ETrue; // Request has been issued

    }

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

// DoCancel

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

//

void CGlxtnBackgroundGenerationTask::DoCancel()

    {

    TRACER("void CGlxtnBackgroundGenerationTask::DoCancel()");

    CGlxtnSaveThumbnailTask::DoCancel();

    Storage()->NotifyBackgroundError(ItemId(), KErrCancel);

    if ( iClient && EStateFetchingUri == iState )

        {

        iClient->CancelFetchUri(ItemId());

        }

	iImageUtility->Cancel();

	if ( iVideoUtility ) 

		{

		iVideoUtility->Cancel();

		}

    iFileUtility.ClearBadFileMarker();

    }

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

// DoRunL

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

//

TBool CGlxtnBackgroundGenerationTask::DoRunL(TRequestStatus& aStatus)

    {

    TRACER("TBool CGlxtnBackgroundGenerationTask::DoRunL()");

    User::LeaveIfError(aStatus.Int());

    TBool active = EFalse;

    switch ( iState )

        {

        case EStateFetchingUri:

            {

            iImageDecoded = EFalse;

            iBadFileMarkerNotNeededFlag = ETrue;

            // Client is no longer needed

            iClient->ThumbnailFetchComplete(ItemId(),

                                        EGlxThumbnailQualityHigh, KErrNone);

            iClient = NULL;

            User::LeaveIfNull(iFileInfo);

            TBool isVideo, isProtected;

            iFileInfo->IdentifyFileL(isVideo, isProtected);

            // if DRM protected leave

            // assume DRM capablity not present

            if(isProtected)

                {

                User::Leave(KErrAccessDenied);

                }

            active = CheckNextL(aStatus);

            }

            break;

        case EStateDecoding:

            iImageUtility->FreeDecoder();

            iImageDecoded = ETrue;

            FilterThumbnailL(aStatus);

            active = ETrue;

            break;

        case EStateFiltering:

            ScaleThumbnailL(aStatus);

            active = ETrue;

            break;

        case EStateSaving:

            active = ProcessNextL(aStatus);

            break;

        case EStateChecking:

            if ( KGlxThumbnailNotAvailable == aStatus.Int() )

                {

                iTodoSizes.AppendL(iSize);

                }

            active = CheckNextL(aStatus);

            break;

        case EStateScaling:

            EncodeThumbnailL(aStatus);

            active = ETrue;

            break;

        case EStateEncoding:

            SaveThumbnailL(aStatus);

            active = ETrue;

            break;

        default:

            GLX_ASSERT_ALWAYS( EFalse, Panic( EGlxPanicIllegalState ),

                            "CGlxtnBackgroundGenerationTask: Illegal state" );

            break;

        }

    if ( !active )

        {

        if( !iBadFileMarkerNotNeededFlag )

            {

            iFileUtility.ClearBadFileMarker();

            }

        // Send notification that we've finished

        Storage()->NotifyBackgroundError( ItemId(), KErrNone );

        }

    return active;  // Task is complete

    }

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

// DoRunError

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

//

TBool CGlxtnBackgroundGenerationTask::DoRunError(TInt aError)

    {

    TRACER("CGlxtnBackgroundGenerationTask::DoRunError()");

    if( !iBadFileMarkerNotNeededFlag )

        {

        iFileUtility.ClearBadFileMarker();

        }

    if ( iClient )

        {

        iClient->ThumbnailFetchComplete(

                                ItemId(), EGlxThumbnailQualityHigh, aError);

        }

    else

        {

        Storage()->NotifyBackgroundError(ItemId(), aError);

        }

    return EFalse;  // Task is complete

    }

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

// CheckNextL

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

//

TBool CGlxtnBackgroundGenerationTask::CheckNextL(TRequestStatus& aStatus)

    {

    TRACER("CGlxtnBackgroundGenerationTask::CheckNextL()");

    if ( iSizes.Count() == 0 )

        {

        return ProcessNextL(aStatus);

        }

    iSize = iSizes[0];

    iSizes.Remove(0);

    Storage()->IsThumbnailAvailableL(ItemId(), *iFileInfo, iSize, &aStatus);

    iState = EStateChecking;

    return ETrue;

    }

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

// ProcessNextL

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

//

TBool CGlxtnBackgroundGenerationTask::ProcessNextL(TRequestStatus& aStatus)

    {

    TRACER("TBool CGlxtnBackgroundGenerationTask::ProcessNextL()");

    if ( iTodoSizes.Count() == 0 )

        {

        return EFalse;

        }

    iSize = iTodoSizes[0];

    if( iImageDecoded )

        {

        FilterThumbnailL(aStatus);

        }

    else

        {

        DecodeImageL(aStatus);

        }

    return ETrue;

    }

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

// FilterThumbnailL

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

//

void CGlxtnBackgroundGenerationTask::FilterThumbnailL(TRequestStatus& aStatus)

    {

    TRACER("void CGlxtnBackgroundGenerationTask::FilterThumbnailL()");

    // Create thumbnail bitmap of required size

    TSize targetSize(iTodoSizes[0]);

    iTodoSizes.Remove(0);

    iImageUtility->AdjustSize(targetSize, iImage->SizeInPixels());

    delete iThumbnail;

    iThumbnail = NULL;

    iThumbnail = new (ELeave) CFbsBitmap;

    User::LeaveIfError(iThumbnail->Create(targetSize, KGlxThumbnailDisplayMode));

    iImageUtility->FilterImageL(&aStatus, iImage, iFilteredImage, iThumbnail);

    iState = EStateFiltering;

    }

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

// ScaleThumbnailL

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

//

void CGlxtnBackgroundGenerationTask::ScaleThumbnailL(TRequestStatus& aStatus)

    {

    TRACER("void CGlxtnBackgroundGenerationTask::ScaleThumbnailL()");

    TSize targetSize(iSize);

    const TSize srcSize = iImage->SizeInPixels();

    iImageUtility->AdjustSize(targetSize, iImage->SizeInPixels());

    iImageUtility->ScaleImageL(aStatus, *iImage, srcSize, *iThumbnail, targetSize);

    iState = EStateScaling;

    }

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

// DecodeImageL

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

//

void CGlxtnBackgroundGenerationTask::DecodeImageL(TRequestStatus& aStatus)

    {

    TRACER("void CGlxtnBackgroundGenerationTask::DecodeImageL()");

    iBadFileMarkerNotNeededFlag = EFalse;

    iFileUtility.CheckBadFileListL( iFileInfo->FilePath() );

    TBool isVideo, isProtected;

    iFileInfo->IdentifyFileL(isVideo, isProtected);

    if ( isVideo )

        {

        iVideoUtility = new (ELeave) CGlxtnVideoUtility;

        iVideoUtility->GetVideoFrameL(&aStatus, iImage,

                                        iFileInfo->FilePath(), iTodoSizes, KGlxThumbnailDisplayMode);

        }

    else

        {

        iImage = iImageUtility->DecodeImageL(aStatus,

                    iFileInfo->FilePath(), iTodoSizes, KGlxThumbnailDisplayMode);

        }

    delete iFilteredImage;

    iFilteredImage = NULL;

    iState = EStateDecoding;

    }

//  End of File