/*

* 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 <starterclient.h>

#include "iaupdateengine.h"

#include "iaupdateserviceprovider.h"

#include "iaupdateuicontroller.h"

#include "iaupdatefwupdatehandler.h"

#include "iaupdategloballockhandler.h"

#include "iaupdatenodefilter.h"

#include "iaupdateresult.h"

#include "iaupdateprivatecrkeys.h"

#include "iaupdateuiconfigdata.h"

#include "iaupdatequeryhistory.h"

#include "iaupdateparameters.h"

#include "iaupdateagreement.h"

#include "iaupdateautomaticcheck.h"

#include "iaupdateresultsdialog.h"

#include "iaupdatedebug.h"

IAUpdateEngine::IAUpdateEngine(QObject *parent)

{

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

    iEikEnv = CEikonEnv::Static();

    mServiceProvider = NULL;

    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 );

    if (iIdle)

        {

        delete iIdle;

        }

    if (iIdleAutCheck)

        {

        delete iIdleAutCheck;

        }

    if (iGlobalLockHandler)

        {

        delete iGlobalLockHandler;

        }

    if ( iController )

        {

        delete iController;

        }

    if ( iFwUpdateHandler )

        {

        delete iFwUpdateHandler;

        }

    if ( mServiceProvider )

        {

        delete mServiceProvider;

        }

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

}

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

// IAUpdateEngine::StartedByLauncherL

// 

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

//

    {

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

    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 );

    CleanupStack::PushL( aFilterParams );

    if ( wgid > 0 )

        {

        }

    CleanupStack::Pop( aFilterParams );

    if ( !aFilterParams->ShowProgress() )

        {

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

        }

    iController->SetForcedRefresh( aForcedRefresh );

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

    }

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

// IAUpdateEngine::ShowUpdatesRequestL

// 

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

// 

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

    {

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

    SetClientWgId( wgid );

//    delete iBackgroundTimer;

//    iBackgroundTimer = NULL;

    CleanupStack::PushL( aFilterParams );

    if ( wgid > 0 )

        {

        }

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

    //iRequestObserver = &aObserver;

    //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() )

        {

        CleanupStack::Pop( globalLockHandler );

        CleanupStack::Pop( aFilterParams );

        CleanupStack::PushL( globalLockHandler );

        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

// 

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

//     

    {

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

    SetClientWgId( wgid );

    if ( wgid > 0 )

        {

        }

    delete iIdle;

    iIdle = NULL;

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

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

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

    }

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

// IAUpdateEngine::StartUpdate

// 

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

//

    {

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

    if ( aFirmwareUpdate )

        {

        if ( !iFwUpdateHandler )

            {

            TRAP_IGNORE( CIAUpdateFWUpdateHandler::NewL() );

            }

        if ( iFwUpdateHandler )

            {

            iFwUpdateHandler->FirmWareUpdatewithFOTA();

            }

        }

    else

        {

        // 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() )

            {

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

            // by user.

            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 );   

            }

        }

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

    }

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

// IAUpdateEngine::SetVisibleL

// 

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

//  

    {

    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

// 

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

// 

    {

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

    }

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

// IAUpdateEngine::ClientInBackgroundL

// 

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

// 

    {

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

        {

        CleanupStack::PushL( wgArray );

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

            {

            }

        CleanupStack::PopAndDestroy( wgArray );  

        }

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

    return inBackground;  

    }

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

// IAUpdateEngine::handleAllClientsClosed()

// 

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

//

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() )

        {

            {

            if ( iController->Filter() )

                {

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

                    {

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

                        {

                        if ( !iController->ForcedRefresh() )

                            {

                            //from bgchecker, make it silent

                            }

                        }

                    }

                }

            }

        SetDefaultConnectionMethodL( totalSilent );

        iController->StartRefreshL();  

        }

    else

        {

        }    

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

    }

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