/*

* 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 CWsfIct

*

*/

//  EXTERNAL INCLUDES

#include <apgcli.h>

#include <apgtask.h>

#include <ictsclientinterface.h>

#include <cmmanagerext.h>

#include <cmdestinationext.h>

#include <cmpluginwlandef.h>

//  CLASS HEADER

#include "wsfict.h"

#include "wsflogger.h"

//  INTERNAL INCLUDES

using namespace CMManager;

/**

* UID of Wlan Login application (hsbrowser)

* used when launching WLAN Login application

*/

static const TInt KBrowserUid = { 0x2000AFCC };

/**

* Length of a needed separators

* used when launching WLAN Login application

*/

const TInt KSeparatorsLength = 4;

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

// CWsfIct::NewL

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

//

EXPORT_C CWsfIct* CWsfIct::NewL()

    {

    CWsfIct* self = CWsfIct::NewLC();

    CleanupStack::Pop( self );

    return self;

    }

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

// CWsfIct::NewLC

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

//

EXPORT_C CWsfIct* CWsfIct::NewLC()

    {

    CWsfIct* self = new( ELeave ) CWsfIct;

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CWsfIct::~CWsfIct

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

//

EXPORT_C CWsfIct::~CWsfIct()

    {

    LOG_ENTERFN( "CWsfIct::~CWsfIct" );

    if ( iIct )

        {

        LOG_WRITE( "ict cancel" );

        TRAP_IGNORE( iIct->CancelStartL() );

        delete iIct;

        iIct = NULL;

        }

    }

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

// CWsfIct::CWsfIct

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

//

CWsfIct::CWsfIct(): iConnectOnly( EFalse )

    {

    }

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

// CWsfIct::ConstructL

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

//

void CWsfIct::ConstructL()

    {

    }

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

// CWsfIct::ConnectivityObserver

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

//

void CWsfIct::ConnectivityObserver( TIctsTestResult aResult, 

                                    const TDesC& aString )

    {

    LOG_ENTERFN( "CWsfIct::ConnectivityObserver" );

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

    // check the result

    switch ( aResult )

        {

        case EConnectionOk:

            {

            // test succeeded

            TRAP_IGNORE( MoveToInternetSnapL( iIapId ) );

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

            }

        }

    }

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

// CWsfIct::LaunchWlanLoginL()

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

//    

void CWsfIct::LaunchWlanLoginL( const TDesC& aString )

    {   

    LOG_ENTERFN( "CWsfIct::LaunchWlanLoginL" );

    // Count IAP Id length

    TInt iapIdLength ( 1 );

    TInt iapId = iIapId;

    while ( iapId >= 10 )

        {

        iapId = iapId/10;

        iapIdLength++;

        }

    // Count Network Id length

    TInt netIdLength ( 1 );

    TInt netId = iNetId;

    while ( netId >= 10 )

        {

        netId = netId/10;

        netIdLength++;

        }

    TInt length = aString.Length() + 

                  iapIdLength + 

                  netIdLength + 

                  KSeparatorsLength;

    HBufC* param = HBufC::NewLC( length );

    _LIT(tmpString, "%d, %d, %S");

    param->Des().Format( tmpString, 

                         iIapId, 

                         iNetId, 

                         &aString );

    TUid uid( TUid::Uid( KBrowserUid ) );

    TThreadId id;

    RApaLsSession appArcSession;

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

    CleanupClosePushL( appArcSession );

    TInt err = appArcSession.StartDocument( *param, TUid::Uid( KBrowserUid ), id );

    if ( err != KErrNone )

        {

        LOG_ENTERFN( "CWsfIct::LaunchWlanLoginL failed" );

        }

    CleanupStack::PopAndDestroy( &appArcSession );

    CleanupStack::PopAndDestroy( param );

    }

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

// CWsfIct::MoveToInternetSnapL

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

//

void CWsfIct::MoveToInternetSnapL( const TUint32 aIapId )

    {

	LOG_ENTERFN( "CWsfIct::MoveToInternetSnapL" );

    RCmManagerExt cmManager;

    cmManager.OpenL();

    CleanupClosePushL( cmManager );

    // Check that is IAP uncategorized

    RArray<TUint32> cmIds;

    CleanupClosePushL( cmIds );

    cmManager.ConnectionMethodL( cmIds, ETrue, ETrue, EFalse );

    TBool foundFromUncategorized = EFalse;

    for ( TInt k = 0; k < cmIds.Count(); k++ )

        {

        RCmConnectionMethodExt cm;

        TRAPD( error, cm = cmManager.ConnectionMethodL( cmIds[k] ) );

        if ( KErrNone == error )

            {

            CleanupClosePushL( cm );

            TUint iapId = cm.GetIntAttributeL( CMManager::ECmIapId );

            if ( iapId == aIapId )

                {

                LOG_WRITE( "IAP is uncategorized" );

                foundFromUncategorized = ETrue;

                }

            CleanupStack::PopAndDestroy( &cm );

            }

        }

    CleanupStack::PopAndDestroy( &cmIds );

    if ( !foundFromUncategorized )

        {

        LOG_WRITE( "Not moving IAP since it is in SNAP" );

        CleanupStack::PopAndDestroy( &cmManager );

        return;

        }

    // Read all destination(SNAP) settings into an array

    RArray<TUint32> destinations;

    CleanupClosePushL( destinations );

    cmManager.AllDestinationsL( destinations );

    RCmDestinationExt destination;

    // Loop through each destination

    for( TInt i = 0; i < destinations.Count(); i++ )

        {

        destination = cmManager.DestinationL( destinations[i] );

        CleanupClosePushL( destination ); 

        // Internet destination will always exist in the system.

        // Internet destination will have ESnapPurposeInternet 

        // set in its metadata.

        if ( destination.MetadataL( CMManager::ESnapMetadataPurpose ) == 

                                    CMManager::ESnapPurposeInternet )

            {

            RCmConnectionMethodExt iap = cmManager.ConnectionMethodL( aIapId );

            CleanupClosePushL( iap );     

            LOG_WRITE( "Move Iap to internet destination" );

            destination.AddConnectionMethodL( iap );

            destination.UpdateL();

            CleanupStack::PopAndDestroy( &iap ); 

            }

        CleanupStack::PopAndDestroy( &destination ); 

        }

    CleanupStack::PopAndDestroy( &destinations ); 

    CleanupStack::PopAndDestroy( &cmManager ); 

    }

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

// CWsfIct::TestConnectedAccessPointL

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

//

void CWsfIct::TestConnectedAccessPointL( TUint aIapId )

    {

    LOG_ENTERFN( "CWsfIct::TestConnectedAccessPointL" );

    if ( !aIapId || aIapId != iIapId )

        {

        // the wlaninfo must already contain a valid IAP id

        LOG_WRITE( "invalid IAP id" );

        return;

        }

    if ( iIct )

        {

        iIct->CancelStartL();

        delete iIct;

        iIct = NULL;

        }

    LOG_WRITE( "starting ICT test..." );

    iIct = CIctsClientInterface::NewL( iIapId, iNetId, *this );

    LOG_WRITE( "ICT created" );

    iIct->StartL();

    LOG_WRITE( "ICT: started" );

    }

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

// CWsfIct::InitializeIctL

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

//

void CWsfIct::InitializeIctL( TBool aTestAccessPoint,

                              TUint aIapId,

                              TBool aConnectOnly )

    {

    LOG_ENTERFN( "CWsfIct::InitializeIct" );

    LOG_WRITEF( "IAP id = %d aTestAccessPoint = %d aConnectOnly = %d", 

                aIapId, aTestAccessPoint, aConnectOnly );

    if ( !aIapId || !aTestAccessPoint )

        {

        // the wlaninfo must already contain a valid IAP id 

        // and check that IAP needs testing

        LOG_WRITE( "ICT not initialized" );

        iConnectOnly = EFalse;

        iIapId = 0;

        iNetId = 0;

        return;

        }

    // set variables

    iConnectOnly = aConnectOnly;

    iIapId = aIapId;

    if ( iIct )

        {

        iIct->CancelStartL();

        delete iIct;

        iIct = NULL;

        }

    // get network Id

    RCmManagerExt cmManager;

    cmManager.OpenL();

    CleanupClosePushL(cmManager);

    RCmConnectionMethodExt cm = cmManager.ConnectionMethodL(iIapId);

    CleanupClosePushL(cm);

    iNetId = cm.GetIntAttributeL(CMManager::ECmNetworkId);

    LOG_WRITEF( "Network Id=%d ", iNetId );

    CleanupStack::PopAndDestroy(&cm);

    CleanupStack::PopAndDestroy(&cmManager);

    }

// End of file