/*

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

        }

    iRefreshing = iSession.RequestScanL();   

    return err;

    }

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

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

//

    {

    if ( iObserver )

        {

        iObserver->ConnectingL( aIapId );

        }

    }

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

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

//

    {

        {

        }

    }

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

// CWsfModel::DisconnectL

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

//

EXPORT_C void CWsfModel::DisconnectL()

    {

    LOG_ENTERFN( "CWsfModel::DisconnectL" );

    iSession.DisconnectWlanBearerL();

    iConnectedIapId = 0;

    iConnectedNetId = 0;

    iConnectOnly = EFalse;

    }

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

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

        iBrowserLauncher->LaunchBrowserL( *this, aIapId );

        }

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

        {

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

        ContinueBrowsingL();

        }

    }

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

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

            }

        }

    LOG_WRITE( "before AsyncStop" );

    // finally stop blocking the caller