/*
* Copyright (c) 2002-2004 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "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:    Offers interface for loading and converting images.*
*/




// INCLUDE FILES
#include <gulicon.h>					// CGulIcon
#include <imageconversion.h>			// CImageDecoder
#include <AknIconArray.h>				// CAknIconArray
#include "IptvLiveLogger.h"				// Live TV logging macros
#include <AknIconUtils.h>				// AknIconUtils
#include <AknsUtils.h>

#include "CIptvLiveUIImageHandler.h"	// CIptvLiveUIImageHandler
#include "MIptvLiveUIImageObserver.h"	// MIptvLiveUIImageObserver


// FORWARD DECLARATIONS

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

// ---------------------------------------------------------
// CIptvLiveUIImageHandler::NewL
// Two-phased constructor.
// ---------------------------------------------------------
//
EXPORT_C CIptvLiveUIImageHandler* CIptvLiveUIImageHandler::NewL( 
										MIptvLiveUIImageObserver& aObserver )
    {
    LIVE_TV_TRACE1(_L("CIptvLiveUIImageHandler::NewL() in"));
    CIptvLiveUIImageHandler* self = 
						new ( ELeave ) CIptvLiveUIImageHandler( aObserver );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }

// -----------------------------------------------------------------------------
// CIptvLiveUIImageHandler::ConstructL()
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CIptvLiveUIImageHandler::ConstructL()
    {
    LIVE_TV_TRACE1(_L("CIptvLiveUIImageHandler::ConstructL() in"));
	User::LeaveIfError( iFs.Connect() );
    LIVE_TV_TRACE1(_L("CIptvLiveUIImageHandler::ConstructL() out"));
    }
    
// -----------------------------------------------------------------------------
// CIptvLiveUIImageHandler::CIptvLiveUIImageHandler()
// C++ default constructor can NOT contain any code, that might leave.
// -----------------------------------------------------------------------------
//
CIptvLiveUIImageHandler::CIptvLiveUIImageHandler( 
										MIptvLiveUIImageObserver& aObserver ) 
	: CActive( EPriorityNormal ), iObserver( &aObserver ), 
	iImageDecoder( NULL ), iBitmap( NULL )
    {
    LIVE_TV_TRACE1(_L("CIptvLiveUIImageHandler::CIptvLiveUIImageHandler() in"));
    CActiveScheduler::Add( this );
    LIVE_TV_TRACE1(_L("CIptvLiveUIImageHandler::CIptvLiveUIImageHandler() out"));
    }

// -----------------------------------------------------------------------------
// CIptvLiveUIImageHandler::~CIptvLiveUIImageHandler()
// Destructor.
// -----------------------------------------------------------------------------
//
EXPORT_C CIptvLiveUIImageHandler::~CIptvLiveUIImageHandler()
    {
    LIVE_TV_TRACE1(_L("CIptvLiveUIImageHandler::~CIptvLiveUIImageHandler() in"));
    Cancel();
    iObserver = NULL;
	delete iImageDecoder;
	delete iBitmap;
	iFs.Close();
    LIVE_TV_TRACE1(_L("CIptvLiveUIImageHandler::~CIptvLiveUIImageHandler() out"));    	
    }

// -----------------------------------------------------------------------------
// CIptvLiveUIImageHandler::LoadImageL(). Asynchronous, 
// MIptvLiveUIImageObserver::ImageReadyL() when loading and converting is complete.
// -----------------------------------------------------------------------------
//
EXPORT_C void CIptvLiveUIImageHandler::LoadImageL( const TDesC& aFilePath )
    {
    LIVE_TV_TRACE1(_L("CIptvLiveUIImageHandler::LoadImageL() in"));
	if ( IsActive() ) 
		{
		LIVE_TV_TRACE1(_L("CIptvLiveUIImageHandler::LoadImageL() IS ACTIVE, leave with KErrInUse"));
		User::Leave( KErrInUse );
		}
	if ( iImageDecoder ) 
		{
		iImageDecoder->Cancel();
		delete iImageDecoder;
		iImageDecoder = NULL;
		}
	// Create new image decoder 
	iImageDecoder = CImageDecoder::FileNewL( iFs, aFilePath );

	// Create bitmap
	if ( iBitmap ) 
		{
		delete iBitmap;
		iBitmap = NULL;
		}
	TFrameInfo info = iImageDecoder->FrameInfo();
	iBitmap = new ( ELeave ) CFbsBitmap;
	TInt err = iBitmap->Create( info.iOverallSizeInPixels, 
										 info.iFrameDisplayMode );
	if ( err == KErrNone )
		{
		// Start converting the image
		iImageDecoder->Convert( &iStatus, *iBitmap );
		SetActive();	
		}
	else
		{
		delete iImageDecoder;
		iImageDecoder = NULL;
		delete iBitmap;
		iBitmap = NULL;
		User::Leave( err );
		}
	
    LIVE_TV_TRACE1(_L("CIptvLiveUIImageHandler::LoadImageL() out"));
   	}
    
// -----------------------------------------------------------------------------
// CIptvImageLoader::LoadIconL
// Loads icon to the given array.
// -----------------------------------------------------------------------------
//
EXPORT_C void CIptvLiveUIImageHandler::LoadIconL( CAknIconArray* aIcons, 
									const TInt aIconIndex, 
                                    const TInt aMaskIndex, const TSize& aIconSize,
                                    const TDesC& aMifFileName, TBool aInsert )
    {
	LIVE_TV_TRACE1(_L("CIptvLiveUIImageHandler::LoadIconL() in") );
    CFbsBitmap* bitmap = NULL;
    CFbsBitmap* mask = NULL;
        
    AknIconUtils::CreateIconLC( bitmap, mask, aMifFileName, 
                                aIconIndex, aMaskIndex );

    CGulIcon* icon = CGulIcon::NewL( bitmap, mask );
    CleanupStack::PushL( icon );

    // ownership of bitmap and mask transferred to icon
    icon->SetBitmapsOwnedExternally( EFalse );

    TInt err = AknIconUtils::SetSize( bitmap, aIconSize );
	if ( err != KErrNone ) 
		{
		LIVE_TV_TRACE2(_L("CIptvLiveUIImageHandler::LoadIconL() AknIconUtils::SetSize() FAILED: %d"), err);
		}

    if ( aInsert && aIcons )
        {
        aIcons->InsertL( 0, icon );
        }
    else 
        {
		if ( aIcons ) 
			{
			aIcons->AppendL( icon );	
			}
        }

    CleanupStack::Pop( icon );  
    CleanupStack::Pop( mask );
    CleanupStack::Pop( bitmap );
	LIVE_TV_TRACE1(_L("CIptvLiveUIImageHandler::LoadIconL() out") );
    }   

// -----------------------------------------------------------------------------
// Loads color-customized icon to the given array.
// -----------------------------------------------------------------------------
//
EXPORT_C void CIptvLiveUIImageHandler::LoadIconL( CAknIconArray* aIcons, 
                                    const TAknsItemID aItemId, 
									const TInt aIconIndex, 
                                    const TInt aMaskIndex, 
                                    const TSize& aIconSize,
                                    const TDesC& aMifFileName, 
                                    TBool aInsert
                                    )
    {
	LIVE_TV_TRACE1(_L("CIptvLiveUIImageHandler::LoadIconL() in") );
        
    MAknsSkinInstance* skin = AknsUtils::SkinInstance();    
            
    CFbsBitmap* bitmap = NULL;
    CFbsBitmap* mask = NULL;
    TRgb defaultColour( KRgbWhite );
    // Color is not updated if it not found from the skin
    AknsUtils::GetCachedColor( skin,
              defaultColour,
              KAknsIIDQsnIconColors,
              EAknsCIQsnIconColorsCG13 );
    
    AknsUtils::CreateColorIconLC( skin,
              aItemId,
              KAknsIIDQsnIconColors,
              EAknsCIQsnIconColorsCG13,
              bitmap,
              mask,
              aMifFileName,
              aIconIndex,
              aMaskIndex,
              defaultColour,
              aIconSize,
              EAspectRatioPreserved );
        
    CGulIcon* icon = NULL;
    icon = CGulIcon::NewL( bitmap, mask );
    
    CleanupStack::Pop( 2 ); // mask, bitmap        
    // ownership of bitmap and mask transferred to icon
    icon->SetBitmapsOwnedExternally( EFalse );         
    
    CleanupStack::PushL( icon );    

    if ( aInsert && aIcons )
        {
        aIcons->InsertL( 0, icon );
        }
    else 
        {
		if ( aIcons ) 
			{
			aIcons->AppendL( icon );	
			}
        }

    CleanupStack::Pop( icon );  
	LIVE_TV_TRACE1(_L("CIptvLiveUIImageHandler::LoadIconL() out") );
    }   

// -----------------------------------------------------------------------------
// CIptvLiveUIImageHandler::RunL()
// From CActive
// -----------------------------------------------------------------------------
//
void CIptvLiveUIImageHandler::RunL()
    {
    LIVE_TV_TRACE2(_L("CIptvLiveUIImageHandler::RunL() in, iStatus.Int() = %d"), iStatus.Int());
	if ( iStatus.Int() == KErrNone ) 
		{
		// Image conversion ok
		iObserver->ImageReadyL( KErrNone, *iBitmap );
		}
	else 
		{
		// There was some error, notify observer
		iObserver->ImageReadyL( iStatus.Int(), *iBitmap );
		}
	// free image file and bitmap
	delete iImageDecoder;
	iImageDecoder = NULL;
	delete iBitmap;
	iBitmap = NULL;
	LIVE_TV_TRACE1(_L("CIptvLiveUIImageHandler::RunL() out"));
    }

// -----------------------------------------------------------------------------
// CIptvLiveUIImageHandler::RunError()
// From CActive
// -----------------------------------------------------------------------------
//
TInt CIptvLiveUIImageHandler::RunError( TInt /*aError*/ )
    {
    LIVE_TV_TRACE1(_L("CIptvLiveUIImageHandler::RunError() in"));
	// free image file and bitmap
	delete iImageDecoder;
	iImageDecoder = NULL;
	delete iBitmap;
	iBitmap = NULL;
	LIVE_TV_TRACE1(_L("CIptvLiveUIImageHandler::RunError() out"));
    return KErrNone;
    }
    
// -----------------------------------------------------------------------------
// CIptvLiveUIImageHandler::DoCancel()
// From CActive
// -----------------------------------------------------------------------------
//
void CIptvLiveUIImageHandler::DoCancel()
    {
    LIVE_TV_TRACE1(_L("CIptvLiveUIImageHandler::DoCancel() in"));
	if ( iImageDecoder ) 
		{
		iImageDecoder->Cancel();	
		}
	delete iImageDecoder;
	iImageDecoder = NULL;
    LIVE_TV_TRACE1(_L("CIptvLiveUIImageHandler::DoCancel() out"));
    }

// End of File