/*
* 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:    Base class for tasks which load thumbnails
*
*/




#include "glxtnloadthumbnailtask.h"

#include <glxassert.h>
#include <glxtracer.h>
#include <glxlog.h>
#include <glxthumbnail.h>
#include <imageconversion.h>
#include <s32mem.h>

#include "glxtnfileinfo.h"
#include "glxtnfileutility.h"
#include "glxtnimagedecoderfactory.h"
#include "glxtnthumbnailrequest.h"
#include "mglxtnstorage.h"



// ---------------------------------------------------------------------------
// Constructor
// ---------------------------------------------------------------------------
//
CGlxtnLoadThumbnailTask::CGlxtnLoadThumbnailTask( const TGlxtnTaskId& aId,
                                    const TGlxThumbnailRequest& aRequestInfo,
                                    CGlxtnFileUtility& aFileUtility,
                                    MGlxtnThumbnailCreatorClient& aClient) :
    CGlxtnClientTask( aId, aRequestInfo.iId, aClient ),
    iFileUtility( aFileUtility ), iRequestedSize( aRequestInfo.iSizeClass ),
    iDrmAllowed( aRequestInfo.iDrmAllowed )
    {
    TRACER("CGlxtnLoadThumbnailTask::CGlxtnLoadThumbnailTask()");
    }

// ---------------------------------------------------------------------------
// Destructor
// ---------------------------------------------------------------------------
//
CGlxtnLoadThumbnailTask::~CGlxtnLoadThumbnailTask() 
    {
    TRACER("CGlxtnLoadThumbnailTask::~CGlxtnLoadThumbnailTask()");
    delete iDecoder;
    delete iThumbnail;
    delete iThumbData;
    delete iInfo;
    }

// -----------------------------------------------------------------------------
// ConstructL
// -----------------------------------------------------------------------------
//
void CGlxtnLoadThumbnailTask::ConstructL( TInt aBitmapHandle )
    {
    TRACER("void CGlxtnLoadThumbnailTask::ConstructL()");
    // Duplicate the client's bitmap
    iThumbnail = new (ELeave) CFbsBitmap();
    User::LeaveIfError( iThumbnail->Duplicate( aBitmapHandle ) );
    }

// ---------------------------------------------------------------------------
// DoCancel
// ---------------------------------------------------------------------------
//
void CGlxtnLoadThumbnailTask::DoCancel()
    {
    TRACER("void CGlxtnLoadThumbnailTask::DoCancel()");
    if ( iDecoder )
        {
        iDecoder->Cancel();
        }

    Storage()->StorageCancel();
    }

// ---------------------------------------------------------------------------
// LoadThumbnailL
// ---------------------------------------------------------------------------
//
TBool CGlxtnLoadThumbnailTask::LoadThumbnailL( TRequestStatus& aStatus )
    {
    TRACER("TBool CGlxtnLoadThumbnailTask::LoadThumbnailL()");
    GLX_ASSERT_DEBUG( iInfo, Panic( EGlxPanicNullPointer ), "No file info" );

    if ( Storage() && iFileUtility.IsPersistentSize( iRequestedSize ) )
        {
        Storage()->LoadThumbnailDataL( iThumbData, iFormat, ItemId(),
                                    *iInfo, iRequestedSize, &aStatus );
        iState = EStateLoading;

        return ETrue;
        }

    return EFalse;
    }

// ---------------------------------------------------------------------------
// HandleLoadedThumbnailL
// ---------------------------------------------------------------------------
//
TBool CGlxtnLoadThumbnailTask::HandleLoadedThumbnailL(TRequestStatus& aStatus)
    {
    TRACER("CGlxtnLoadThumbnailTask::HandleLoadedThumbnailL()");
	TBool active = EFalse;

    User::LeaveIfNull( iThumbData );

    switch ( iFormat )
        {
        case EGlxIDF_Bitmap:
            {
            CFbsBitmap* bitmap = new (ELeave) CFbsBitmap;
            CleanupStack::PushL( bitmap );

            RDesReadStream stream( *iThumbData );
            CleanupClosePushL( stream );
            stream >> *bitmap;
            CleanupStack::PopAndDestroy( &stream );

            User::LeaveIfError( iThumbnail->Resize( bitmap->SizeInPixels() ) );

            CFbsBitmapDevice* device = CFbsBitmapDevice::NewL( iThumbnail );
            CleanupStack::PushL( device );
            CFbsBitGc* context = NULL;
            User::LeaveIfError( device->CreateContext( context ) );
            CleanupStack::PushL( context );

            context->BitBlt( TPoint(), bitmap );

            CleanupStack::PopAndDestroy( context ); 
            CleanupStack::PopAndDestroy( device );

            CleanupStack::PopAndDestroy( bitmap );
            }
            break;

    	case EGlxIDF_JPEG:
            iDecoder = GlxtnImageDecoderFactory::NewL(
                                    iFileUtility.FsSession(), *iThumbData );
            DecodeThumbnailL( aStatus, EFalse );
            active = ETrue;
            break;

        default:
            User::Leave( KErrNotSupported );
            break;
        }

    return active;
    }

// ---------------------------------------------------------------------------
// DecodeThumbnailL
// ---------------------------------------------------------------------------
//
void CGlxtnLoadThumbnailTask::DecodeThumbnailL( TRequestStatus& aStatus,
                                                TBool /*aScaleBitmap*/ )
    {
    TRACER("CGlxtnLoadThumbnailTask::DecodeThumbnailL()");
    GLX_ASSERT_DEBUG( iDecoder, Panic( EGlxPanicNullPointer ), "No decoder" );

    // Resize empty bitmap to required size
    TSize thumbSize( iDecoder->FrameInfo().iOverallSizeInPixels );
    GLX_DEBUG3("CGlxtnLoadThumbnailTask::DecodeThumbnailL() thumbSize w(%d) h(%d)", 
            thumbSize.iWidth, thumbSize.iHeight);
   
    // Always adjust the target bitmap size 
	// as Exif thumbnail could be bigger in size
    TSize targetSize = iRequestedSize;
    if( (thumbSize.iWidth <= targetSize.iWidth ) && 
	    (thumbSize.iHeight <= targetSize.iHeight ) )
         {
         targetSize.iWidth  = thumbSize.iWidth;
         targetSize.iHeight = thumbSize.iHeight;
         }
    else if ( targetSize.iHeight * thumbSize.iWidth
             < targetSize.iWidth * thumbSize.iHeight )
         {
         // Source has taller aspect than target so reduce target width
         targetSize.iWidth =  ( ( targetSize.iHeight * thumbSize.iWidth )
                                 / (  thumbSize.iHeight ) );
         }
    else
         {
         // Source has wider aspect than target so reduce target height
         targetSize.iHeight = (targetSize.iWidth * thumbSize.iHeight)
                                 / thumbSize.iWidth;
         }
    GLX_DEBUG3("CGlxtnLoadThumbnailTask::DecodeThumbnailL() targetSize w(%d) h(%d)", 
            targetSize.iWidth, targetSize.iHeight);
     
    User::LeaveIfError( iThumbnail->Resize(targetSize) );

    iDecoder->Convert( &aStatus, *iThumbnail );
    iState = EStateDecodingThumbnail;
    }