/*

* Copyright (c) 2009-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 IAUpdateEngine

*                class member functions.

*

*/

#include <qapplication.h>

#include <hbmessagebox.h>

#include <hbaction.h>

#include <eikenv.h>

#include <centralrepository.h>

#include <cmmanagerext.h>

#include <cmdestinationext.h>

#include <rconnmon.h>

#include <apgwgnam.h>

#include "iaupdateengine.h"

#include "iaupdateserviceprovider.h"

#include "iaupdateuicontroller.h"

#include "iaupdategloballockhandler.h"

#include "iaupdatenodefilter.h"

#include "iaupdateresult.h"

#include "iaupdateprivatecrkeys.h"

#include "iaupdateuiconfigdata.h"

#include "iaupdatequeryhistory.h"

#include "iaupdateparameters.h"

#include "iaupdatedebug.h"

IAUpdateEngine::IAUpdateEngine(QObject *parent)

    : QObject(parent),

      iController(NULL),

      iGlobalLockHandler(NULL),

      iIdle(NULL),

      iUpdateNow(EFalse),

      iRequestIssued(EFalse),

      iStartedFromApplication(EFalse),

      iUpdatequeryUid(0)

{

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::IAUpdateEngine() begin");

    iEikEnv = CEikonEnv::Static();

    mServiceProvider = new IAUpdateServiceProvider( *this );

    connect(mServiceProvider, SIGNAL(clientDisconnected()), this, SLOT(handleAllClientsClosed()));

    TRAP_IGNORE( iController = CIAUpdateUiController::NewL( *this ));

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::IAUpdateEngine() end")

}

IAUpdateEngine::~IAUpdateEngine()

{

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

    InformRequestObserver( KErrCancel );

    delete iGlobalLockHandler;

    delete iController;

    delete mServiceProvider;    

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

}

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

// IAUpdateEngine::StartedByLauncherL

// 

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

//

void IAUpdateEngine::StartedByLauncherL( TBool aRefreshFromNetworkDenied )

    {

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

    iRequestIssued = ETrue;

    iRequestType = IAUpdateUiDefines::ENoRequest;

    iController->SetRequestType( iRequestType );

    SetVisibleL( ETrue );

    CIAUpdateParameters* params = iController->ParamsReadAndRemoveFileL();

    iController->CheckUpdatesDeferredL( params, aRefreshFromNetworkDenied );

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

    }

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

// IAUpdateEngine::CheckUpdatesRequestL

// 

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

//

void IAUpdateEngine::CheckUpdatesRequestL( int wgid, CIAUpdateParameters* aFilterParams )

    {

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

    SetClientWgId( wgid );

    iRequestIssued = ETrue;

    iStartedFromApplication  = ETrue;

    CleanupStack::PushL( aFilterParams );

    if ( wgid > 0 )

        {

        HideApplicationInFSWL( ETrue );

        }

    CleanupStack::Pop( aFilterParams );

    if ( !aFilterParams->ShowProgress() )

        {

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

        }

    iRequestType = IAUpdateUiDefines::ECheckUpdates; 

    iController->SetRequestType( iRequestType );

    iController->CheckUpdatesDeferredL( aFilterParams, EFalse ); 

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

    }

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

// IAUpdateEngine::ShowUpdatesRequestL

// 

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

// 

void IAUpdateEngine::ShowUpdatesRequestL( int wgid, CIAUpdateParameters* aFilterParams )

    {

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

    SetClientWgId( wgid );

    iRequestIssued = ETrue;

//    delete iBackgroundTimer;

//    iBackgroundTimer = NULL;

    iStartedFromApplication  = ETrue;

    CleanupStack::PushL( aFilterParams );

    if ( wgid > 0 )

        {

        HideApplicationInFSWL( ETrue );

        }

    //StatusPane()->MakeVisible( ETrue );

    iEikEnv->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] IAUpdateEngine::ShowUpdatesRequestL() end"); 

    }

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

// IAUpdateEngine::ShowUpdateQueryRequestL

// 

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

//     

void IAUpdateEngine::ShowUpdateQueryRequestL( int wgid, TUint aUid )

    {

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

    SetClientWgId( wgid );

    iRequestIssued = ETrue;

    iStartedFromApplication  = ETrue;

    iUpdatequeryUid = aUid;

    iUpdateNow = EFalse;

    if ( wgid > 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] IAUpdateEngine::ShowUpdateQueryRequestL end")

    }

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

// IAUpdateEngine::SetVisibleL

// 

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

//  

void IAUpdateEngine::SetVisibleL( TBool aVisible )

    {

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::SetVisibleL() begin");

    IAUPDATE_TRACE_1("[IAUPDATE] visible: %d", aVisible );

    /*if ( aVisible )

        {

        if ( iEikonEnv->RootWin().OrdinalPosition() != 0 || iEikonEnv->RootWin().OrdinalPriority() != ECoeWinPriorityNormal )

            {

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

            }

        StatusPane()->MakeVisible( ETrue );

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

        AddViewL( iMainView );

        ActivateLocalViewL( TUid::Uid( EIAUpdateMainViewId ) );

        }

    else

        {

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

        StatusPane()->MakeVisible( EFalse );

        }*/

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::SetVisibleL() end");

    }

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

// IAUpdateEngine::SetClientWgId

// 

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

// 

void IAUpdateEngine::SetClientWgId( TInt aWgId )

    {

    IAUPDATE_TRACE_1("[IAUPDATE] IAUpdateEngine::SetClientWgId() wgId %d", aWgId );

    iWgId = aWgId;

    }

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

// IAUpdateEngine::ClientInBackgroundL

// 

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

// 

TInt IAUpdateEngine::ClientInBackgroundL() const

    {

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::ClientInBackgroundL() begin");

    TBool inBackground = EFalse;

    if ( iWgId > 0 )

        {

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

        CleanupStack::PushL( wgArray );

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

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

        if ( ( wgArray->At( 0 ) != ownWgId ) && ( wgArray->At( 0 ) != iWgId  ) )

            {

            inBackground = ETrue;

            }

        CleanupStack::PopAndDestroy( wgArray );  

        }

    IAUPDATE_TRACE_1("[IAUPDATE] IAUpdateEngine::ClientInBackgroundL() inBackground: %d", inBackground );

    return inBackground;  

    }

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

// IAUpdateEngine::refresh

// 

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

//  

/*void IAUpdateEngine::refresh(int error) 

    {

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::refresh() begin");

    IAUPDATE_TRACE_1("[IAUPDATE] Error code: %d", error );

    //iMainView->RefreshL( iController->Nodes(), iController->FwNodes(), aError );                    

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::refresh() end");

    }*/

void IAUpdateEngine::handleAllClientsClosed()

{

    qApp->quit(); 

}

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

// IAUpdateEngine::StartupComplete

// 

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

//    

void IAUpdateEngine::StartupComplete( TInt aError )

    {

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::StartupComplete() begin"); 

    IAUPDATE_TRACE_1("[IAUPDATE] error code: %d", aError);

    if( aError != KErrNone ) 

        {  

        HandleLeaveErrorWithoutLeave( aError );

        }

    else

        {

        TRAPD( err, StartupCompleteL() );

        if( err != KErrNone ) 

           {  

           HandleLeaveErrorWithoutLeave( err );

           }

        }

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::StartupComplete() end");    

    }

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

// IAUpdateEngine::StartupCompleteL

// 

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

//    

void IAUpdateEngine::StartupCompleteL()

    {

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::StartupCompleteL() begin"); 

    delete iGlobalLockHandler;

    iGlobalLockHandler = NULL;

    iGlobalLockHandler = CIAUpdateGlobalLockHandler::NewL();

    if ( !iGlobalLockHandler->InUseByAnotherInstanceL() )

        {

        TBool totalSilent( EFalse );

        if ( iRequestType == IAUpdateUiDefines::ECheckUpdates )

            {

            if ( iController->Filter() )

                {

                if ( iController->Filter()->FilterParams() )

                    {

                    if ( iController->Filter()->FilterParams()->Refresh() )

                        {

                        //from bgchecker, make it silent

                        totalSilent = ETrue;

                        }

                    }

                }

            }

        SetDefaultConnectionMethodL( totalSilent );

        iGlobalLockHandler->SetToInUseForAnotherInstancesL( ETrue );

        iController->StartRefreshL();  

        }

    else

        {

        RefreshCompleteL( ETrue, KErrServerBusy );

        }    

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::StartupCompleteL() end");    

    }

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

// IAUpdateEngine::HandleLeaveErrorL

// 

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

//        

void IAUpdateEngine::HandleLeaveErrorL( TInt aError )

    {

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::HandleLeaveErrorL() begin");

    //removal of iGlobalLockHandler releases possible global operation lock to other IAD instances

    delete iGlobalLockHandler;

    iGlobalLockHandler = NULL;

    // client request is completed before leave in case of leave error

    if ( aError != KErrNone ) 

        {   

        InformRequestObserver( aError );

        User::Leave( aError );

        }

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::HandleLeaveErrorL() end");

    }

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

// IAUpdateEngine::HandleLeaveErrorWithoutLeave

// 

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

//  

void IAUpdateEngine::HandleLeaveErrorWithoutLeave( TInt aError )

    {

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::HandleLeaveErrorWithoutLeave() begin");

    //removal of iGlobalLockHandler releases possible global operation lock to other IAD instances

    delete iGlobalLockHandler;

    iGlobalLockHandler = NULL;

    if ( aError != KErrNone ) 

        {

        InformRequestObserver( aError );

        }

    if ( aError == KErrDiskFull )

        {

        //TRAP_IGNORE( ShowGlobalErrorNoteL( aError ) );

        }

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::HandleLeaveErrorWithoutLeave end");

    }

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

// IAUpdateEngine::RefreshCompleteL

// 

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

//      

void IAUpdateEngine::RefreshCompleteL( TBool /*aWithViewActivation*/, TInt aError )

    {

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::RefreshCompleteL() begin");

    IAUPDATE_TRACE_1("[IAUPDATE] error code: %d", aError );

    //removal of iGlobalLockHandler releases possible global operation lock to other IAD instances

    delete iGlobalLockHandler;

    iGlobalLockHandler = NULL;   

    if ( iRequestType == IAUpdateUiDefines::ECheckUpdates )

        {

        InformRequestObserver( aError );

        }

    else 

        {    

        emit refresh( iController->Nodes(), iController->FwNodes(), aError );   

        //if ( aWithViewActivation)

          //  {

          //  ActivateLocalViewL( TUid::Uid( EIAUpdateMainViewId ) );

          //  }

        // By calling CIdle possible waiting dialog can be closed before

        // automatic check where a new dialog may be launched

        //delete iIdleAutCheck;

        //iIdleAutCheck = NULL;

        //iIdleAutCheck = CIdle::NewL( CActive::EPriorityIdle ); 

        //iIdleAutCheck->Start( TCallBack( AutomaticCheckCallbackL, this ) );*/

        } 

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::RefreshCompleteL() end");        

    }

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

// IAUpdateEngine::UpdateCompleteL

// 

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

//     

void IAUpdateEngine::UpdateCompleteL( TInt aError )    

    {

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::UpdateCompleteL begin");

    IAUPDATE_TRACE_1("[IAUPDATE] error code: %d", aError );

    //removal of iGlobalLockHandler releases possible global operation lock to other IAD instances

    delete iGlobalLockHandler;

    iGlobalLockHandler = NULL;  

    if ( iRequestType != IAUpdateUiDefines::ENoRequest )

        {

        InformRequestObserver( aError );

        }

    //RefreshL( KErrNone ); 

    //ShowStatusDialogDeferredL();

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::UpdateCompleteL end");

    }

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

// IAUpdateEngine::InformRequestObserver

// 

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

//      

void IAUpdateEngine::InformRequestObserver( TInt aError )

    {

    IAUPDATE_TRACE("[IAUPDATE] IAUpdateEngine::InformRequestObserver() begin");

    //if ( iRequestObserver )

    if ( iRequestIssued )    

        {

        if ( iController->ClosingAllowedByClient() )

            {

            if ( iRequestType != IAUpdateUiDefines::ENoRequest )

                {

//                if ( iRequestType == IAUpdateUiDefines::EUpdateQuery && iUpdateNow )

//                    {

//                  if ( !iBackgroundTimer )

//                        {

//                        iBackgroundTimer = CIAUpdateUITimer::NewL( *this, CIAUpdateUITimer::EBackgroundDelay );

//                        }

//                 if ( !iBackgroundTimer->IsActive() )

//                        {

//                        iBackgroundTimer->After( 500000 );

//                        }

//                    }

//                 else

//                    {

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

//                    }

                }

            }

        switch ( iRequestType )

            {

            case IAUpdateUiDefines::ENoRequest:

                {

                mServiceProvider->completeLauncherLaunch( aError );

                break;

                }

            case IAUpdateUiDefines::ECheckUpdates:

                {

                mServiceProvider->completeCheckUpdates( iController->CountOfAvailableUpdates(), aError );

                break;

                }

            case IAUpdateUiDefines::EShowUpdates:

                {

                CIAUpdateResult* result( NULL );

                TRAPD( error, result = CIAUpdateResult::NewL() )

                if ( result )

                    {

                    TIAUpdateResultsInfo resultsInfo( iController->ResultsInfo() );

                    IAUPDATE_TRACE_3("[IAUPDATE] IAUpdateEngine::InformRequestObserver succeed: %d failed: %d  cancelled: %d",