/*

* Copyright (c) 2006-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 CSatUiIconHandler class.

*

*/

#include    <fbs.h>

#include    <rsatservice.h>

#include    <tsaticoninfo.h>

#include    "csatuiiconhandler.h"

#include    "tflogger.h"

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

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

// First part of Two-phased constructor.

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

//

CSatUiIconHandler* CSatUiIconHandler::NewL()

    {

    TFLOGSTRING( "CSatUiIconHandler::NewL enter" )

    CSatUiIconHandler* self = new ( ELeave ) CSatUiIconHandler;

    TFLOGSTRING( "CSatUiIconHandler::NewL exit" )

    return self;

    }

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

// Destructor

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

//

CSatUiIconHandler::~CSatUiIconHandler()

    {

    TFLOGSTRING( "CSatUiIconHandler::~CSatUiIconHandler enter" )

    // Close RSatService interface

    iSatService.Close();

    TFLOGSTRING( "CSatUiIconHandler::~CSatUiIconHandler exit" )

    }

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

// Fetches first icon information, then the handle to the icon and at last

// does the duplication of the icon bitmap. Object is set to wait the

// completion of the request.

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

//

CFbsBitmap* CSatUiIconHandler::FetchIconL( const RSatSession& aSatSession,

                                           const TUint8 aIconId,

                                           const TInt aOptWidth,

                                           const TInt aOptHeight,

                                           TBool& aIconSupport )

    {

    TFLOGSTRING( "CSatUiIconHandler::FetchIconL enter" )

    TFLOGSTRING3( "CSatUiIconHandler::FetchIconL aOptWidth=%d aOptHeight=%d",

            aOptWidth, aOptHeight )

    iSatService.OpenL( aSatSession );

    CleanupClosePushL( iSatService );

    RIconEf iconEf;

    CleanupClosePushL( iconEf );

    // Order of superiority list

    RArray<TInt> selectedIcons;

    CleanupClosePushL( selectedIcons );

    CFbsBitmap* iconBitmap = NULL;

    // Getting the information of the icon

    TRAPD( err, iSatService.GetIconInfoL( aIconId, iconEf ); );

    if ( KErrNone == err )

        {

        TFLOGSTRING( "CSatUiIconHandler::FetchIconL no error" )

        // Sorting into order of superiority

        SortIconsL( iconEf, selectedIcons, aOptWidth, aOptHeight );

        // Reset iconCount by approved icons

        const TInt iconCount = selectedIcons.Count() <= iconEf.Count() ? 

                               selectedIcons.Count() :

                               iconEf.Count();

        TBool fetchSuccess( EFalse );

        TFLOGSTRING2( "CSatUiIconHandler::FetchIconL iconCount: %d", iconCount )

        // If there were icons to be fetched

        if ( 0 < iconCount )

            {

            // start going through approved icons list from the 

            // first and biggest icon

            TInt counter( 0 );

            for ( counter = 0; ( counter < iconCount ) && !fetchSuccess;

                counter++ )

                {

                TInt selectedIconCounter = selectedIcons.operator[]( counter );

                TFLOGSTRING2( "CSatUiIconHandler::\

                    FetchIconL selectedIconCounter: %d", selectedIconCounter )

                TRAPD( err, 

                       iconBitmap = iSatService.GetIconL( iconEf.operator[](

                           selectedIconCounter ) ) );

                if ( KErrNone == err  )

                    {

                    fetchSuccess = ETrue;

                    TFLOGSTRING( "CSatUiIconHandler::FetchIconL fetchSuccess!" )

                    }

                else

                    {

                    delete iconBitmap;

                    }

                }

            }

        }

        TFLOGSTRING2( "CSatUiIconHandler::FetchIconL icon info error=%d", err )

        if ( KErrNotSupported == err )

            {

            TFLOGSTRING( "CSatUiIconHandler::FetchIconL icons not supported" )

            aIconSupport = EFalse;

            }

    // selectedIcons, iconEf and iSatService not deleted but closed

    CleanupStack::PopAndDestroy( 3, &iSatService );

    TFLOGSTRING( "CSatUiIconHandler::FetchIconL exit" )

    // Icon was not found, icons are not supported or an error was received.

    return iconBitmap;

    }

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

// C++ default constructor cannot contain any code that might leave.

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

//

CSatUiIconHandler::CSatUiIconHandler()

    {

    TFLOGSTRING( "CSatUiIconHandler::CSatUiIconHandler enter - exit" )

    }

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

// Sorts icons into order of superiority

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

//

void CSatUiIconHandler::SortIconsL( const RIconEf& aIconEf,

    RArray<TInt>& aSelectedIcons, const TInt aOptWidth,

    const TInt aOptHeight ) const

    {

    TFLOGSTRING( "CSatUiIconHandler::SortIcons enter" )

    const TInt iconCount = aIconEf.Count();

    TFLOGSTRING2( "CSatUiIconHandler::SortIcons iconCount=%d", iconCount )

    TInt counter( 0 );

    // Search icon from available iconarray

    for ( counter = 0; counter < iconCount; counter++ )

        {

        TFLOGSTRING3( "CSatUiIconHandler::SortIcons Icon Width=%d Height=%d",

            aIconEf.operator[]( counter ).IconSize().iWidth,

            aIconEf.operator[]( counter ).IconSize().iHeight )

        const TInt selectedCount( aSelectedIcons.Count() );

        TBool replacement( EFalse );

        // Count the difference of the icon versus layout

        TInt newWidthDifference(

            aOptWidth - aIconEf.operator[]( counter ).IconSize().iWidth );

        TInt newHeightDifference(

            aOptHeight - aIconEf.operator[]( counter ).IconSize().iHeight );

        // Make the difference absolute value

        if ( newWidthDifference < 0 )

            {

            newWidthDifference = -newWidthDifference;

            }

        if ( newHeightDifference < 0 )

            {

            newHeightDifference = -newHeightDifference;

            }

        TInt listCounter( 0 );

        // Going through the list of icons of suitable size

        for ( listCounter = 0; ( listCounter < selectedCount ) &&

            !replacement; listCounter++ )

            {

            // Count the difference of the icon versus layout

            TInt oldWidthDifference( aOptWidth - aIconEf.operator[](

              aSelectedIcons.operator[]( listCounter ) ).IconSize().iWidth );

            TInt oldHeightDifference( aOptHeight - aIconEf.operator[](

              aSelectedIcons.operator[]( listCounter ) ).IconSize().iHeight );

            // Make the difference absolute value

            if ( oldWidthDifference < 0 )

                {

                oldWidthDifference = -oldWidthDifference;

                }

            if ( oldHeightDifference < 0 )

                {

                oldHeightDifference = -oldHeightDifference;

                }

            // New icon is better either by being closer to the layout or by

            // being same size and color instead of black and white

            if ( ( ( newWidthDifference < oldWidthDifference ) &&

                  ( newHeightDifference <= oldHeightDifference ) ) ||

                ( ( newWidthDifference <= oldWidthDifference ) &&

                  ( newHeightDifference < oldHeightDifference ) ) ||

                ( ( newWidthDifference == oldWidthDifference ) &&

                  ( newHeightDifference == oldHeightDifference ) &&

                 ( TSatIconInfo::EBasic == aIconEf.operator[]( aSelectedIcons.

                    operator[]( listCounter ) ).CodingScheme() ) &&

                 ( TSatIconInfo::EColor ==  aIconEf.operator[]( counter ).

                    CodingScheme() ) ) )

                {

                TFLOGSTRING2( "CSatUiIconHandler::SortIcons \

                             newWidthDifference: %d", newWidthDifference ) 

                TFLOGSTRING2( "CSatUiIconHandler::SortIcons \

                             oldHeightDifference: %d", oldHeightDifference )    

                // Insert new icon to correct place

                aSelectedIcons.InsertL( counter, listCounter );

                replacement = ETrue;

                }

            }

        TFLOGSTRING2( "CSatUiIconHandler::SortIcons listCounter: %d", \

            listCounter )    

        // Either first item or was not better than any in the list

        // New icon is added to the end of the array

        if ( !replacement )

            {

            aSelectedIcons.AppendL( counter );

            }

        }

    TFLOGSTRING2( "CSatUiIconHandler::SortIcons counter: %d", \

            counter )

    TFLOGSTRING( "CSatUiIconHandler::SortIcons exit" )

    }