/*

* 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 CIAUpdateMainView class 

*                member functions.

*

*/

#include <eikmenup.h>

#include <aknViewAppUi.h> 

#include <akntitle.h> 

#include <aknnavi.h> // CAknNavigationControlContainer

#include <aknnavide.h> // CAknNavigationDecorator

#include <AknUtils.h>

#include <aknmessagequerydialog.h>      // CAknMessageQueryDialog

#include <akntoolbar.h> 

#include <StringLoader.h>

#include <featmgr.h>  

#include <iaupdate.rsg>

#include "iaupdate.hrh"

#include "iaupdatemainview.h"

#include "iaupdatemaincontainer.h"

#include "iaupdatenode.h"

#include "iaupdatefwnode.h"

#include "iaupdatebasenode.h"

#include "iaupdatedialogutil.h"

#include "iaupdatestatusdialog.h"

#include "iaupdateappui.h"

#include "iaupdateuicontroller.h"

#include "iaupdatedeputils.h"

#include "iaupdatedebug.h"

#include "iaupdatefwupdatehandler.h"

//CONSTANTS

const TInt KKiloByte = 1024;

const TInt KMegaByte = 1024 * 1024;

const TInt KMaxShownInKiloBytes = 10 * KMegaByte;

const TInt KSelInfoArrayGranularity = 3;

//MACROS

_LIT( KSpace, " " );

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

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

// CIAUpdateMainView::NewL

// Two-phased constructor.

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

//

CIAUpdateMainView* CIAUpdateMainView::NewL( const TRect& aRect )

    {

    CIAUpdateMainView* self = CIAUpdateMainView::NewLC( aRect );

    CleanupStack::Pop(self);

    return self;

    }

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

// CIAUpdateMainView::NewLC

// 

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

//

CIAUpdateMainView* CIAUpdateMainView::NewLC( const TRect& aRect )

    {

    CIAUpdateMainView* self = new (ELeave) CIAUpdateMainView();

    CleanupStack::PushL( self );

    self->ConstructL( aRect );

    return self;

    }

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

// CIAUpdateMainView::CIAUpdateMainView

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

// might leave.

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

//

CIAUpdateMainView::CIAUpdateMainView()

    {

    }

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

// CIAUpdateMainView::~CIAUpdateMainView

// Destructor

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

//

CIAUpdateMainView::~CIAUpdateMainView()

    {

    delete iDecorator;

    iAllNodes.Close();

    if ( iContainer )

        {

    	AppUi()->RemoveFromStack( iContainer );

    	delete iContainer;

        }

    delete iFwUpdateHandler;

    }

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

// CIAUpdateMainView::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CIAUpdateMainView::ConstructL( const TRect& /*aRect*/ )

    {

    BaseConstructL( R_IAUPDATE_MAIN_VIEW );

    Toolbar()->SetItemDimmed( EIAUpdateCmdStartUpdate, ETrue, ETrue );

    Toolbar()->SetItemDimmed( EIAUpdateCmdMarkedUpdateDetails, ETrue, ETrue );

    Toolbar()->SetItemDimmed( EIAUpdateCmdUpdateHistory, ETrue, ETrue );

    Toolbar()->SetToolbarObserver( this ); 

    iFwUpdateHandler = CIAUpdateFWUpdateHandler::NewL();

    }

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

// CIAUpdateMainView::RefreshL

// Refreshes update list

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

//    

void CIAUpdateMainView::RefreshL( const RPointerArray<MIAUpdateNode>& aNodes,

                                  const RPointerArray<MIAUpdateFwNode>& aFwNodes,

                                  TInt aError  )

    {   

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateMainView::RefreshL begin");

    iRefreshError = aError;    

    iAllNodes.Reset();

    if ( aFwNodes.Count() > 0 )

        {

        IAUPDATE_TRACE("[IAUPDATE] CIAUpdateMainView::RefreshL hard code importance");

        //hardcode the importance of firmware as Critical

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

             {

             aFwNodes[i]->Base().SetImportance( MIAUpdateBaseNode::ECritical );

             }

        //either NSU or FOTA available

        if ( aFwNodes.Count() == 1 )

            {

            IAUPDATE_TRACE("[IAUPDATE] CIAUpdateMainView::RefreshL either NSU or FOTA available");

            MIAUpdateAnyNode* node = aFwNodes[0];

            User::LeaveIfError( iAllNodes.Append( node ) );

            }

        //both NSU and FOTA available, show only FOTA node

        if ( aFwNodes.Count() == 2 )

            {

            IAUPDATE_TRACE("[IAUPDATE] CIAUpdateMainView::RefreshL both NSU and FOTA available");

            MIAUpdateAnyNode* node1 = aFwNodes[0];

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

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

                {

                User::LeaveIfError( iAllNodes.Append( node1 ) );

                }

            else

                {

                MIAUpdateAnyNode* node2 = aFwNodes[1];

                User::LeaveIfError( iAllNodes.Append( node2 ) );

                }

            }

        }

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

        {

        MIAUpdateAnyNode* node = aNodes[i];

        User::LeaveIfError( iAllNodes.Append( node ) );

        }

    if( iContainer )

        {        

        iContainer->RefreshL( iAllNodes, iRefreshError );  

        SetSelectedIndicesL();     

        DynInitToolbarL( R_IAUPDATE_MAIN_TOOLBAR, Toolbar() );

        }    

     Toolbar()->SetItemDimmed( EIAUpdateCmdUpdateHistory, EFalse, ETrue );

     }

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

// CIAUpdateMainView::GetCurrentNode

// 

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

//    

MIAUpdateAnyNode* CIAUpdateMainView::GetCurrentNode()

   {

   if ( iContainer )

      {

   	  return iContainer->GetCurrentNode( iAllNodes ); 	 

      }

   return NULL;   

   }

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

// CIAUpdateMainView::GetSelectedNode

// 

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

//    

MIAUpdateAnyNode* CIAUpdateMainView::GetSelectedNode()

   {

   MIAUpdateAnyNode* selectedNode = NULL;

   for( TInt i = 0; i < iAllNodes.Count() && !selectedNode ; ++i )

       {

       if ( iAllNodes[i]->Base().IsSelected() )

           {

           selectedNode = iAllNodes[i];

           }

       }

    return selectedNode;   

   }

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

// CIAUpdateMainView::Id

// Get Uid of this view

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

//       

TUid CIAUpdateMainView::Id() const

    {

    return TUid::Uid( EIAUpdateMainViewId );

    }

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

// CIAUpdateMainView::HandleCommandL

// 

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

// 

void CIAUpdateMainView::HandleCommandL( TInt aCommand )

    {

    switch( aCommand ) 

        {  

        case EIAUpdateCmdStartUpdate:

            {

            RPointerArray<MIAUpdateAnyNode> selectedNodes;

            CleanupClosePushL( selectedNodes );

            GetSelectedNodesL( selectedNodes ); 

            if ( selectedNodes[0]->NodeType() == MIAUpdateAnyNode::ENodeTypeFw )

                {

                //the marking logic will make sure firmware won't be marked with normal sis updates

                //at the same time.

                iFwUpdateHandler->FirmWareUpdatewithFOTA();

                }

            else

                {

                AppUi()->HandleCommandL( aCommand );

                }

            CleanupStack::PopAndDestroy( &selectedNodes );

            break;    

            }

        case EIAUpdateCmdUpdateWithPC:

            {

            iFwUpdateHandler->FirmWareUpdatewithNSU();

            break;

            }

        case EIAUpdateCmdSettings:

            {

            Toolbar()->SetToolbarVisibility( EFalse );

            AppUi()->HandleCommandL( aCommand );

            Toolbar()->SetToolbarVisibility( ETrue );

            break;

            }

        case EAknSoftkeyMark:

            {

            iContainer->HandleMarkCommandL( EAknCmdMark );

            break;	

            }

        case EAknSoftkeyUnmark:

            {

            iContainer->HandleMarkCommandL( EAknCmdUnmark );

            break;	

            }

        case EAknCmdMark:        

        case EAknCmdUnmark:

            {

            iContainer->HandleMarkCommandL( aCommand );

            break;	

            }

        default:

            { 

            AppUi()->HandleCommandL( aCommand );

            break;

            }

        }

    }

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

// CIAUpdateMainView::DynInitMenuPaneL

// Dim options which are not availble in empty list.

// Set Mark/Unmark option

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

//    

void CIAUpdateMainView::DynInitMenuPaneL( TInt aResourceId, CEikMenuPane* aMenuPane )

    {

    if( aResourceId == R_IAUPDATE_MAIN_MENU ) 

        {

        if ( !FeatureManager::FeatureSupported( KFeatureIdHelp ) )

            {

            aMenuPane->SetItemDimmed( EAknCmdHelp, ETrue );

            }

        RPointerArray<MIAUpdateAnyNode> selectedNodes;

        CleanupClosePushL( selectedNodes );

        GetSelectedNodesL( selectedNodes ); 

        if ( selectedNodes.Count() )

            {

            if ( selectedNodes[0]->NodeType() == MIAUpdateAnyNode::ENodeTypeFw )

                {

                //firmware is selected

                MIAUpdateFwNode* node = static_cast<MIAUpdateFwNode*>( selectedNodes[0] );

                if ( node->FwType() == MIAUpdateFwNode::EFotaDp2 )

                    {

                    aMenuPane->SetItemDimmed( EIAUpdateCmdUpdateWithPC, ETrue );

                    }

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

                    {

                    aMenuPane->SetItemDimmed( EIAUpdateCmdStartUpdate, ETrue );

                    }

                }

            else

                {

                //firmware is not selected, only sis

                aMenuPane->SetItemDimmed( EIAUpdateCmdUpdateWithPC, ETrue );

                }

            }

        else

            {

            aMenuPane->SetItemDimmed( EIAUpdateCmdStartUpdate, ETrue );

            aMenuPane->SetItemDimmed( EIAUpdateCmdUpdateWithPC, ETrue );

            }

        CleanupStack::PopAndDestroy( &selectedNodes );

        }

    }

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

// CIAUpdateMainView::DoActivateL

// Activate view

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

// 

void  CIAUpdateMainView::DoActivateL( const TVwsViewId& /*aPrevViewId*/, 

                                      TUid /*aCustomMessageId*/, 

                                      const TDesC8& /*aCustomMessage*/ )

    {

    UpdateStatusPaneL();

    if( !iContainer )

        {    

        iContainer = CIAUpdateMainContainer::NewL( ClientRect(), *this );

        if( iAllNodes.Count() > 0 )

            {            

            iContainer->RefreshL( iAllNodes, iRefreshError );

            }

        SetSelectedIndicesL();  

        DynInitToolbarL( R_IAUPDATE_MAIN_TOOLBAR, Toolbar() );

        AppUi()->AddToStackL( iContainer ); 

        }

    else

        {

        UpdateSelectionInfoInNaviPaneL();	

        }

    }

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

// CIAUpdateMainView::DoDeactivate()

// Container is deleted in deactivation

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

//

void CIAUpdateMainView::DoDeactivate()

    {

    RemoveSelectionInfoInNaviPane();

    }

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

// CIAUpdateMainView::DynInitToolbarL()

//

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

//

void CIAUpdateMainView::DynInitToolbarL( TInt aResourceId, CAknToolbar* aToolbar )

    {

    if ( aResourceId == R_IAUPDATE_MAIN_TOOLBAR )

        {

        if ( iContainer )

            {

            if ( CountOfSelectedItems() > 0 )

                {

                aToolbar->SetItemDimmed( EIAUpdateCmdStartUpdate, EFalse, ETrue );

                }

            else

                {

                aToolbar->SetItemDimmed( EIAUpdateCmdStartUpdate, ETrue, ETrue );

                }

            if ( CountOfSelectedItems() == 1 )

                {

                aToolbar->SetItemDimmed( EIAUpdateCmdMarkedUpdateDetails, EFalse, ETrue );

                }

            else

                {

                aToolbar->SetItemDimmed( EIAUpdateCmdMarkedUpdateDetails, ETrue, ETrue );

                }

            }

        }

    }

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

// CIAUpdateMainView::OfferToolbarEventL()

//

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

//            

void CIAUpdateMainView::OfferToolbarEventL( TInt aCommand )

    {

    if ( aCommand == EIAUpdateCmdStartUpdate )

        {

        RPointerArray<MIAUpdateAnyNode> selectedNodes;

        CleanupClosePushL( selectedNodes );

        GetSelectedNodesL( selectedNodes ); 

        if ( selectedNodes.Count() )

            {

            if ( selectedNodes[0]->NodeType() == MIAUpdateAnyNode::ENodeTypeFw )

                {

                //firmware is selected

                MIAUpdateFwNode* node = static_cast<MIAUpdateFwNode*>( selectedNodes[0] );

                if ( node->FwType() == MIAUpdateFwNode::EFotaDp2 )

                    {

                    aCommand = EIAUpdateCmdStartUpdate;

                    }

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

                    {

                    aCommand = EIAUpdateCmdUpdateWithPC;

                    }

                }

            else

                {

                //firmware is not selected, only sis

                aCommand = EIAUpdateCmdStartUpdate;

                }

            }

        else

            {

             MIAUpdateAnyNode* currentNode = GetCurrentNode(); 

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

                 {

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

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

                     {

                     aCommand = EIAUpdateCmdUpdateWithPC;

                     }

                 } 

            }

        CleanupStack::PopAndDestroy( &selectedNodes );   

        }

    HandleCommandL( aCommand );

    }

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

// CIAUpdateMainView::MarkListItemL

// Mark list item

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

//    

TBool CIAUpdateMainView::MarkListItemL( TBool aMark, TInt aIndex )

    {

    if ( aMark )

        {

        //It's Mark Command

        RPointerArray<MIAUpdateAnyNode> selectedNodes;

        CleanupClosePushL( selectedNodes );

        GetSelectedNodesL( selectedNodes ); 

        //There are selected items already and type are different with the current one

        if ( selectedNodes.Count() > 0 && (iAllNodes[aIndex]->NodeType() != selectedNodes[0]->NodeType() ) )

            {       

            /*HBufC* msgText = StringLoader::LoadLC(R_IAUPDATE_FIRMWARE_WITH_OTHERS);

            CAknQueryDialog* dlg = CAknQueryDialog::NewL();

            dlg->ExecuteLD( R_IAUPDATE_INFORMATION_QUERY, *msgText );

            CleanupStack::PopAndDestroy( msgText );*/

            //clean all of the current selection(s)

            iContainer->CleanAllSelection();

            // firmware item and normal sis items can't be selected at the same time

            // unmark the selected nodes.

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

                {                

                TInt index = iAllNodes.Find( selectedNodes[i]);

                iAllNodes[index]->Base().SetSelected( EFalse );

                }

            }

        CleanupStack::PopAndDestroy( &selectedNodes );

        }

    //there is no selected items or the type is the same with the current one

    if ( iAllNodes[aIndex]->NodeType() == MIAUpdateAnyNode::ENodeTypeFw )

        {

        iAllNodes[aIndex]->Base().SetSelected( aMark );       

        if ( aMark )

            {

            SetMiddleSKTextL( ETrue, ETrue );

            }

        else

            {

            SetMiddleSKTextL( ETrue, EFalse );  

            }