/*
* Copyright (c) 2005 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: 
*      Implementation of CBrowserFaviconHandler
*
*
*/


// INCLUDES
#include "BrowserFaviconHandler.h"
#include "ApiProvider.h"
#include "BrowserUtil.h"
#include <e32base.h>
#include <brctldefs.h>
#include <fbs.h>
#include <MdaImageConverter.h>
#include <favouritesitemlist.h>
#include <favouritesitem.h>

// number of favicons to get before redrawing
const TInt KNumFaviconsToRedraw = 3	;

// ----------------------------------------------------------------------------
// CBrowserFaviconHandler::CBrowserFaviconHandler()
// ----------------------------------------------------------------------------
//
CBrowserFaviconHandler::CBrowserFaviconHandler( 
										MApiProvider& aApiProvider,
										MBrowserFaviconObserver& aObserver,
										TSize aFaviconSize ) :
	CActive( CActive::EPriorityIdle ),
	iApiProvider( aApiProvider ),
	iObserver( aObserver ),
	iFaviconSize( aFaviconSize )
	{
	CActiveScheduler::Add( this );	
	}


// ----------------------------------------------------------------------------
// CBrowserFaviconHandler::~CBrowserFaviconHandler()
// ----------------------------------------------------------------------------
//
CBrowserFaviconHandler::~CBrowserFaviconHandler()
	{
	Cancel();
	if(iBmpScaler!=NULL)
		{
			iBmpScaler->Cancel();
		}
	delete iBmpScaler;
	delete iFaviconArrayIndices;
	delete iFavicon;
	}


// ----------------------------------------------------------------------------
// CBrowserFaviconHandler::NewL()
// ----------------------------------------------------------------------------
//	
CBrowserFaviconHandler* CBrowserFaviconHandler::NewL( 
										MApiProvider& aApiProvider,
										CArrayPtr<CGulIcon>* aIconArray,
										MBrowserFaviconObserver& aObserver,
										TSize aFaviconSize )
	{
	CBrowserFaviconHandler* self = 
					CBrowserFaviconHandler::NewLC( 	aApiProvider, 
													aIconArray, 
													aObserver,
													aFaviconSize );
    
    CleanupStack::Pop();
    return self;	
	}
	

// ----------------------------------------------------------------------------
// CBrowserFaviconHandler::NewLC()
// ----------------------------------------------------------------------------
//	
CBrowserFaviconHandler* CBrowserFaviconHandler::NewLC(
										MApiProvider& aApiProvider,
										CArrayPtr<CGulIcon>* aIconArray,
										MBrowserFaviconObserver& aObserver,
										TSize aFaviconSize )
	{
	CBrowserFaviconHandler* self = 
					new ( ELeave ) CBrowserFaviconHandler( 	aApiProvider,
															aObserver,
															aFaviconSize );
	CleanupStack::PushL( self );
    self->ConstructL( aIconArray );
    return self;	
	}
	

// ----------------------------------------------------------------------------
// CBrowserFaviconHandler::ConstructL()
// ----------------------------------------------------------------------------
//		
void CBrowserFaviconHandler::ConstructL( CArrayPtr<CGulIcon>* aIconArray )
	{
	iIconArray = aIconArray; // not owned
	iFaviconArrayIndices = new ( ELeave ) CArrayFixFlat<TFaviconIndex>( 4 );
		
	// Construct Favicon Engine
	iBmpScaler = CBrowserFaviconScaler::NewL(*this);
	}

// ----------------------------------------------------------------------------
// CBrowserFaviconHandler::RequestFavicons()
// ----------------------------------------------------------------------------
//      
void CBrowserFaviconHandler::RequestFavicons( CFavouritesItemList* aFavItems )
    {
    TInt count = aFavItems->Count();
    while(count)
        {            
            CFavouritesItem& item = *aFavItems->At( count - 1); // index starts from 0
            CGulIcon *favIcon = NULL;           
                        
            // Request Favicon from Engine  - there should be new API for request, but no har to use it
            if ( item.Url().Length() )
                iFavicon = iApiProvider.BrCtlInterface().GetBitmapData(item.Url(), TBrCtlDefs::EBitmapFavicon );

            if ( favIcon )
                {                
                delete iFavicon;
                iFavicon = NULL;
                }
            count--;
        }
    }

// ----------------------------------------------------------------------------
// CBrowserFaviconHandler::StartGetFaviconsL()
// ----------------------------------------------------------------------------
//		
void CBrowserFaviconHandler::StartGetFaviconsL( CFavouritesItemList* aFavItems )
	{
	Cancel();
	iBmpScaler->Cancel();
		
	if ( aFavItems->Count() )
		{
		// New request for favicons: 
		iFavItems = aFavItems;
		
	    // Initialisation.
		iFavItemsCurrentIndex = 0;      // will be incremented before favicon getting
        iFaviconsFound = 0;             // keeps track of favicons found
		iFaviconArrayIndices->Reset();  // refresh the array mapping uid's to favicons
		
		// Initiate the getting of favicons	
		GetFaviconL();
		}
	}
	
// ----------------------------------------------------------------------------
// CBrowserFaviconHandler::GetFaviconL()
// ----------------------------------------------------------------------------
//		
void CBrowserFaviconHandler::GetFaviconL()
	{	
	// The whole list has already been checked - we're finished
	if ( iFavItemsCurrentIndex >= iFavItems->Count() )
		{
		iObserver.DrawFavicons();
		}
	else
	    {
	    // Step through the item array until we find a favicon, or reach the end
		do
			{
			iWasLastItemFavicon = EFalse;
			
			CFavouritesItem& item = *iFavItems->At( iFavItemsCurrentIndex );			
			if ( iFavicon )
				{
				// Make sure ongoing scaling is cancelled (if any)
				Cancel();
				iBmpScaler->Cancel();
				
				delete iFavicon;
				iFavicon = NULL;
				}
						
			// Get Favicon from Engine
			if ( item.Url().Length() )
				{
				iFavicon = iApiProvider.BrCtlInterface().GetBitmapData(item.Url(), TBrCtlDefs::EBitmapFavicon );
				}

			// Asynchronously scales the favicon and stores it in an array
			if ( iFavicon )
				{
				iWasLastItemFavicon = ETrue;	
				RescaleFaviconL();
				iFaviconsFound++;
				__ASSERT_DEBUG( !( iFavItemsCurrentIndex > iFavItems->Count() ),
								Util::Panic( Util::EOutOfRange ) );
				break;
				}
			} while ( ++iFavItemsCurrentIndex < iFavItems->Count() );
		}
		
		// If we exited the 'do' and the last item wasn't a favicon
		// it means we're finished
		if ( !iWasLastItemFavicon &&  ( iFaviconsFound %  KNumFaviconsToRedraw ) )
			{
			iObserver.DrawFavicons();
			}
	}
	
// ----------------------------------------------------------------------------
// CBrowserFaviconHandler::RescaleFaviconL()
// ----------------------------------------------------------------------------
//
void CBrowserFaviconHandler::RescaleFaviconL()
	{
	iHasMask = (iFavicon->Mask() != NULL);
	if (iHasMask)
		{
		iBmpScaler->StartScalingL( *iFavicon->Mask(), iFaviconSize, ETrue );
		}
	else
		{
		iBmpScaler->StartScalingL( *iFavicon->Bitmap(), iFaviconSize, EFalse );
		}
	//  Complete two asynchronous requests.
	iStatus = KRequestPending;
	SetActive();

	}
	
// ----------------------------------------------------------------------------
// CBrowserFaviconHandler::AppendToIconArray()
// ----------------------------------------------------------------------------
//		
TInt CBrowserFaviconHandler::AppendToIconArray()
	{
	TInt err( KErrNone );
	TInt arrayIndex(-1);
	
	// Add the favicon to the icon array
	TRAP( err, iIconArray->AppendL( iFavicon ); );

	// Favicon was successfully added to the array
	if ( !err )
		{		
		arrayIndex = iIconArray->Count() - 1;
		
		// Keep track of the index of the favicon in the icon array
		if ( arrayIndex > -1 )
			{
			TFaviconIndex faviconIndex;			
			faviconIndex.iFavouritesItemIndex = iFavItems->At( iFavItemsCurrentIndex )->Uid();
			faviconIndex.iIndex = arrayIndex;		
			TRAP( err, iFaviconArrayIndices->AppendL( faviconIndex ); )
			
			// If there was an error remove the favicon from the icon array
			if ( err )
				{
				iIconArray->Delete( iIconArray->Count() - 1 );				
				}
			else
				{
				iFavicon = NULL; // favicon ownership passed
				iFavItemsCurrentIndex++; // we can go to the next item now
				}
			}
		}
		
	// Ownership of the favicon was not passed, so we need to delete it
	if ( err )
		{
		iFaviconsFound--; // one less favicon in the array
		}	
		
	return err;
	}
	
	
// ----------------------------------------------------------------------------
// CBrowserFaviconHandler::GetFaviconArrayIndex()
// ----------------------------------------------------------------------------
//
TInt CBrowserFaviconHandler::GetFaviconArrayIndex( const CFavouritesItem& aItem )
	{
	TInt arrayIndex( KErrNotFound );
	
	// Find the index of the favicon in the icon array
	for ( TInt i=0; i<iFaviconArrayIndices->Count(); i++ )
		{
		// if uid is 0 then don't associate with favicon.  for adaptive bookmarks
		if ( aItem.Uid() && aItem.Uid() == iFaviconArrayIndices->At(i).iFavouritesItemIndex )
			{
			arrayIndex = iFaviconArrayIndices->At(i).iIndex;
			break;
			}			
		}	
	return arrayIndex;
	}

// ----------------------------------------------------------------------------
// CBrowserFaviconHandler::ScalingCompletedL()
// ----------------------------------------------------------------------------
//		
void CBrowserFaviconHandler::ScalingCompletedL(CFbsBitmap* aResult, const TRect& /*aTargetRect*/)
	{
	// Check that favicon hasn't already disappeared (i.e. if race cond in which scaler returns 
	// after you've already left and deleted the icon handle concerned
	if(NULL == iFavicon)
		{
		return;
		}
	
	
	// Add the favicon to the icon array (which also contains other icons)
	if (iHasMask)
		{
		iFavicon->SetMask(aResult);
		iHasMask = EFalse;
		iBmpScaler->StartScalingL( *iFavicon->Bitmap(), iFaviconSize, EFalse );
		}
	else
		{
		iFavicon->SetBitmap(aResult);
		iFavicon->SetBitmapsOwnedExternally(EFalse);
		TInt err = AppendToIconArray();
		
		// Complete the AO
		TRequestStatus* status = &iStatus;
		User::RequestComplete( status, err );	
		}
	}
// ----------------------------------------------------------------------------
// CBrowserFaviconHandler::DoCancel()
// ----------------------------------------------------------------------------
//	
void CBrowserFaviconHandler::DoCancel()
	{
	TRequestStatus* s = &iStatus;
	User::RequestComplete( s, KErrNone );
	}
	
		
// ----------------------------------------------------------------------------
// CBrowserFaviconHandler::RunL()
// ----------------------------------------------------------------------------
//		
void CBrowserFaviconHandler::RunL()
	{		
	TBool drawFavicons( EFalse );
		
	// Redraw the favicons at a predefined frequency
	if ( iFaviconsFound % KNumFaviconsToRedraw == 0 )
		{
		drawFavicons = ETrue;
		}
	else
		{
		// We're not getting any more favicons: draw any undrawn ones
		if ( iStatus != KErrNone )
			{
			// do a final draw
			drawFavicons = ETrue;
			}
		}
	
	if ( drawFavicons && iFaviconsFound )
		{
		iObserver.DrawFavicons();
		}
	
	// Continue getting favicons if no errors
	if ( iStatus == KErrNone )
		{
		GetFaviconL();
		}	
	}

// ----------------------------------------------------------------------------
// CBrowserFaviconHandler::UpdateIconArray()
// ----------------------------------------------------------------------------
//	
void CBrowserFaviconHandler::UpdateIconArray(CArrayPtr<CGulIcon>* aIconArray)
    {
   	iIconArray = aIconArray; 
    }
 
// End of File