/*

* Copyright (c) 2008-2008 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:  Implementation of the utility class for asynchronously decoding the header thumbnail image

*

*/

#include "ccappimagedecoding.h"

#include <bitmaptransforms.h>

#include <Pbk2PresentationUtils.h>

#include <imageconversion.h>

namespace{

const TInt KDelay = 500000; // 0.5s

inline TSize ScaledLoadSize( const TSize& aOriginalSize, TInt aScaleFactor )

    {

    // Divide original size with scalefactor

    // Round always up if result is not integer

    return TSize( aOriginalSize.iWidth / aScaleFactor + ( aOriginalSize.iWidth % aScaleFactor ? 1 : 0 ),

               aOriginalSize.iHeight / aScaleFactor + ( aOriginalSize.iHeight % aScaleFactor ? 1 : 0 ) );

    }

} // namespace

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

// Two-phase construction

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

//

EXPORT_C CCCAppImageDecoding* CCCAppImageDecoding::NewL(

        MCCAppImageDecodingObserver& aObserver,

        RFs& aFs,

        HBufC8* aBitmapData, 

        HBufC* aImageFile)

    {

    CCCAppImageDecoding* self = new (ELeave) CCCAppImageDecoding(

            aObserver, aFs, aBitmapData, aImageFile);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);    

    self->iBitmapData = aBitmapData;   // take ownship

    self->iImageFullName = aImageFile;  // take ownship

    return self;

    }

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

// First phase (C++) constructor

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

//

inline CCCAppImageDecoding::CCCAppImageDecoding(

        MCCAppImageDecodingObserver& aObserver,

        RFs& aFs,

        HBufC8* aBitmapData, 

        HBufC* aImageFile) : 

CActive( CActive::EPriorityStandard ), 

iObserver(aObserver), 

iFs(aFs)

    { 

    CActiveScheduler::Add(this); 

    }

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

// Second phase (C++) constructor

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

//

inline void CCCAppImageDecoding::ConstructL()

    {

    User::LeaveIfError( iTimer.CreateLocal() );

    }

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

// Destructor

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

//

CCCAppImageDecoding::~CCCAppImageDecoding()

    {

    Cancel();

    if (iImgDecoder)

        {

        iImgDecoder->Cancel();

        delete iImgDecoder;

        }

    if (iBitmapScaler)

        {

        iBitmapScaler->Cancel();

        delete iBitmapScaler;

        }

    delete iBitmap;

    delete iBitmapData;

    delete iImageFullName;

    iTimer.Close();

    }

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

// Starts the decoding process

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

//

EXPORT_C void CCCAppImageDecoding::StartL( const TSize& aImageSize )

    {

    Cancel();

    iDecoderState = ECcaConvertThumbnailImage;

    iBitmapSize = aImageSize;

    CreateBitmapL();

    }

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

// Called by the active object framework when the decoding (request) is

// completed.

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

//

void CCCAppImageDecoding::RunL() 

    {

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

    switch ( iDecoderState )

	    {

	    case ECcaConvertThumbnailImage:

	    	{

	        iDecoderState = ECcaScaleThumbnail;

	        CropBitmapL();

	        ScaleBitmapL();

	        break;

	    	}

	    case ECcaScaleThumbnail:

	    	{

	    	if ( iImageFullName )

	    		{

	            iDecoderState = ECcaReadImageFromFile;

	            SetPriority( EPriorityIdle );

	            iTimer.After( iStatus, KDelay ); 

	            SetActive();

	    		}

	    	// don't break here

	    	}

	    case ECcaScaleImage:

	    	{

	        // Ownership of the bitmap is transferred

	        iObserver.BitmapReadyL( iBitmap );

	        iBitmap = NULL;

	        delete iBitmapScaler;

	        iBitmapScaler = NULL;

	        delete iImgDecoder;

	        iImgDecoder = NULL;

	        break;

	    	}

	    case ECcaReadImageFromFile:

	    	{

	    	if ( iImageFullName )

	    		{

	            iDecoderState = ECcaConvertImageFromFile;

	            CreateBitmapL();

	    		}

	    	break;

	    	}

	    case ECcaConvertImageFromFile:

	    	{

	        iDecoderState = ECcaScaleImage;

	        SetPriority( EPriorityStandard );

            CropBitmapL();

	        ScaleBitmapL();

	        break;

	    	}

	    default:

	        break;

	    }

    }

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

// Called when the decoding (request) is cancelled for some reason.

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

//

void CCCAppImageDecoding::DoCancel()

    { 

    if (iImgDecoder)

        {

        iImgDecoder->Cancel();

        delete iImgDecoder;

        iImgDecoder = NULL;

        }

    if ( iBitmapScaler )

        {

        iBitmapScaler->Cancel();

        delete iBitmapScaler;

        iBitmapScaler = NULL;

        }

    iTimer.Cancel();

    }

void CCCAppImageDecoding::CropBitmapL()

    {

    TSize dummy;

    Pbk2PresentationImageUtils::CropImageL(

            *iBitmap, 

            Pbk2PresentationImageUtils::ELandscapeCropping, 

            dummy );

    }

void CCCAppImageDecoding::ScaleBitmapL()

    {   

    iBitmapScaler = CBitmapScaler::NewL();

    iBitmapScaler->Scale( &iStatus, *iBitmap, iBitmapSize );

    SetActive();

    }

void CCCAppImageDecoding::CreateBitmapL()

    {

    TInt initDecoder( KErrGeneral );

    if ( iDecoderState == ECcaConvertThumbnailImage && iBitmapData )

        {

        iImgDecoder = CImageDecoder::DataNewL( iFs, *iBitmapData, CImageDecoder::EOptionAlwaysThread );

        initDecoder = KErrNone;

        }

    else if ( iDecoderState == ECcaConvertImageFromFile && iImageFullName )

        {

        // leaaves if file doesn't exist

        TRAP ( initDecoder, iImgDecoder = CImageDecoder::FileNewL( iFs, *iImageFullName, CImageDecoder::EOptionAlwaysThread ) );

        }

    if ( initDecoder )

        {

        delete iBitmapScaler;

        iBitmapScaler = NULL;

        delete iImgDecoder;

        iImgDecoder = NULL;

        return;

        }

   if ( !iBitmap )

       {

       const TFrameInfo info = iImgDecoder->FrameInfo();

	   // calculate size for the bitmap

       const TSize size( iBitmapSize );

       TSize loadSize( info.iOverallSizeInPixels );

       for( TInt i = 1 ; i < 9 ; i = i * 2 )

           {

		   // we can use scalers 1:1 1:2 1:4 1:8

           TSize calcSize( ScaledLoadSize( info.iOverallSizeInPixels, i ) );

           if( calcSize.iHeight < size.iHeight ||

               calcSize.iWidth < size.iWidth )

               {

               break;

               }

           loadSize = calcSize;

           }

       iBitmap = new ( ELeave ) CFbsBitmap;

       User::LeaveIfError( iBitmap->Create( loadSize, info.iFrameDisplayMode ));

       }

    iStatus = KRequestPending;

    iImgDecoder->Convert( &iStatus, *iBitmap );

    SetActive();

    }