/*

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

*                member functions.

*

*/

// INCLUDES

#include <avkon.hrh>

#include <StringLoader.h> 

#include <iaupdate.rsg>

#include <centralrepository.h>

#include <apgwgnam.h>

#include <f32file.h>

#include <ErrorUI.h>

#include <starterclient.h>

#include <iaupdateresult.h>

#include <iaupdateparameters.h>

#include <cmmanagerext.h>

#include <cmconnectionmethodext.h>

#include <cmconnectionmethoddef.h>

#include <cmpluginpacketdatadef.h>

#include <cmdestinationext.h>

#include <cmmanagerdef.h>

#include <rconnmon.h>

#include <hlplch.h>                   

#include "iaupdateappui.h"

#include "iaupdatemainview.h"

#include "iaupdatehistoryview.h"

#include "iaupdate.hrh"

#include "iaupdatenode.h"

#include "iaupdatefwnode.h"

#include "iaupdatebasenode.h"

#include "iaupdateuicontroller.h"

#include "iaupdaterequestobserver.h"

#include "iaupdateserver.h"

#include "iaupdatestatusdialog.h"

#include "iaupdatedetailsdialog.h"

#include "iaupdatefwdetailsdialog.h"

#include "iaupdatesettingdialog.h"

#include "iaupdateprivatecrkeys.h"

#include "iaupdatestarter.h"

#include "iaupdateuiconfigdata.h"

#include "iaupdateagreement.h"

#include "iaupdateautomaticcheck.h"

#include "iaupdatequeryhistory.h"

#include "iaupdatedialogutil.h"

#include "iaupdategloballockhandler.h"

#include "iaupdatenodefilter.h"

#include "iaupdateuitimer.h"

#include "iaupdateagreement.h"

#include "iaupdatedebug.h"

const TUint KSWInstSvrUid = 0x101F875A;

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

// CIAUpdateAppUi::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CIAUpdateAppUi::ConstructL()

    {    

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

    TInt ownWgId = iEikonEnv->RootWin().Identifier();

    RArray<RWsSession::TWindowGroupChainInfo> wgList;

    iEikonEnv->WsSession().WindowGroupList( &wgList );

    TBool chained = EFalse;

    for ( TInt i = 0; i < wgList.Count() && !chained ; i++ )

        {

        if ( wgList[i].iId == ownWgId && wgList[i].iParentId > 0 )

            {

            chained = ETrue;

            }

        }

    wgList.Reset();

    if ( chained )

        {

        BaseConstructL( EAknEnableSkin | EAknEnableMSK | EAknSingleClickCompatible );

        }

    else

        {

        iEikonEnv->RootWin().SetOrdinalPosition( -1, ECoeWinPriorityNeverAtFront );

        BaseConstructL( EAknEnableSkin | EAknEnableMSK | EAknSingleClickCompatible );

        StatusPane()->MakeVisible( EFalse );

        }

    iController = CIAUpdateUiController::NewL( *this ); 

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

    }

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

// CIAUpdateAppUi::CIAUpdateAppUi

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

// might leave.

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

//

CIAUpdateAppUi::CIAUpdateAppUi(): iIsDMSet( EFalse ), iUiRefreshAllowed( ETrue )                              

    { 

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

    }

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

// CIAUpdateAppUi::~CIAUpdateAppUi

// Destructor

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

//

CIAUpdateAppUi::~CIAUpdateAppUi()

    {    

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

    iShowStatusDialogAgain = EFalse;

    delete iGlobalLockHandler;

    iDestIdArray.Reset();

	delete iController;

	delete iIdle;

	delete iIdleAutCheck;

	delete iForegroundTimer;

	delete iBackgroundTimer;

	delete iDialogParam;

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

    }        

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

// CIAUpdateAppUi::StartedByLauncherL

// 

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

//

void CIAUpdateAppUi::StartedByLauncherL( MIAUpdateRequestObserver& aObserver, 

                                         TBool aRefreshFromNetworkDenied )

    {

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::StartedByLauncherL() begin");

    iRequestObserver = &aObserver;

    iRequestType = IAUpdateUiDefines::ENoRequest;

    iController->SetRequestType( iRequestType );

    SetVisibleL( ETrue );

    CIAUpdateParameters* params = iController->ParamsReadAndRemoveFileL();

    iController->CheckUpdatesDeferredL( params, aRefreshFromNetworkDenied );

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::StartedByLauncherL() end");

    }

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

// CIAUpdateAppUi::CheckUpdatesRequestL

// 

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

//

void CIAUpdateAppUi::CheckUpdatesRequestL( MIAUpdateRequestObserver& aObserver,

                                           CIAUpdateParameters* aFilterParams,

                                           TBool aForcedRefresh )

    {

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::CheckUpdatesRequestL() begin");

    iStartedFromApplication  = ETrue;

    CleanupStack::PushL( aFilterParams );

    if ( iWgId > 0 )

        {

        HideApplicationInFSWL( ETrue );

        }

    CleanupStack::Pop( aFilterParams );

    if ( !aFilterParams->ShowProgress() )

        {

        iEikonEnv->RootWin().SetOrdinalPosition( -1, ECoeWinPriorityNeverAtFront );	

        }

    iRequestObserver = &aObserver;

    iRequestType = IAUpdateUiDefines::ECheckUpdates; 

    iController->SetRequestType( iRequestType );

    IAUPDATE_TRACE_1("[IAUPDATE] CIAUpdateAppUi::CheckUpdatesRequestL() Forced refresh: %d", aForcedRefresh );

    iController->SetForcedRefresh( aForcedRefresh ); 

    iController->CheckUpdatesDeferredL( aFilterParams, EFalse );

	IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::CheckUpdatesRequestL() end");

    }

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

// CIAUpdateAppUi::ShowUpdatesRequestL

// 

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

// 

void CIAUpdateAppUi::ShowUpdatesRequestL( MIAUpdateRequestObserver& aObserver,

                                          CIAUpdateParameters* aFilterParams )

    {

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::ShowUpdatesRequestL() begin"); 

    delete iBackgroundTimer;

    iBackgroundTimer = NULL;

    iStartedFromApplication  = ETrue;

    CleanupStack::PushL( aFilterParams );

    if ( iWgId > 0 )

        {

        HideApplicationInFSWL( ETrue );

        }

    StatusPane()->MakeVisible( ETrue );

    iEikonEnv->RootWin().SetOrdinalPosition( 0, ECoeWinPriorityNormal );

    iRequestObserver = &aObserver;

    iRequestType = IAUpdateUiDefines::EShowUpdates;

    iController->SetRequestType( iRequestType );

    if ( !iMainView )

        {

    	iMainView  = CIAUpdateMainView::NewL( ClientRect() ); 

    	AddViewL( iMainView );

        }

    // by pushing object to cleanup stack its destructor is called if leave happens

    // so global lock issued by this instance can be released in destructor of CIAUpdateGlobalLockHandler

    CIAUpdateGlobalLockHandler* globalLockHandler = CIAUpdateGlobalLockHandler::NewLC();

    if ( !globalLockHandler->InUseByAnotherInstanceL() )

        {

        globalLockHandler->SetToInUseForAnotherInstancesL( ETrue );

        CleanupStack::Pop( globalLockHandler );

        CleanupStack::Pop( aFilterParams );

        CleanupStack::PushL( globalLockHandler );

        iController->CheckUpdatesDeferredL( aFilterParams, EFalse );

        CleanupStack::Pop( globalLockHandler );	

        delete iGlobalLockHandler;

        iGlobalLockHandler = globalLockHandler;

        //now possible deletion of iGlobalLockHandler in leave situation is handled

        //in HandleLeaveErrorL() and HandleLeaveErrorWithoutLeave methods. 

        }

    else

        {

        CleanupStack::PopAndDestroy( globalLockHandler );

        CleanupStack::PopAndDestroy( aFilterParams );

        // locked by another IAD instance, nothing else to do than just complete client's request.	

        InformRequestObserver( KErrNone );

        }  

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::ShowUpdatesRequestL() end"); 

    }

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

// CIAUpdateAppUi::ShowUpdateQueryRequestL

// 

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

//     

void CIAUpdateAppUi::ShowUpdateQueryRequestL( MIAUpdateRequestObserver& aObserver, 

                                              TUint aUid )

    {

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::ShowUpdateQueryRequestL begin");

    iStartedFromApplication  = ETrue;

    iUpdatequeryUid = aUid;

    iUpdateNow = EFalse;

    if ( iWgId > 0 )

        {

        HideApplicationInFSWL( ETrue );

        }

    iRequestObserver = &aObserver;

    iRequestType = IAUpdateUiDefines::EUpdateQuery;

    delete iIdle;

    iIdle = NULL;

	iIdle = CIdle::NewL( CActive::EPriorityIdle ); 

    iIdle->Start( TCallBack( UpdateQueryCallbackL, this ) ); 

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::ShowUpdateQueryRequestL end")

    }

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

// CIAUpdateAppUi::HandleObserverRemoval

// 

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

// 

void CIAUpdateAppUi::HandleObserverRemoval()

    {

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::HandleObserverRemoval() begin");

	iRequestObserver = NULL;

	IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::HandleObserverRemoval() end");

    }

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

// CIAUpdateAppUi::TextLinkL

// 

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

// 

void CIAUpdateAppUi::TextLinkL( TInt /*aLinkId*/ )

    {

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::TextLinkL() begin");

    TRAPD( err, HandleTextLinkL() );

    if ( err != KErrNone )

        {

    	HandleLeaveErrorL( err );

        }

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::TextLinkL() end");

    }

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

// CIAUpdateAppUi::HandleCommandL

// 

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

//         

void CIAUpdateAppUi::HandleCommandL( TInt aCommand )

    {

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::HandleCommandL() begin");   

    IAUPDATE_TRACE_1("[IAUPDATE] command id: %d", aCommand );

    switch(aCommand)

        {

        case EIAUpdateCmdStartUpdate:

            {

            IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::HandleCommandL() EIAUpdateCmdStartUpdate");

            // by pushing object to cleanup stack it's destructor is called if leave happens

            // so global lock issued by this instance can be released in destructor of CIAUpdateGlobalLockHandler

            CIAUpdateGlobalLockHandler* globalLockHandler = CIAUpdateGlobalLockHandler::NewLC();

            if ( !globalLockHandler->InUseByAnotherInstanceL() )

                {

            	globalLockHandler->SetToInUseForAnotherInstancesL( ETrue );

            	// No need to be totally silent since the updating is started

            	// by user.

            	SetDefaultConnectionMethodL( EFalse );

            	iController->StartUpdateL();

            	CleanupStack::Pop( globalLockHandler );	

            	delete iGlobalLockHandler;

            	iGlobalLockHandler = globalLockHandler;

            	//now possible deletion of iGlobalLockHandler in leave situation is handled

            	//in HandleLeaveErrorL() and HandleLeaveErrorWithoutLeave methods. 

                }

            else

                {

                CleanupStack::PopAndDestroy( globalLockHandler ); 	

                }

            break;	

            } 

       	case EIAUpdateCmdSettings:

       	    {

       	    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::HandleCommandL() EIAUpdateCmdSettings");

            CIAUpdateSettingDialog::ShowDialogL();

            break;	

       	    } 

       	case EIAUpdateCmdUpdateDetails:

       	     {

       	     IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::HandleCommandL() EIAUpdateCmdUpdateDetails");

       	     if ( iMainView->GetCurrentNode()->NodeType() == MIAUpdateAnyNode::ENodeTypeNormal )

       	         {

       	         TIAUpdateDialogParam param;

       	         param.iNode = static_cast<MIAUpdateNode*>( iMainView->GetCurrentNode() );

       	         CIAUpdateDetailsDialog::ShowDialogL( &param );

       	         }

       	     if (iMainView->GetCurrentNode()->NodeType() == MIAUpdateAnyNode::ENodeTypeFw )

       	         {

       	         //this is changed because of the new requirement: when both NSU and FOTA available, only show FOTA in details

       	         MIAUpdateFwNode* node = static_cast<MIAUpdateFwNode*>( iMainView->GetCurrentNode() );

       	         CIAUpdateFwDetailsDialog::ShowDialogL( node );

       	         }

       	      break;      

       	      }

        case EIAUpdateCmdMarkedUpdateDetails:

            {

            IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::HandleCommandL() EIAUpdateCmdUpdateDetails");

            if ( iMainView->GetSelectedNode()->NodeType() == MIAUpdateAnyNode::ENodeTypeNormal )

                {

                TIAUpdateDialogParam param;

                param.iNode = static_cast<MIAUpdateNode*>( iMainView->GetSelectedNode() );

                CIAUpdateDetailsDialog::ShowDialogL( &param );

                }

            if (iMainView->GetSelectedNode()->NodeType() == MIAUpdateAnyNode::ENodeTypeFw )

                {

                //this is changed because of the new requirement: when both NSU and FOTA available, only show FOTA in details

                MIAUpdateFwNode* node = static_cast<MIAUpdateFwNode*>( iMainView->GetSelectedNode() );

                CIAUpdateFwDetailsDialog::ShowDialogL( node );

                }

            break;		

            }

        // History view

        case EIAUpdateCmdUpdateHistory:

            {

            IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::HandleCommandL() EIAUpdateCmdUpdateHistory");

            if ( !iHistoryView )

                {

                iHistoryView = 

                    CIAUpdateHistoryView::NewL( iController->HistoryL() );

                AddViewL( iHistoryView );

                }

            ActivateLocalViewL( TUid::Uid( EIAUpdateHistoryViewId ) );

            break;	

            }

        case EIAUpdateCmdDisclaimer:

            {

            IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::HandleCommandL() EIAUpdateCmdDisclaimer");

            CIAUpdateAgreement* agreement = CIAUpdateAgreement::NewLC();

            agreement->ShowAgreementL();

            CleanupStack::PopAndDestroy( agreement);

            break;	

            }

        case EAknCmdHelp:

            {

            IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::HandleCommandL() EAknCmdHelp");

            HlpLauncher::LaunchHelpApplicationL( iEikonEnv->WsSession(), AppHelpContextL() );

            break;

            }

        case EEikCmdExit:

        case EAknCmdExit:

        case EAknSoftkeyExit:

            {

            IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::HandleCommandL() Exit");

            if (iController )

                {

                iController->CancelOperation();

                if ( iController->Starter() )

                	 {

                	 iController->Starter()->BringToForegroundL();

                	 }

                }

            if ( iRequestObserver )

                {

   	            InformRequestObserver( KErrCancel );

                }

            Exit();	

            break;

            }

        case EIAUpdateCmdHistoryViewExit:

            IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::HandleCommandL() EIAUpdateCmdHistoryViewExit");

            ActivateLocalViewL( TUid::Uid( EIAUpdateMainViewId ) );

            break;

        default:

            {

            break;

            }

        }

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::HandleCommandL() end")    

    }

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

// CIAUpdateppUi::HandleWsEventL

// 

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

// 

void CIAUpdateAppUi::HandleWsEventL( const TWsEvent& aEvent, CCoeControl* aDestination )

    {

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateAppUi::HandleWsEventL() begin");   

    CAknViewAppUi::HandleWsEventL( aEvent, aDestination );

  	if ( aEvent.Type() == EEventWindowGroupListChanged )

	    {

        IAUPDATE_TRACE("[IAUPDATE] Window group list changed"); 

		RWindowGroup owngroup;

		TInt ownWgId = iEikonEnv->RootWin().Identifier();

  		TApaTaskList tasklist( iEikonEnv->WsSession() );   

        TApaTask task = tasklist.FindApp( TUid::Uid( KSWInstSvrUid ) );

        if ( task.Exists() )

            {

            IAUPDATE_TRACE("[IAUPDATE] Installer task exists");

            TInt instUiWgId = task.WgId();

            TInt ownPosition = KErrNotFound;

            TInt instUiPosition = KErrNotFound;

            CArrayFixFlat<TInt>*  wgArray = new(ELeave)CArrayFixFlat<TInt>(10);  

            CleanupStack::PushL( wgArray );

            User::LeaveIfError( iEikonEnv->WsSession().WindowGroupList( 0, wgArray ) );   

            for ( TInt i = 0; i < wgArray->Count(); i++ )

                {

                if ( wgArray->At(i) == ownWgId )

                    {

                    IAUPDATE_TRACE_1("[IAUPDATE] ownPosition: %d", i);

                	ownPosition = i;

                    }

                else if ( wgArray->At(i) == instUiWgId )

                    {

                    IAUPDATE_TRACE_1("[IAUPDATE] instUiPosition: %d", i);

                	instUiPosition = i;

                    }

                }

            CleanupStack::PopAndDestroy( wgArray );

          	if ( ownPosition == 0 && iInstUiOnTop )

                {

                // IAD is now topmost. In the case Installer UI was previously on the top of IAD 

                // bring Installer UI foreground 

                IAUPDATE_TRACE("[IAUPDATE] instUi to foreground");

            	task.BringToForeground();

            	iInstUiOnTop = EFalse;

                }

            else

                {

                if ( instUiPosition < ownPosition  && 

                    instUiPosition != KErrNotFound && 

                    ownPosition != KErrNotFound )