/*
* 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:    Classes for thumbnail-related tasks.
*
*/




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

#include "glxtngeneratethumbnailtask.h"

#include <bitdev.h>
#include <fbs.h>
#include <glxassert.h>
#include <glxlog.h>
#include <glxtracer.h>
#include <glxthumbnail.h>

#include "glxtnfileinfo.h"
#include "glxtnfileutility.h"
#include "glxtnimageutility.h"
#include "glxtnsavethumbnailtask.h"
#include "glxtntaskmanager.h"
#include "glxtnthumbnailrequest.h"
#include "glxtnvideoutility.h"
#include "mglxtnthumbnailcreatorclient.h"

// -----------------------------------------------------------------------------
// NewL
// -----------------------------------------------------------------------------
//
CGlxtnGenerateThumbnailTask* CGlxtnGenerateThumbnailTask::NewL(
        const TGlxThumbnailRequest& aRequestInfo,
        CGlxtnFileUtility& aFileUtility, MGlxtnThumbnailCreatorClient& aClient)
    {
    TRACER("CGlxtnGenerateThumbnailTask::NewL()");
    CGlxtnGenerateThumbnailTask* task
                = new (ELeave) CGlxtnGenerateThumbnailTask(
                                        aRequestInfo, aFileUtility, aClient);
    CleanupStack::PushL(task);
    task->ConstructL(aRequestInfo.iBitmapHandle);
    CleanupStack::Pop( task );
    return task;
    }

// -----------------------------------------------------------------------------
// Constructor
// -----------------------------------------------------------------------------
//
CGlxtnGenerateThumbnailTask::CGlxtnGenerateThumbnailTask(
        const TGlxThumbnailRequest& aRequestInfo,
        CGlxtnFileUtility& aFileUtility, MGlxtnThumbnailCreatorClient& aClient) :
    CGlxtnLoadThumbnailTask( KGlxtnTaskIdGenerateThumbnail,
                            aRequestInfo, aFileUtility, aClient )
	{
    TRACER("CGlxtnGenerateThumbnailTask::CGlxtnGenerateThumbnailTask()");
	}

// -----------------------------------------------------------------------------
// ConstructL
// -----------------------------------------------------------------------------
//
void CGlxtnGenerateThumbnailTask::ConstructL(TInt aBitmapHandle)
	{
    TRACER("CGlxtnGenerateThumbnailTask::ConstructL()");
	CGlxtnLoadThumbnailTask::ConstructL( aBitmapHandle );

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

// -----------------------------------------------------------------------------
// Destructor
// -----------------------------------------------------------------------------
//
CGlxtnGenerateThumbnailTask::~CGlxtnGenerateThumbnailTask() 
	{
    TRACER("CGlxtnGenerateThumbnailTask::~CGlxtnGenerateThumbnailTask()");
	delete iImageUtility;
    delete iVideoUtility;
    delete iImage;
	}

// -----------------------------------------------------------------------------
// SetManager
// -----------------------------------------------------------------------------
//
void CGlxtnGenerateThumbnailTask::SetManager(CGlxtnTaskManager* aManager)
    {
    TRACER("void CGlxtnGenerateThumbnailTask::SetManager()");
    iTaskManager = aManager;
    }

// -----------------------------------------------------------------------------
// DoStartL
// -----------------------------------------------------------------------------
//
TBool CGlxtnGenerateThumbnailTask::DoStartL(TRequestStatus& aStatus)
    {
    TRACER("CGlxtnGenerateThumbnailTask::DoStartL()");
    iInfo = new (ELeave) CGlxtnFileInfo;
    Client().FetchFileInfoL(iInfo, ItemId(), &aStatus);
    iState = EStateFetchingUri;

    return ETrue; // Request has been issued
    } 

// -----------------------------------------------------------------------------
// DoCancel
// -----------------------------------------------------------------------------
//
void CGlxtnGenerateThumbnailTask::DoCancel() 
	{
    TRACER("void CGlxtnGenerateThumbnailTask::DoCancel()");
	CGlxtnLoadThumbnailTask::DoCancel();

	iImageUtility->Cancel();

	if ( iVideoUtility ) 
		{
		iVideoUtility->Cancel();
		}

    iFileUtility.ClearBadFileMarker();
	}

// -----------------------------------------------------------------------------
// DoRunL
// -----------------------------------------------------------------------------
//
TBool CGlxtnGenerateThumbnailTask::DoRunL(TRequestStatus& aStatus) 
	{
    TRACER("TBool CGlxtnGenerateThumbnailTask::DoRunL()");
	TInt error = aStatus.Int();

	TBool active = EFalse;

    if ( KErrNone == error )
        {
        switch ( iState )
            {
            case EStateFetchingUri:
                {
                User::LeaveIfNull(iInfo);
                iBadFileMarkerNotNeededFlag = ETrue;

                iInfo->IdentifyFileL(iVideo, iProtected);
                // leave if file is DRM protected and client has no DRM 
                // capablity
                if ( iProtected && !iDrmAllowed )
                    {
                    User::Leave(KErrAccessDenied);
                    }

                if ( !LoadThumbnailL( aStatus ) )
                    {
                    iBadFileMarkerNotNeededFlag = EFalse;
                    iFileUtility.CheckBadFileListL( iInfo->FilePath() );
                    HighQualityDecodeL( aStatus );
                    }
                active = ETrue;
                }
                break;

            case EStateLoading:
                active = HandleLoadedThumbnailL( aStatus );
                break;

            case EStateDecodingThumbnail:
                // Nothing to do
                break;

            case EStateDecodingImage:
                {
                iImageUtility->FreeDecoder();

                // Resize empty bitmap to required size
                TSize targetSize(iRequestedSize);
                iImageUtility->AdjustSize(targetSize, iImage->SizeInPixels());
                User::LeaveIfError(iThumbnail->Resize(targetSize));

                iImageUtility->FilterImageL(&aStatus, iImage, iImage, iThumbnail);
                iState = EStateFiltering;
                active = ETrue;
                }
                break;

            case EStateFiltering:
                {
                TSize targetSize(iRequestedSize);
                const TSize srcSize = iImage->SizeInPixels();
                iImageUtility->AdjustSize(targetSize, iImage->SizeInPixels());
                iImageUtility->ScaleImageL(aStatus, *iImage, srcSize, *iThumbnail, targetSize);
                iState = EStateScaling;
                active = ETrue;
                }
                break;

            case EStateScaling:
            	{
            	User::LeaveIfError(iThumbnail->SetDisplayMode(KGlxThumbnailDisplayMode));
            	           	
                // Create task to save generated thumbnail
                if ( Storage() && !iInfo->iTemporary
                    && !SizeRequiresDrmRights()
                    && iFileUtility.IsPersistentSize(iRequestedSize) )
                    {
                    CGlxtnSaveThumbnailTask* task
                        = CGlxtnSaveThumbnailTask::NewL(ItemId(), iInfo,
                                        iRequestedSize, iThumbnail, Storage());
                    iThumbnail = NULL;  // Task has ownership
                    iInfo = NULL;       // Task has ownership
                    iTaskManager->AddTaskL(task);
                    }
                break;
            	}

            default:
                GLX_ASSERT_ALWAYS( EFalse, Panic( EGlxPanicIllegalState ),
                            "CGlxtnGenerateThumbnailTask: Illegal state" );
                break;
            }
        }
    else
        {
        if ( EStateLoading == iState )
            {
            // Loading failed - generate new thumbnail instead
            HighQualityDecodeL( aStatus );
            active = ETrue;
            }
        }

    if ( !active )
        {
        if ( !iBadFileMarkerNotNeededFlag )
            {
            iFileUtility.ClearBadFileMarker();
            }
        Client().ThumbnailFetchComplete(ItemId(),
                                        EGlxThumbnailQualityHigh, error);
        }

    return active; 
	}

// -----------------------------------------------------------------------------
// DoRunError
// -----------------------------------------------------------------------------
//
TBool CGlxtnGenerateThumbnailTask::DoRunError(TInt aError)
    {
    TRACER("TBool CGlxtnGenerateThumbnailTask::DoRunError(TInt aError)");
    iFileUtility.ClearBadFileMarker();
    Client().ThumbnailFetchComplete(ItemId(), EGlxThumbnailQualityHigh, aError);

    return EFalse;
    }

// ---------------------------------------------------------------------------
// HighQualityDecodeL
// ---------------------------------------------------------------------------
//
void CGlxtnGenerateThumbnailTask::HighQualityDecodeL(
                                                TRequestStatus& aStatus )
    {
    TRACER("void CGlxtnGenerateThumbnailTask::HighQualityDecodeL()");
    RArray<TSize> targetSizes;
    CleanupClosePushL(targetSizes);
    targetSizes.AppendL( TSize(iRequestedSize) );
    if ( iVideo )
        {
        iVideoUtility = new (ELeave) CGlxtnVideoUtility;
        iVideoUtility->GetVideoFrameL( &aStatus, iImage, iInfo->FilePath(), targetSizes, KGlxThumbnailDisplayMode );
        }
    else
        {
        iImage = iImageUtility->DecodeImageL( aStatus, iInfo->FilePath(),
                                    targetSizes, KGlxThumbnailDisplayMode );
        }
    CleanupStack::PopAndDestroy(&targetSizes);
    iState = EStateDecodingImage;
    }

// -----------------------------------------------------------------------------
// SizeRequiresDrmRights
// -----------------------------------------------------------------------------
//
TBool CGlxtnGenerateThumbnailTask::SizeRequiresDrmRights()
    {
    TRACER("TBool CGlxtnGenerateThumbnailTask::SizeRequiresDrmRights()");
    if ( iProtected )
        {
        if ( iVideo )
            {
            return ETrue;
            }

        // Rights are required if thumbnail doesn't fit in KGlxThumbnailDrmWidth
        // by KGlxThumbnailDrmHeight box either portrait or landscape
        if ( (iRequestedSize.iWidth > KGlxThumbnailDrmWidth
                || iRequestedSize.iHeight > KGlxThumbnailDrmHeight)
            && (iRequestedSize.iWidth > KGlxThumbnailDrmHeight
                || iRequestedSize.iHeight > KGlxThumbnailDrmWidth) )
            {
            return ETrue;
            }

        const TSize& imageSize(iImageUtility->OriginalSize());

        // Rights are required if thumbnail is greater than 25% of image size
        // Due to preserving aspect ratio, this will only happen if both width
        // and height are greater than half the image width and height
        if ( iRequestedSize.iWidth > imageSize.iWidth / 2
            && iRequestedSize.iHeight> imageSize.iHeight / 2 )
            {
            return ETrue;
            }
        }

    return EFalse;
    }