/*

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

#include "ccappcommlauncherimagedecoding.h"

const TInt KDelay = 500000; // 0.5s

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

// Two-phase construction

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

//

CCCAppCommLauncherImageDecoding* CCCAppCommLauncherImageDecoding::NewL(

        CCCAppCommLauncherHeaderControl* aHeader, const TDesC8* aBitmapData, const TDesC* aImageFile)

    {

    CCCAppCommLauncherImageDecoding* self = new (ELeave) CCCAppCommLauncherImageDecoding(aHeader);

    CleanupStack::PushL(self);

    self->ConstructL(aBitmapData, aImageFile);

    CleanupStack::Pop(self);

    return self;

    }

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

// First phase (C++) constructor

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

//

CCCAppCommLauncherImageDecoding::CCCAppCommLauncherImageDecoding(CCCAppCommLauncherHeaderControl* aHeader) : 

CActive( CActive::EPriorityStandard ), iHeader(aHeader)

    { 

    CActiveScheduler::Add(this); 

    }

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

// ConstructL, second phase constructor

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

//

void CCCAppCommLauncherImageDecoding::ConstructL(const TDesC8* aBitmapData, const TDesC* aImageFile)

    {

    if ( aImageFile )

        {

        iImageFullName = aImageFile->AllocL();

        }

    if ( aBitmapData )

        {

        iBitmapData = aBitmapData->AllocL();

        }

    User::LeaveIfError( iFs.Connect() );

    iTimer.CreateLocal();

    }

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

// Destructor

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

//

CCCAppCommLauncherImageDecoding::~CCCAppCommLauncherImageDecoding()

    {

    DoCancel();

    if (iBitmap)

        {

        delete iBitmap;

        iBitmap = NULL;

        }

    if (iBitmapData)

        {

        delete iBitmapData;

        iBitmapData = NULL;

        }

    if (iImageFullName)

        {

        delete iImageFullName;

        }

    iFs.Close();

    iTimer.Close();

    }

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

// Starts the decoding process

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

//

void CCCAppCommLauncherImageDecoding::StartL( TSize aImageSize )

    {

    iDecoderState = ECcaConvertThumbnailImage;

    iBitmapSize = aImageSize;

    CreateBitmapL();

    }

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

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

// completed.

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

//

void CCCAppCommLauncherImageDecoding::RunL() 

    {

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

    switch ( iDecoderState )

	    {

	    case ECcaConvertThumbnailImage:

	    	{

	        iDecoderState = ECcaScaleThumbnail;

	        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

	        iHeader->SetBitmap( 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 );

	        ScaleBitmapL();

	        break;

	    	}

	    default:

	        break;

	    }

    }

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

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

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

//

void CCCAppCommLauncherImageDecoding::DoCancel()

    { 

    if (iImgDecoder)

        {

        iImgDecoder->Cancel();

        delete iImgDecoder;

        iImgDecoder = NULL;

        }

    if ( iBitmapScaler )

        {

        iBitmapScaler->Cancel();

        delete iBitmapScaler;

        iBitmapScaler = NULL;

        }

    iTimer.Cancel();

    }

void CCCAppCommLauncherImageDecoding::ScaleBitmapL()

    {   

    iBitmapScaler = CBitmapScaler::NewL();

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

    SetActive();

    }

void CCCAppCommLauncherImageDecoding::CreateBitmapL()

    {

    if ( iDecoderState == ECcaConvertThumbnailImage )

        {

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

        }

    else if ( iDecoderState == ECcaConvertImageFromFile )

        {

        // leaaves if file doesn't exist

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

        if ( initDecoder )

        	{

	        delete iBitmapScaler;

	        iBitmapScaler = NULL;

	        delete iImgDecoder;

	        iImgDecoder = NULL;

        	return;

        	}

        }

   if ( !iBitmap )

       {

       TFrameInfo info = iImgDecoder->FrameInfo();

       iBitmap = new ( ELeave ) CFbsBitmap;

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

       }

    iStatus = KRequestPending;

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

    SetActive();

    }