/*

* 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 CIAUpdateUiController

*                class member functions.

*

*/

// INCLUDES

#include <centralrepository.h>

#include <SWInstDefs.h>

#include <featurecontrol.h>

#include <cmmanager.h>

#include <qapplication.h>

#include <hbmessagebox.h>

#include <hbaction.h>

#include <hbprogressdialog.h>

#include <iaupdateparameters.h>

#include "iaupdateuicontroller.h"

#include "iaupdateuicontrollerobserver.h"

#include "iaupdate.hrh"

#include "iaupdatenode.h"

#include "iaupdatefwnode.h"

#include "iaupdatebasenode.h"

#include "iaupdatenodefilter.h"

#include "iaupdatefactory.h"

#include "iaupdatestarter.h"

#include "iaupdateprivatecrkeys.h"

#include "iaupdatecontrollerfile.h"

#include "iaupdateuiconfigdata.h"

#include "iaupdateutils.h"

#include "iaupdateagreement.h"

#include "iaupdateautomaticcheck.h"

#include "iaupdateroaminghandler.h"

#include "iaupdatependingnodesfile.h"

#include "iaupdaterestartinfo.h"

#include "iaupdaterresultsfile.h"

#include "iaupdaterresult.h"

#include "iaupdateridentifier.h"

#include "iaupdateruids.h"

#include "iaupdaterdefs.h"

#include "iaupdateparametersfilemanager.h"

#include "iaupdateerrorcodes.h"

#include "iaupdatefileconsts.h"

#include "iaupdatefirsttimeinfo.h"

#include "iaupdaterefreshhandler.h"

#include "iaupdatenodeid.h"

#include "iaupdatewaitdialog.h"

#include "iaupdatedebug.h"

// cenrep in emulator:

// copy 2000F85A.txt to '\epoc32\release\winscw\udeb\Z\private\10202be9\'

// delete 2000F85A.txt from 'epoc32\winscw\c\private\10202be9\persists'

//

// cenrep in hardware:

// copy 2000F85A.txt to '\epoc32\data\Z\private\10202be9'

//

// This is a static function that is used with RPointerArray::Sort to sort

// the nodes according to their node depths and other special values.

TInt SortSelectedNodes( const MIAUpdateNode& aNode1, const MIAUpdateNode& aNode2 )

    {

    // Temporarily use the const_cast here to get the base node.

    // After that, base node is set back to const. So, the casting here

    // is safe to do.

    const MIAUpdateBaseNode& baseNode1( 

        const_cast< MIAUpdateNode& >( aNode1 ).Base() );

    const MIAUpdateBaseNode& baseNode2( 

        const_cast< MIAUpdateNode& >( aNode2 ).Base() );

    if ( baseNode1.Uid().iUid == KIAUpdaterUid

         && baseNode2.Uid().iUid != KIAUpdaterUid )

        {

        // Self updater should always be the first one

        // in the node array.

        return -1;

        }

    else if ( baseNode2.Uid().iUid == KIAUpdaterUid

              && baseNode1.Uid().iUid != KIAUpdaterUid )

        {

        // Self updater should always be the first one

        // in the node array.

        return 1;

        }

    else if ( aNode1.IsSelfUpdate() && !aNode2.IsSelfUpdate() )

        {

        // Self updates always before normal nodes.

        return -1;

        }

    else if ( !aNode1.IsSelfUpdate() && aNode2.IsSelfUpdate() )

        {

        // Self updates always before normal nodes.

        return 1;

        }

    else

        {

        // The depth can be used in normal cases to make sure that dependency

        // nodes are handled before their dependants. Notice, that this is

        // a safe way even if dependency chain contains hidden nodes.

        // The dependency nodes should be before its dependants in the array.

        // The depth value informs how deep in the dependency hierarchy the node is.

        // A depth value zero means that the node is a root. If multiple branches lead to

        // a same node, then the greatest depth value is used for the node.

        // The node can not ever depend on the node that has the same or greater depth.

        TInt depthDiff( aNode2.Depth() - aNode1.Depth() );

        if ( depthDiff != 0 )

            {

            // Depths were different.

            // In some cases, the user may have chosen a dependency node only

            // and left the dependant out. Then this node may be moved unnecessarily

            // in the array. But because dependecies may change the selection order

            // usually quite much, the possible unnecessary movement here should not

            // matter. Notice, that using the depth values is really safe way to make

            // sure the dependency nodes are handled before their dependants.

            return depthDiff;

            }

        else

            {

            // Because depthDiffs equal we need to do some additional checking.

            // This kind of comparison is also used in the filter.

            // See: CIAUpdateNodeFilter::CompareAndMarkFilterNodes

            TInt importanceDiff( 

                baseNode2.Importance() - baseNode1.Importance() );

            if ( importanceDiff != 0 )

                {

                // Sort according to the importance because importances

                // differ.

                return importanceDiff;

                }

            else

                {

                // Because evertyhing else matched, we finally check

                // the name. Items should be handled in alphabetical order

                // now.

                return baseNode1.Name().CompareC( baseNode2.Name() );

                }

            }

        }

    }

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

// CIAUpdateUiController::NewLC

// Two-phased constructor.

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

//

CIAUpdateUiController* CIAUpdateUiController::NewLC( 

    MIAUpdateUiControllerObserver& aObserver )

    {

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateUiController::NewLC() begin");

    CIAUpdateUiController* self = 

        new( ELeave ) CIAUpdateUiController( aObserver );

    CleanupStack::PushL( self );

    self->ConstructL();

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateUiController::NewLC() end");

    return self;

    }

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

// CIAUpdateUiController::NewL

// Two-phased constructor.

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

//

CIAUpdateUiController* CIAUpdateUiController::NewL( 

    MIAUpdateUiControllerObserver& aObserver )

    {

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateUiController::NewL() begin");

    CIAUpdateUiController* self = 

        CIAUpdateUiController::NewLC( aObserver );

    CleanupStack::Pop( self );

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateUiController::NewL() end");

    return self;

    }

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

// CIAUpdateUiController::CIAUpdateUiController

// C++ constructor

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

//

CIAUpdateUiController::CIAUpdateUiController( 

    MIAUpdateUiControllerObserver& aObserver )

: iObserver( aObserver ),

  iState( EIdle )

    {    

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateUiController::CIAUpdateUiController()");

    iEikEnv = CEikonEnv::Static();

    }

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

// CIAUpdateUiController::ConstructL

// 

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

//

void CIAUpdateUiController::ConstructL()

    {    

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateUiController::ConstructL() begin");

    iClosingAllowedByClient = ETrue;

    iController = 

        IAUpdateFactory::CreateControllerL( 

            TUid::Uid( KIAUpdateFamilyUid ), *this );

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateUiController::ConstructL() 1");

    iFilter = CIAUpdateNodeFilter::NewL();

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateUiController::ConstructL() 2");

    // Notice, this will read the init values from the file

    // if the file exists. Otherwise, default values are used.

    iControllerFile = 

        CIAUpdateControllerFile::NewL( IAUpdateFileConsts::KControllerFile );

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateUiController::ConstructL() 3");

    iConfigData = CIAUpdateUiConfigData::NewL();

    iOffConfigurated = !IAUpdateEnabledL();

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateUiController::ConstructL() end");   

    }

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

// CIAUpdateUiController::~CIAUpdateUiController

// Destructor

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

//

CIAUpdateUiController::~CIAUpdateUiController()

    {    

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateUiController::~CIAUpdateUiController() begin");

    CancelOperation();

    delete mWaitDialog;

    delete iController;

    iNodes.Reset();

    iFwNodes.Reset();

    iSelectedNodesArray.Reset();

    iServicePackNodes.Reset();

    iPreviousSelections.Reset();

    delete iFilter;

    delete iControllerFile;

    delete iIdle;

    delete iStarter;

    delete iConfigData;

    delete iRoamingHandler;

    delete iParams;

    delete iRefreshHandler;

    // If dialogs have not been released yet, release them now.

    // ProcessFinishedL() should normally be used for dialogs but

    // here just use non-leaving delete. In normal cases, dialogs should

    // already be released in the end of the update flow before coming here.

    //delete iWaitDialog;

    //delete iProgressDialog;

	IAUPDATE_TRACE("[IAUPDATE] CIAUpdateUiController::~CIAUpdateUiController() end");

    }        

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

// CIAUpdateUiController::ConfigData

// Returns the configuration data from the config file.

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

//

const CIAUpdateUiConfigData& CIAUpdateUiController::ConfigData() const

    {

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateUiController::ConfigData()");

    return *iConfigData;

    }

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

// CIAUpdateUiController::SetDefaultConnectionMethodL

// Sets the connection method for the update network connection.

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

//

void CIAUpdateUiController::SetDefaultConnectionMethodL( const TIAUpdateConnectionMethod& aMethod )

    {

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateUiController::SetDefaultConnectionMethodL() begin");

    iController->SetDefaultConnectionMethodL( aMethod );

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateUiController::SetDefaultConnectionMethodL() end"); 

    }

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

// CIAUpdateUiController::CheckUpdatesL

// Updates the update item list.

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

//

void CIAUpdateUiController::CheckUpdatesL()

    {

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateUiController::CheckUpdatesL() begin");

    iCountOfAvailableUpdates = 0;

    if ( iParams )

        {

    	iFilter->SetFilterParams( iParams ); //iParams ownership is changed

    	iParams = NULL;

        }

    TBool agreementAccepted( EFalse ); 

        {

        }

        {

        if ( iRequestType == IAUpdateUiDefines::ECheckUpdates )

            {

            CIAUpdateAutomaticCheck* automaticCheck = CIAUpdateAutomaticCheck::NewLC();

            TBool autoUpdateCheckEnabled = automaticCheck->AutoUpdateCheckEnabledL();

            CleanupStack::PopAndDestroy( automaticCheck );

            if ( !autoUpdateCheckEnabled )

                {

                iObserver.RefreshCompleteL( ETrue, KErrNone );

                return;

                }

            }

        else if ( iRequestType == IAUpdateUiDefines::EShowUpdates )

            {

       	    iObserver.UpdateCompleteL( KErrNone ); 

       	    return;

       	    }

       	else

       	    {

       	    qApp->quit();

       	    return;	

       	    }

        }

    if ( iRequestType == IAUpdateUiDefines::ECheckUpdates && 

         AllowNetworkRefreshL() && 

         iRoamingHandler->IsRoaming() && 

         !AutomaticConnectionWhenRoamingL() )

        {

        // In Silent check updates case, global setting when roaming to be automatic 

        // Promt dialog is not allowed in the silent check

        // error is returned that a client (backround checker) will try again later 

        iObserver.RefreshCompleteL( EFalse, KErrAbort );

        }  

    else if ( iRequestType == IAUpdateUiDefines::EShowUpdates && iRefreshed )

        {

    	iFilter->FilterAndSortNodesL( iNodes, iFwNodes );

        iObserver.RefreshCompleteL( ETrue, KErrNone );

        }

    else

        {

        TInt ret( iController->Startup() );

        if ( ret == KErrAlreadyExists )   

            {

            IAUPDATE_TRACE("[IAUPDATE] Controller startup already done.");

            // Controller startup has already been done. 

            // So, no operation was started from the controller. 

            // So, call StartupComplete directly from here. 

    	    StartupComplete( KErrNone );

            }

        else

            {

            IAUPDATE_TRACE_1("[IAUPDATE] Controller startup error code: %d", ret);

            // Something went wrong with controller startup if error code is not

            // KErrNone here. Above, KErrAlreadyExists was handled separately.

            // If ret is KErrInUse, then startup was still going on

            // and new startup should not be called. Also, leave in that case.

            User::LeaveIfError( ret );	

            }	

        }

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateUiController::CheckUpdatesL() end");

    }

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

// CIAUpdateUiController::StartUpdateL

// Starts software updating

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

//

void CIAUpdateUiController::StartUpdateL()

    {

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateUiController::StartUpdateL() begin");

    // Just to be sure that self update related information

    // is always in resetted state when new update flows are

    // started.

    iController->ResetSelfUpdate();

    CreateSelectedNodesArrayL();

    if ( !IAUpdateUtils::SpaceAvailableInInternalDrivesL( iSelectedNodesArray ) )

        {

            HbMessageBox messageBox(HbMessageBox::MessageTypeInformation); 

            messageBox.setText(QString("Insufficient memory. Free some memory and try again."));

            HbAction action("OK");

            messageBox.setPrimaryAction(&action);

            messageBox.setTimeout(HbPopup::NoTimeout);

        }

    else

        {

        if ( !IsStartedByLauncher() )

            {

            if ( !iStarter )

                {

                // Notice, that the ownership of the filter parameters will

                // remain in the filter.

                CIAUpdateParameters* params = iFilter->FilterParams();

      	        iStarter = CIAUpdateStarter::NewL( params->CommandLineExecutable(), 

        	                                           params->CommandLineArguments() );

                }

            }

        // Inform the controller that we are now starting updates. This way the

        // controller can handle situations as a whole and not as one item at the

        // time.

        iController->StartingUpdatesL();

        iFileInUseError = EFalse;

        // Set the node index to -1 because ContinueUpdateL increases it by one

        // in the beginning of the function. So, we can use the ContinueUpdateL

        // also in here.

        iNodeIndex = -1;

        ContinueUpdateL( EFalse );

        }

	IAUPDATE_TRACE("[IAUPDATE] CIAUpdateUiController::StartUpdateL() end");

    }

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

// CIAUpdateUiController::ContinueUpdateL

// Continues software updating from the next node

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

//

void CIAUpdateUiController::ContinueUpdateL( TBool aSelfUpdateFinished )

    {

    IAUPDATE_TRACE_1("[IAUPDATE] CIAUpdateUiController::ContinueUpdateL() begin: %d",

                   aSelfUpdateFinished );

    // Get the node index of the next node.

    // The node that is indexed by iNodeIndex has already been handled in

    // previous loop. So, increase the temp index by one here as it will be done

    // in the while loop below for real index.

    TInt tmpIndex( iNodeIndex + 1 );

    if ( tmpIndex > 0 

        && tmpIndex < iSelectedNodesArray.Count()

        && iSelectedNodesArray[ tmpIndex - 1 ]->IsSelfUpdate()

        && !iSelectedNodesArray[ tmpIndex ]->IsSelfUpdate()

        && !aSelfUpdateFinished

        && iController->SelfUpdateDataExists() )

        {

        IAUPDATE_TRACE_1("[IAUPDATE] Self updates have been handled now: %d",

                         iNodeIndex);

        // Self update should be started now because

        // current node is not anymore self update and previous nodes were.

        // UpdateCompleteL will start the self updater and inform observers.

        // If no self update data can be found, then there has been some error

        // when self update data has been set. So, then there is no reason to start

        // self updater here. In that case, continue normally in the while loop below if

        // other items are waiting for update.

        iNodeIndex++;

        UpdateCompleteL( KErrNone );

        // Do not continue after this.

        return;

        }

    TBool nextUpdate( ETrue );

    while ( nextUpdate )

       {

       IAUPDATE_TRACE_1("[IAUPDATE] Next update while loop: %d",

                        iNodeIndex);

       iNodeIndex++;

       if ( iNodeIndex < iSelectedNodesArray.Count() )

            {

            MIAUpdateNode* selectedNode = iSelectedNodesArray[ iNodeIndex ];

            // Only update items that have not been installed yet.

            if ( !selectedNode->IsInstalled() )

                {

                IAUPDATE_TRACE("[IAUPDATE] Item not installed yet");    

                if ( !selectedNode->IsDownloaded() )

                    {

                    // Because content has not been downloaded or installed yet,

                    // it needs to be downloaded before it can be installed.

                    IAUPDATE_TRACE("[IAUPDATE] Download");

                    selectedNode->DownloadL( *this );

                    iState = EDownloading;

                    iClosingAllowedByClient = ETrue;

                    /*ShowUpdatingDialogL( R_IAUPDATE_DOWNLOADING_NOTE,

                                         selectedNode->Base().Name(),

                                         iNodeIndex + 1,