/*

* Copyright (c) 2007-2010 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:   This module contains the implementation of CIAUpdateMainContainer class 

*                member functions.

*

*/

//INCLUDES

#include <barsread.h>

#include <coemain.h>

#include <aknlists.h>

#include <badesca.h> // CDesCArray

#include <iaupdate.rsg>

#include <avkon.mbg>

#include <iaupdate.mbg>

#include <AknIconArray.h> 

#include <gulicon.h>

#include <StringLoader.h>

#include <data_caging_path_literals.hrh>

#include <e32property.h>

#include <featmgr.h>

#include "iaupdatefwnode.h"

#include "iaupdatemaincontainer.h"

#include "iaupdatecontainerobserver.h"

#include "iaupdateapplication.h"

#include "iaupdatenode.h"

#include "iaupdatebasenode.h"

#include "iaupdateversion.h"

#include "iaupdatefwnsmlpskeys.h"

//MACROS

_LIT( KTabulator, "\t" );

_LIT( KOne, "1");

_LIT( KTwo, "2");

_LIT( KSpace, " ");

//CONSTANTS

const TInt KKiloByte = 1024;

const TInt KMegaByte = 1024 * 1024;

const TInt KMaxShownInKiloBytes = 10 * KMegaByte;

_LIT( KSWUPDATE_HLP_MAIN, "SWUPDATE_HLP_MAIN" ); 

// MACROS

_LIT(KIAUpdateIconFileName, "IAUpdate.mif");

//CONST

const TUid KFOTAUid = {0x102072C4};

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

// CIAUpdateMainContainer::NewL

// Two-phased constructor.

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

//

CIAUpdateMainContainer* CIAUpdateMainContainer::NewL( 

                                         const TRect& aRect, 

                                         MIAUpdateContainerObserver& aObserver )

    {

    CIAUpdateMainContainer* self = CIAUpdateMainContainer::NewLC(aRect,aObserver);

    CleanupStack::Pop(self);

    return self;

    }

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

// CIAUpdateMainContainer::NewLC

// 

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

//

CIAUpdateMainContainer* CIAUpdateMainContainer::NewLC( 

                                          const TRect& aRect, 

                                          MIAUpdateContainerObserver& aObserver )

    {

    CIAUpdateMainContainer* self = new (ELeave) CIAUpdateMainContainer(aObserver);

    CleanupStack::PushL(self);

    self->ConstructL(aRect);

    return self;

    }

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

// CIAUpdateMainContainer::CIAUpdateMainContainer

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CIAUpdateMainContainer::CIAUpdateMainContainer(MIAUpdateContainerObserver& aObserver)

    : iObserver( aObserver )

    {

    }

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

// CIAUpdateMainContainer::~CIAUpdateMainContainer

// Destructor

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

//

CIAUpdateMainContainer::~CIAUpdateMainContainer()

    {

	delete iListBox;

    }

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

// CIAUpdateMainContainer::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CIAUpdateMainContainer::ConstructL(const TRect& aRect )

    {

    // Create a window for this application view

    CreateWindowL();

    // Create list box

    iListBox = new (ELeave) CAknDoubleGraphicStyleListBox();

    iListBox->SetContainerWindowL( *this );

    TResourceReader reader;

    iEikonEnv->CreateResourceReaderLC( reader, R_IAUPDATE_UPDATES_LIST );

    iListBox->ConstructFromResourceL( reader );

    CleanupStack::PopAndDestroy();

    iListBox->EnableStretching( EFalse );

    iListBox->ItemDrawer()->ColumnData()->EnableMarqueeL( ETrue );

    // Setup scroll bars

    iListBox->CreateScrollBarFrameL( ETrue );

    iListBox->ScrollBarFrame()->SetScrollBarVisibilityL( 

        CEikScrollBarFrame::EOn, CEikScrollBarFrame::EAuto );    

    // Create item text array

    iItemTextArray = new (ELeave) CDesCArrayFlat(2);    

    iListBox->Model()->SetItemTextArray( iItemTextArray );

    iListBox->Model()->SetOwnershipType( ELbmOwnsItemArray) ;

    HBufC* text = KNullDesC().AllocLC();    

    iListBox->View()->SetListEmptyTextL( *text );

    CleanupStack::PopAndDestroy( text );

    // Create icon array

    CFbsBitmap* bitmap = 0;

    CFbsBitmap* mask = 0;

    CArrayPtr<CGulIcon>* iconArray = new (ELeave) CAknIconArray( 3 );    

    CleanupStack::PushL( iconArray );

    AknIconUtils::CreateIconLC(

        bitmap, 

        mask, 

        AknIconUtils::AvkonIconFileName(), 

        EMbmAvkonQgn_prop_checkbox_on, 

        EMbmAvkonQgn_prop_checkbox_on_mask );

    CGulIcon* icon = CGulIcon::NewLC();

    icon->SetBitmap( bitmap );

    icon->SetMask( mask );

    icon->SetBitmapsOwnedExternally( EFalse );

    iconArray->AppendL( icon );

    CleanupStack::Pop( icon );

    CleanupStack::Pop( mask );

    CleanupStack::Pop( bitmap );

    AknIconUtils::CreateIconLC(

        bitmap, 

        mask, 

        AknIconUtils::AvkonIconFileName(), 

        EMbmAvkonQgn_prop_checkbox_off, 

        EMbmAvkonQgn_prop_checkbox_off_mask );

    icon = CGulIcon::NewLC();

    icon->SetBitmap( bitmap );

    icon->SetMask( mask );

    icon->SetBitmapsOwnedExternally( EFalse );

    iconArray->AppendL( icon );

    CleanupStack::Pop( icon );

    CleanupStack::Pop( mask );

    CleanupStack::Pop( bitmap );

    HBufC* iconFilePath = HBufC::NewLC( KDC_APP_BITMAP_DIR().Length() + 

                                        KIAUpdateIconFileName().Length() +2 );

    TPtr ptr = iconFilePath->Des();

    ptr.Append( KDC_APP_BITMAP_DIR );

    ptr.Append( KIAUpdateIconFileName );

    TRAPD( err, CreateIconL( bitmap, 

                             mask, 

                             *iconFilePath, 

                             EMbmIaupdateQgn_indi_important_add, 

                             EMbmIaupdateQgn_indi_important_add_mask ) ); 

    if ( err == KErrNone ) 

        {

        CleanupStack::PushL( bitmap );

        CleanupStack::PushL( mask );

        }

    else if ( err == KErrEof )

        {

        // icon does not exist in Z drive. I.e IAD eclipsed over phase 1 version.

        // So icon to be retrieved from C drive. 

        ptr.Zero();

    	ptr.Append( _L("C:") );

    	ptr.Append( KDC_APP_BITMAP_DIR );

        ptr.Append( KIAUpdateIconFileName );

        AknIconUtils::CreateIconLC(

                      bitmap, 

                      mask, 

                      *iconFilePath, 

                      EMbmIaupdateQgn_indi_important_add, 

                      EMbmIaupdateQgn_indi_important_add_mask );

        }

    else

        {

        User::Leave( err );	

        }

    icon = CGulIcon::NewLC();

    icon->SetBitmap( bitmap );

    icon->SetMask( mask );

    icon->SetBitmapsOwnedExternally( EFalse );

    iconArray->AppendL( icon );

    CleanupStack::Pop( icon );

    CleanupStack::Pop( mask );

    CleanupStack::Pop( bitmap );

    CleanupStack::PopAndDestroy( iconFilePath );

    CleanupStack::Pop( iconArray ); 

    iListBox->ItemDrawer()->ColumnData()->SetIconArray( iconArray );

    iListBox->SetListBoxObserver( this );

    // Set the windows size

    SetRect( aRect );

    // Activate the window, which makes it ready to be drawn

    ActivateL();

    }

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

// CIAUpdateMainContainer::HandleMarkCommandL

// Handles Mark/Unmark commnds

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

//

void CIAUpdateMainContainer::HandleMarkCommandL( TInt aCommand )

    {

    TInt index = iListBox->CurrentItemIndex();

    TBool markingAccepted = EFalse;

    if( !iListBox->View()->ItemIsSelected( index ) )                                                                                             

        {

        // aCommand is set to EAknCmdMark if current item is not selected.

        // That's because passed command id may be wrong when using touch UI 

        aCommand = EAknCmdMark;                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             

        markingAccepted = iObserver.MarkListItemL( ETrue, index );

        }

    else 

        {

        // aCommand is set to EAknCmdUnmark if current item is selected.

        // That's because passed command id may be wrong when using touch UI    

        aCommand = EAknCmdUnmark;

        markingAccepted = iObserver.MarkListItemL( EFalse, index ); 

        }

	if ( markingAccepted )

	    {

        AknSelectionService::HandleMarkableListProcessCommandL( aCommand, iListBox );

	    }

    }

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

// CIAUpdateMainContainer::RefreshL

// Refresh list

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

//

void CIAUpdateMainContainer::RefreshL( const RPointerArray<MIAUpdateAnyNode>& aNodes,

                                       TInt aError )

    {

    iItemTextArray->Reset();

    for( TInt i = 0; i < aNodes.Count(); ++i ) 

        {

        MIAUpdateAnyNode* node = aNodes[i];

        TInt sizeInBytes = node->Base().ContentSizeL();

        TInt size = 0;

        TBool shownInMegabytes = EFalse;        

        if ( sizeInBytes >= KMaxShownInKiloBytes )

            {

    	    shownInMegabytes = ETrue;

    	    size = sizeInBytes / KMegaByte;

    	    if ( sizeInBytes % KMegaByte != 0 )

    	        {

    	    	size++;

    	        }

            }

        else 

            {

    	    size = sizeInBytes / KKiloByte;

    	    if ( sizeInBytes % KKiloByte != 0 )

    	        {

    	    	size++;

    	        }  

            }

        HBufC* importanceDescription( NULL );        

        switch( node->Base().Importance() )

        {        

        case MIAUpdateBaseNode::EMandatory:

            {

            if ( shownInMegabytes )

                {

                importanceDescription = StringLoader::LoadLC(

                                   R_IAUPDATE_DES_REQUIRED_UPDATE_MB, size );

                }

            else 

                {

                importanceDescription = StringLoader::LoadLC(

                                   R_IAUPDATE_DES_REQUIRED_UPDATE_KB, size );   

                }  

            break;

            }

        case MIAUpdateBaseNode::ECritical:

            {

            TBool isNSU = EFalse;

            if( node->NodeType() == MIAUpdateAnyNode::ENodeTypeFw )

                {

                MIAUpdateFwNode* fwnode = static_cast<MIAUpdateFwNode*>( node );          

                if ( fwnode->FwType() == MIAUpdateFwNode::EFotiNsu )

                    {

                    isNSU = ETrue;

                    }

                }

                {

                importanceDescription = StringLoader::LoadLC(

                                                       R_IAUPDATE_DES_CRITICAL_UPDATE_NO_SIZE );

                }

            else

                {

                if ( shownInMegabytes )

                    {

                    importanceDescription = StringLoader::LoadLC(

                                       R_IAUPDATE_DES_CRITICAL_UPDATE_MB, size );

                    }

                else 

                    {

                    importanceDescription = StringLoader::LoadLC(

                                       R_IAUPDATE_DES_CRITICAL_UPDATE_KB, size );   

                    } 

                }

            break;

            }

        case MIAUpdateBaseNode::ERecommended:

            {

            if ( shownInMegabytes )

                {

            	importanceDescription = StringLoader::LoadLC(

            	                   R_IAUPDATE_DES_RECOMMENDED_UPDATE_MB, size );

                }

            else 

                {

                importanceDescription = StringLoader::LoadLC(

            	                   R_IAUPDATE_DES_RECOMMENDED_UPDATE_KB, size );	

                }  

            break;

            }

        case MIAUpdateBaseNode::ENormal:

            {

            if ( shownInMegabytes )

                {

            	importanceDescription = StringLoader::LoadLC(

            	                   R_IAUPDATE_DES_NORMAL_UPDATE_MB, size );

                }

            else 

                {

                importanceDescription = StringLoader::LoadLC(

            	                   R_IAUPDATE_DES_NORMAL_UPDATE_KB, size );	

                }  

            break;

            }

        default:

            {

            importanceDescription = KNullDesC().AllocLC();

            break;

            }

        }

        TPtr ptr = importanceDescription->Des();

        AknTextUtils::DisplayTextLanguageSpecificNumberConversion( ptr );    

        if ( node->NodeType() == MIAUpdateAnyNode::ENodeTypeNormal )  

            {       

            HBufC* name = node->Base().Name().AllocLC();

            HBufC* buffer = HBufC::NewLC( KOne.iTypeLength +

                                          KTabulator.iTypeLength + 

                                          name->Length() + 

                                          KTabulator.iTypeLength +

                                          importanceDescription->Length() );

            buffer->Des() = KOne();

            buffer->Des() += KTabulator();

            buffer->Des() += *name;

            buffer->Des() += KTabulator();

            buffer->Des() += *importanceDescription;        

            iItemTextArray->AppendL( *buffer );

            CleanupStack::PopAndDestroy( buffer );

            CleanupStack::PopAndDestroy( name );

            }

        if ( node->NodeType() == MIAUpdateAnyNode::ENodeTypeFw ) 

            {

            HBufC* firmwareHeader = StringLoader::LoadLC(R_IAUPDATE_MAIN_DEVICE_FW);

            HBufC* firmwarename = HBufC::NewLC( node->Base().Name().Length() +

                                                KSpace.iTypeLength + 

                                                firmwareHeader->Length() );

            firmwarename->Des() = node->Base().Name();

            firmwarename->Des() += KSpace();

            firmwarename->Des() += *firmwareHeader;

            HBufC* buffer = HBufC::NewLC( KOne.iTypeLength +

                                          KTabulator.iTypeLength + 

                                          firmwarename->Length() + 

                                          KTabulator.iTypeLength +

                                          importanceDescription->Length() +

                                          KTabulator.iTypeLength +

                                          KTwo.iTypeLength );

            buffer->Des() = KOne();

            buffer->Des() += KTabulator();

            buffer->Des() += *firmwarename;

            buffer->Des() += KTabulator();

            buffer->Des() += *importanceDescription;        

            buffer->Des() += KTabulator();

            buffer->Des() += KTwo();

            iItemTextArray->AppendL( *buffer );

            CleanupStack::PopAndDestroy( buffer );

            CleanupStack::PopAndDestroy( firmwarename );

            CleanupStack::PopAndDestroy( firmwareHeader );

            }

        CleanupStack::PopAndDestroy( importanceDescription );

        }    

    if ( aNodes.Count() == 0 )

        {

    	HBufC* emptyText = NULL;

        if ( aError )

            {

            if ( aError == KErrCancel || aError == KErrAbort )

                {

        	    emptyText = KNullDesC().AllocLC();

                }

            else

                {

                emptyText = StringLoader::LoadLC( R_IAUPDATE_REFRESH_FAILED );	

                }

    	    }

        else

            {

            emptyText = StringLoader::LoadLC( R_IAUPDATE_TEXT_NO_UPDATES );	

            }

        iListBox->View()->SetListEmptyTextL( *emptyText );

        CleanupStack::PopAndDestroy( emptyText );

        iListBox->ScrollBarFrame()->SetScrollBarVisibilityL( 

                CEikScrollBarFrame::EOff, CEikScrollBarFrame::EOff );  

        }

    else

        {

        if ( iListBox->CurrentItemIndex() == KErrNotFound )

            {

           	iListBox->SetCurrentItemIndex( aNodes.Count() - 1 );

            }

        }

    iListBox->HandleItemAdditionL();

    }

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

// CIAUpdateMainContainer::GetCurrentNode

// 

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

//

MIAUpdateAnyNode* CIAUpdateMainContainer::GetCurrentNode( 

                                    const RPointerArray<MIAUpdateAnyNode>& aNodes )    

    {

    MIAUpdateAnyNode* currentNode = NULL;

    TInt currentIndex = iListBox->CurrentItemIndex();

    if( currentIndex != -1 )

        {

        currentNode = aNodes[currentIndex];

        }

    return currentNode;

    }