/*

* Copyright (c) 2007-2008 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:  Implementation of CWsfModel

*

*/

//  EXTERNAL INCLUDES

#include <eikenv.h>

#include <apgcli.h>

#include <apgtask.h>

#include <ictsclientinterface.h>

#include <cmmanagerext.h>

#include <cmdestinationext.h>

#include <cmpluginwlandef.h>

#include <centralrepository.h>

#include <internetconnectivitycrkeys.h>

#include <featmgr.h>

#include <sysutil.h>

#include <wlanerrorcodes.h>

//  CLASS HEADER

#include "wsfmodel.h"

//  INTERNAL INCLUDES

#include "wsfwlaninfoarray.h"

#include "wsfwlaniapwizard.h"

#include "wsfapplauncher.h"

#include "wsfmodelobserver.h"

#include "wsfstatechangeobserver.h"

#include "wsfscreensaverwatcher.h"

#include "wsflogger.h"

using namespace CMManager;

/**

* UID of helper application 

* used when model is instantiated in the active idle

*/

static const TUid KHelperApUid = { 0x10281CEB };

/**

* UID of Wlan Login application (hsbrowser)

* used when launching WLAN Login application

*/

static const TInt KBrowserUid = { 0x2000AFCC };

/**

* Estimated overhead for access point creation 

*/

const TInt KEstimatedOverhead = 8192;

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

// CWsfModel::NewL

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

//

EXPORT_C CWsfModel* CWsfModel::NewL( MWsfStateChangeObserver& aObserver,

                                     const TBool aScreenSaverAware )

    {

    CWsfModel* self = CWsfModel::NewLC( aObserver, aScreenSaverAware );

    CleanupStack::Pop( self );

    return self;

    }

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

// CWsfModel::NewLC

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

//

EXPORT_C CWsfModel* CWsfModel::NewLC( MWsfStateChangeObserver& aObserver,

                                      const TBool aScreenSaverAware )

    {

    CWsfModel* self = new( ELeave ) CWsfModel;

    CleanupStack::PushL( self );

    self->ConstructL( aObserver, aScreenSaverAware );

    return self;

    }

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

// CWsfModel::~CWsfModel

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

//

EXPORT_C CWsfModel::~CWsfModel()

    {

    iSession.CancelNotifyEvent();

    iSession.Close();

    delete iScreenSaverWatcher;

    delete iArray;   

    delete iObservedWlan;

    delete iBrowserLauncher;

    }

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

// CWsfModel::CWsfModel

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

//

CWsfModel::CWsfModel(): 

    iEikEnv( CEikonEnv::Static() ),

    iRefreshing( EFalse ),

    iIctEnded( EFalse ),

    iKeepConnection( EFalse ),

    iConnectOnly( EFalse )

    {

    }

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

// CWsfModel::ConstructL

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

//

void CWsfModel::ConstructL( MWsfStateChangeObserver& aObserver, 

                            const TBool aScreenSaverAware )

    {

    iArray = CWsfWlanInfoArray::NewL(); 

    iBrowserLauncher = CWsfAppLauncher::NewL();

    User::LeaveIfError( iSession.Connect() ); 

    iSession.NotifyEventL( aObserver );

    if ( aScreenSaverAware )

        {

        iScreenSaverWatcher = CWsfScreenSaverWatcher::NewL( *this );

        }

    }

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

// CWsfModel::SetEngineObserver

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

//

EXPORT_C void CWsfModel::SetEngineObserver( MWsfModelObserver* aObserver )

    {

    iObserver = aObserver;

    }

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

// CWsfModel::GetWlanListL

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

//

EXPORT_C CWsfWlanInfoArray* CWsfModel::GetWlanListL()

    {

    LOG_ENTERFN( "CWsfModel::GetWlanListL" );

    iArray->Reset();

    iSession.UpdateWlanListL( iArray );

    return iArray;

    }

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

// CWsfModel::SetActiveViewL

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

//

EXPORT_C void CWsfModel::SetActiveViewL( TInt aViewId )

    {

    TUid id;

    id.iUid = aViewId;

    iActiveView = id;

    }

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

// CWsfModel::ActiveViewL

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

//

EXPORT_C TUid CWsfModel::ActiveViewL()

    {

    return iActiveView;

    }

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

// CWsfModel::SetObservedWlanL

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

//

EXPORT_C void CWsfModel::SetObservedWlanL( const TDesC8& aSsid )

    {

    HBufC8* ssid = aSsid.AllocL();

    delete iObservedWlan;

    iObservedWlan = ssid;

    }

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

// CWsfModel::ObservedWlan

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

//

EXPORT_C const TDesC8& CWsfModel::ObservedWlan()

    {

    return *iObservedWlan;

    }

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

// CWsfModel::ConnectL

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

//

EXPORT_C int CWsfModel::ConnectL( TUint32 aIapId )

    {

    LOG_ENTERFN( "CWsfModel::ConnectL" );

    if ( iObserver )

        {

        iObserver->ConnectingL( aIapId );

        }

    TInt err = iSession.ConnectWlanBearerL( aIapId, EIapPersistent );

    if ( err == KErrNone )

        {

        iConnectedIapId = aIapId;

        }

    else

        {

        if ( iObserver )

            {

            iObserver->BrowserLaunchFailed( err );            

            }

        }

    if ( iObserver )

        {

        iObserver->ConnectingFinishedL( err );

        }

    TBool timerStarted( EFalse );

    timerStarted = iSession.ControlDisconnectTimerL( 

                                         EAdcStartTimer | EAdcTimerReset );

    if ( !timerStarted )

        {

        LOG_WRITE( "auto-disconnect timer couldn't be started!" );

        }

    iRefreshing = iSession.RequestScanL();   

    return err;

    }

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

// CWsfModel::ConnectWithoutConnWaiterL

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

//

EXPORT_C int CWsfModel::ConnectWithoutConnWaiterL( TUint32 aIapId, 

                                                   TBool aTestedAccessPoint )

    {

    LOG_ENTERFN( "CWsfModel::ConnectWithoutConnWaiterL" );

    if ( iObserver )

        {

        iObserver->ConnectingL( aIapId );

        }

    if ( aTestedAccessPoint )

        {

        return iSession.ConnectWlanBearerWithoutConnWaiterL( aIapId, 

                                                       EIapPersistent );

        }

    else

        {

        return iSession.ConnectWlanBearerWithoutConnWaiterL( aIapId, 

                                                       EIapExpireOnDisconnect );

        }

    }

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

// CWsfModel::FinalizeConnectL

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

//

EXPORT_C void CWsfModel::FinalizeConnectL()

    {

    LOG_ENTERFN( "CWsfModel::FinalizeConnectL" );

    TBool timerStarted( EFalse );

    timerStarted = iSession.ControlDisconnectTimerL( 

                                              EAdcStartTimer | EAdcTimerReset );

    if ( !timerStarted )

        {

        LOG_WRITE( "auto-disconnect timer couldn't be started!" );

        }

    }

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

// CWsfModel::DisconnectL

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

//

EXPORT_C void CWsfModel::DisconnectL()

    {

    LOG_ENTERFN( "CWsfModel::DisconnectL" );

    iSession.DisconnectWlanBearerL();

    iConnectedIapId = 0;

    iConnectedNetId = 0;

    iConnectOnly = EFalse;

    iRefreshing = iSession.RequestScanL();    

    }

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

// CWsfModel::Refreshing

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

//

EXPORT_C TBool CWsfModel::Refreshing()

    {

    return iRefreshing;

    }

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

// CWsfModel::SetRefreshState

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

//

EXPORT_C void CWsfModel::SetRefreshState( TBool aRefreshing )

    {

    iRefreshing = aRefreshing;

    }

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

// CWsfModel::EnableScanL

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

//

EXPORT_C TBool CWsfModel::EnableScanL()

    {

    LOG_ENTERFN( "CWsfModel::EnableScanL" );

    TBool enableScan( iSession.EnableScanL() );

    if ( iScreenSaverWatcher )

        {

        iScreenSaverWatcher->Cancel();

        iScreenSaverWatcher->StartStatusScanning();

        }

    return enableScan;

    }

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

// CWsfModel::DisableScanL

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

//

EXPORT_C TBool CWsfModel::DisableScanL()

    {

    LOG_ENTERFN( "CWsfModel::DisableScanL" );

    TBool disableScan( iSession.DisableScanL() );   

    if ( iScreenSaverWatcher )

        {

        iScreenSaverWatcher->Cancel();

        }

    return disableScan; 

    }

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

// CWsfModel::IsScanEnabledL

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

//

EXPORT_C TBool CWsfModel::IsScanEnabledL()

    {

    return iSession.IsScanEnabledL(); 

    }

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

// CWsfModel::LaunchBrowserL

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

//

EXPORT_C void CWsfModel::LaunchBrowserL( TUint32 aIapId )

    {

    LOG_ENTERFN( "CWsfModel::LaunchBrowserL" );

    if ( !iBrowserLauncher->Launching() ||

         iBrowserLauncher->BrowserIap() != aIapId ) 

        {

        LOG_WRITE( "launching browser..." );

        iConnectedIapId = aIapId;        

        iSession.MonitorAccessPointL( aIapId );

        iSession.ControlDisconnectTimerL( EAdcStopTimer );

        iBrowserLauncher->LaunchBrowserL( *this, aIapId );

        }

    else if ( iBrowserLauncher->BrowserIap() == aIapId ) 

        {

        LOG_WRITE( "bringing browser to foreground..." );

        ContinueBrowsingL();

        }

    }

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

// CWsfModel::CleanUpCancelledLaunchL

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

//

EXPORT_C void CWsfModel::CleanUpCancelledLaunchL()

    {

    LOG_ENTERFN( "CWsfModel::CleanUpCancelledLaunchL" );

    iSession.SetIapPersistenceL( EIapForcedExpiry );

    }

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

// CWsfModel::ContinueBrowsingL

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

//

EXPORT_C void CWsfModel::ContinueBrowsingL()

    {

    LOG_ENTERFN( "CWsfModel::ContinueBrowsingL(void)" );

    iBrowserLauncher->ContinueBrowsingL();

    }

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

// CWsfModel::ContinueBrowsingL

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

//

EXPORT_C void CWsfModel::ContinueBrowsingL( TUint32 aIapId )

    {

    LOG_ENTERFN( "CWsfModel::ContinueBrowsingL(TUint32)" );

    iBrowserLauncher->ContinueBrowsingL( *this, aIapId );

    }    

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

// CWsfModel::ConnectivityObserver

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

//

void CWsfModel::ConnectivityObserver( TIctsTestResult aResult, 

                                      const TDesC& aString )

    {

    LOG_ENTERFN( "CWsfModel::ConnectivityObserver" );

    LOG_WRITEF( "ICTS result: %d", aResult );

    TBool makePersistent( EFalse );

    // check the result

    switch ( aResult )

        {

        case EConnectionOk:

            {

            // test succeeded

            TRAP_IGNORE( MoveToInternetSnapL( iConnectedIapId ) );

            makePersistent = ETrue;

            LOG_WRITE( "ICT: EConnectionOk" );

            break;            

            }

        case EConnectionNotOk:

            {

            // test was run but it failed

            LOG_WRITE( "ICT: EConnectionNotOk" );

            break;

            }

        case EHttpAuthenticationNeeded:

            {

            // test was run but HTTP authentication is required

            LOG_WRITE( "ICT: EHttpAuthenticationNeeded" );

            if ( iConnectOnly )

                {

                // Connect selected. WLAN Login needed.

                TRAP_IGNORE( LaunchWlanLoginL(aString) );

                }    

            break;

            }    

        case ETimeout:

            {

            LOG_WRITE( "ICT: ETimeout" );

            break;

            }

        default:

            {

            _LIT( KIctPanic, "ICT result" );

            User::Panic( KIctPanic, aResult );

            }

        }

    if ( makePersistent )

        {

        TWsfIapPersistence pt = ( iConnectedIapId )? 

                                     EIapPersistent: 

                                     EIapExpireOnShutdown;

        TRAPD( err, MakeIctIapPersistentL( pt ) );

        if ( err )

            {

            LOG_WRITEF( "MakeIctIapPersistentL leaved with error = %d", err );

            }

        }

    if ( iKeepConnection )

        {

        // trigger the auto-disconnect timer as well

        TBool timerStarted( EFalse );

        TRAP_IGNORE( timerStarted = iSession.ControlDisconnectTimerL( 

                                          EAdcStartTimer | EAdcTimerReset ) );

        if ( !timerStarted )

            {

            LOG_WRITE( "auto-disconnect timer couldn't be started!" );

            }

        }

    LOG_WRITE( "before AsyncStop" );

    // finally stop blocking the caller

    iIctEnded = ETrue; 

    if ( iIctWait.IsStarted() )

        {

        LOG_WRITE( "ICT: AsyncStop" );

        iIctWait.AsyncStop();

        } 

    }

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

// CWsfModel::LaunchWlanLoginL()