/*

* Copyright (c) 2008-2009 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: Handles selecting Iap for connection

*

*/

#include "mpmiapselection.h"

#include "mpmlogger.h"

#include "mpmserversession.h"

#include "mpmcommsdataccess.h"

#include "mpmconnmonevents.h"

#include "mpmconfirmdlgstarting.h"

#include "extendedconnpref.h"

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

// CMPMIapSelection::CMPMIapSelection

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

//

CMPMIapSelection::CMPMIapSelection( CMPMCommsDatAccess*  aCommsDatAccess,

                                    CMPMServerSession*   aSession,

                                    CConnectionUiUtilities* aConnUiUtils )

    : iChooseIapState( ENoConnection ),

      iCommsDatAccess( aCommsDatAccess ),

      iConnUiUtils( aConnUiUtils ),

      iStoredIapInfo(),

      iSession( aSession ),

      iConfirmDlgStarting( NULL ),

      iNextBestExists( EFalse ),

      iUserSelectionIapId( 0 ),

      iUserSelectionSnapId( 0 ),

      iImplicitState( EImplicitStart ),

      iIsRoaming( EFalse ),

      iNewWlansAllowed ( EFalse )

    {

    }

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

// CMPMIapSelection::ConstructL

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

//

void CMPMIapSelection::ConstructL()

    {

    }

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

// CMPMIapSelection::NewL

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

//

CMPMIapSelection* CMPMIapSelection::NewL( CMPMCommsDatAccess*  aCommsDatAccess,

                                          CMPMServerSession*   aSession,

                                          CConnectionUiUtilities* aConnUiUtils )

    {

    CMPMIapSelection* self = new ( ELeave ) CMPMIapSelection( aCommsDatAccess,

                                                              aSession,

                                                              aConnUiUtils );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CMPMIapSelection::~CMPMIapSelection

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

//

CMPMIapSelection::~CMPMIapSelection()

    {

    // stop confirm dialog in case one exists

    //

    StopDisplayingStartingDlg();

    delete iConfirmDlgStarting;

    }

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

// CMPMIapSelection::ChooseIapL

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

//

void CMPMIapSelection::ChooseIapL( const TMpmConnPref& aChooseIapPref )

    {

#ifdef _DEBUG

    // Dump CommsDat IAPs to log in order to support testing

    // 

    iCommsDatAccess->DumpIAPsL();

    TRAPD( err, iCommsDatAccess->DumpSnapsL() );

    if ( err != KErrNone )

        {

        MPMLOGSTRING2(

            "CMPMIapSelection::ChooseIapL: DumpSnapsL fail %d",

            err )

        }

#endif // _DEBUG

    iChooseIapPref = aChooseIapPref;

    // Always use stored connection info.

    // If stored information doesn't exist, a normal sequence is used.

    TUint32 snap( 0 );

    TUint32 iap ( 0 );

    snap = iSession->MyServer().GetBMSnap( iSession->ConnectionId() );

    iap = iSession->MyServer().GetBMIap( iSession->ConnectionId() );

    if ( snap )

        {

        MPMLOGSTRING2( "CMPMIapSelection::ChooseIapL: Set snap %i to preferences",

            snap )

        iChooseIapPref.SetSnapId( snap );

        iChooseIapPref.SetIapId( 0 );

        if ( iChooseIapPref.ConnType() == TMpmConnPref::EConnTypeImplicit )

            {

            // No Connection selection dialog on reselection.

            iChooseIapPref.SetConnType( TMpmConnPref::EConnTypeExplicit );

            }

        }

    else if ( iap ) 

        {      

        MPMLOGSTRING2( "CMPMIapSelection::ChooseIapL: Set iap %i to preferences",

                iap )

        iChooseIapPref.SetIapId( iap );

        iChooseIapPref.SetSnapId( 0 );

        if ( iChooseIapPref.ConnType() == TMpmConnPref::EConnTypeImplicit )

            {

            // No Connection selection dialog on reselection.

            iChooseIapPref.SetConnType( TMpmConnPref::EConnTypeExplicit );

            }

        }

    MPMLOGSTRING3( "CMPMIapSelection::ChooseIapL: IapID: %i SnapId: %i",

            iChooseIapPref.IapId(), iChooseIapPref.SnapId() )

    // Update WLAN only information and whether new WLAN network usage is allowed.

    TBool wlanOnly = iSession->IsWlanOnlyL( iNewWlansAllowed );

    // Check if direct IAP connection is tried to make

    if ( iChooseIapPref.IapId() != 0 )

        { 

        TMPMBearerType bearerType = iSession->MyServer().CommsDatAccess()->GetBearerTypeL( iChooseIapPref.IapId() );

        MPMLOGSTRING2( "CMPMIapSelection::ChooseIapL: bearerType: %i", bearerType )

        // Complete selection with error code if wlan only was set and cellular IAP other 

        // than MMS IAP was tried to access

        // Note that CurrentCellularDataUsage()tells if internal cellular connections are 

        // temporarily disabled because dial-up connection is prioritized over internal connections.

        // 

        if ( ( wlanOnly || CurrentCellularDataUsage() == ECmCellularDataUsageDisabled ) && 

             ( bearerType == EMPMBearerTypePacketData ) && 

             ( iSession->IsMMSIap( iChooseIapPref.IapId() ) == EFalse ) ) 

            {            

            ChooseIapComplete( KErrPermissionDenied, NULL );

            return;

            }

        }

    if  ( iChooseIapPref.ConnSelectionDialog() )

        {

        // Complete selection with error code if wlan only was set and bearer set as cellular 

        if ( wlanOnly && 

             iChooseIapPref.BearerSet() == TExtendedConnPref::EExtendedConnBearerCellular ) 

            {            

            ChooseIapComplete( KErrPermissionDenied, NULL );

            return;

            }

        }

    MPMLOGSTRING2( "CMPMIapSelection::ChooseIapL:\

 connection type %d", iChooseIapPref.ConnType() )

    if ( iChooseIapPref.ConnType() == TMpmConnPref::EConnTypeDefault )

        {

        // Default connection is requested.

        MPMLOGSTRING( "CMPMIapSelection::ChooseIapL:\

            Default Connection" )

        if ( iSession->UseUserConnPref() )

            {

            // User connection active -> use it

            // Add info into the BM connections

            iSession->MyServer().AppendBMConnection(iSession->ConnectionId(),

                iSession->MyServer().UserConnPref()->SnapId(),

                iSession->MyServer().UserConnPref()->IapId(), 

                EStarting,

				*iSession );

            ChooseIapComplete( KErrNone, iSession->MyServer().UserConnPref());

            return;

            }

        // Read the default connection values

        TCmDefConnType type( TCmDefConnType( 0 ) );

        TUint32 id( 0 );

        iCommsDatAccess->GetDefaultConnectionL( type, id );

        MPMLOGSTRING3( "CMPMIapSelection::ChooseIapL:\

            default connection type %d id %d", type, id )

        // set the received snap id and open the connection

        iChooseIapPref.SetSnapId( id );

        ExplicitConnectionL();

        }

    else if ( iChooseIapPref.ConnType() == TMpmConnPref::EConnTypeExplicit )

        {

        // Client has defined SNAP or IAP connection to be used.

        // If usage of given IAP is mandated, do not allow user connection.

        if ( !iChooseIapPref.MandateIap() )

            {

            TBool useUCPref = iSession->UseUserConnPref();

            // Check that user connection is active, it is not in internet snap 

            // and destination id is something else than zero.

            // OR

            // User connection is active and iap id is non-zero.

            if ( ( useUCPref &&

                   !iSession->MyServer().UserConnectionInInternet() &&

                   iChooseIapPref.SnapId() ) ||

                 ( useUCPref && iChooseIapPref.IapId() ) )

                 {

                 // Add info into the BM connections

                 iSession->MyServer().AppendBMConnection(

                     iSession->ConnectionId(),

                     iSession->MyServer().UserConnPref()->SnapId(),

                     iSession->MyServer().UserConnPref()->IapId(), 

                     EStarting,

                     *iSession );

                 ChooseIapComplete( KErrNone, iSession->MyServer().UserConnPref() );

                 return;                

                 }

            }

        ExplicitConnectionL();

        }

    else

        {

        // Used connection will be asked from the user.

        ASSERT( iChooseIapPref.ConnType() == TMpmConnPref::EConnTypeImplicit );

        if ( iSession->UseUserConnPref() )

            {

            // Do not prompt the user in this case.

            // Add info into the BM connections

            iSession->MyServer().AppendBMConnection(

                iSession->ConnectionId(),

                iSession->MyServer().UserConnPref()->SnapId(),

                iSession->MyServer().UserConnPref()->IapId(), 

                EStarting,

				*iSession );

            ChooseIapComplete( KErrNone, iSession->MyServer().UserConnPref() );

            return;

            }

        ImplicitConnectionL();

        }

    }

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

// CMPMIapSelection::ExplicitConnectionL

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

//

void CMPMIapSelection::ExplicitConnectionL()

    {

    TBool   iapTypeLanOrWlan = EFalse;

    TUint32 validateIapId    = iChooseIapPref.IapId();

    MPMLOGSTRING2(

        "CMPMIapSelection::ExplicitConnectionL - Connection Id = 0x%x",

        iSession->ConnectionId() )

    TUint32 snap( 0 );

    if ( validateIapId == 0 )

        {

        if ( iChooseIapPref.SnapId() )

            {

            snap = iChooseIapPref.SnapId();

            }

        else

            {

            // Neither defined -> attempt to use 

            // already stored connection info

            snap = iSession->MyServer().GetBMSnap( iSession->ConnectionId() );

            iChooseIapPref.SetSnapId( snap );

            if( !snap )

                {

                // If snap not defined, this must be iap connection

                //

                validateIapId = iSession->MyServer().GetBMIap( iSession->ConnectionId() );

                iChooseIapPref.SetIapId( validateIapId );

                }

            }

        }

    // IAP Id explicitly defined

    // 

    if ( validateIapId )

        {

        MPMLOGSTRING2(

            "CMPMIapSelection::ExplicitConnectionL - IAP Id = %i", 

            validateIapId )

        TUint32 retNetId = 0;

        iCommsDatAccess->ValidateIapL( iSession->ConnectionId(), 

                                       validateIapId, 

                                       retNetId, 

                                       iapTypeLanOrWlan,

                                       *iSession );

        // Set validated IAP Id and returned Access Network Id

        // in connection preferences

        //

        iChooseIapPref.SetIapId( validateIapId );

        iChooseIapPref.SetNetId( retNetId );

        if ( !iapTypeLanOrWlan &&                  

             iSession->MyServer().RoamingWatcher()->RoamingStatus() == EMPMRoamingStatusUnknown )

            {

            ChooseIapComplete( KErrGprsOfflineMode, &iChooseIapPref );

            }

        else

            {

            TWlanIapType wlanType = iCommsDatAccess->CheckWlanL( validateIapId );

            if( wlanType != ENotWlanIap )

                {

                // Add info into the BM connections

                iSession->MyServer().AppendBMConnection( iSession->ConnectionId(), 

                                    iChooseIapPref.SnapId(),

                                    validateIapId,

                                    EStarting,

                                    *iSession );

                ChooseIapComplete( KErrNone, &iChooseIapPref );

                return;                

                }

            // Check whether confirmation from user is needed for allowing cellular usage.

            // When application is starting an IAP confirmation is asked only when roaming.

            // This is skipped for VPN (= virtual) IAPs

            if ( iSession->IsConfirmFirstL( validateIapId ) &&

                 !( iSession->MyServer().CommsDatAccess()->IsVirtualIapL( validateIapId ) ))

                {

                // Check that queries aren't disabled and

                // enough time has elapsed from the last query cancelled by the user.

                if ( !( iChooseIapPref.NoteBehaviour()

                        & TExtendedConnPref::ENoteBehaviourConnDisableQueries ) &&

                     !iSession->MyServer().IsConnPermQueryTimerOn() )

                    {

                    TConnectionId connId = iSession->ConnectionId();

                    // Set confirmation type based on roaming status

                    CMPMConfirmDlg::TDialogType type = 

                            CMPMConfirmDlg::EConfirmDlgHomeNetwork;

                    if ( iSession->MyServer().RoamingWatcher()->RoamingStatus()

                            == EMPMInternationalRoaming ) {

                        type = CMPMConfirmDlg::EConfirmDlgVisitorNetwork;

                    }

                    iConfirmDlgStarting = CMPMConfirmDlgStarting::NewL( 

                        *this, 

                        connId,

                        snap, 

                        validateIapId, 

                        type,

                        iChooseIapPref,

                        iSession->MyServer(),

                        *iSession,

                        EExplicitConnection );

                    return;    

                    }

                else

                    {

                    // Queries disabled, connection must fail

                    ChooseIapComplete( KErrPermissionDenied, &iChooseIapPref );

                    return;

                    }

                }

            // Add info into the BM connections

            //

            iSession->MyServer().AppendBMConnection( iSession->ConnectionId(), 

                                                     snap, 

                                                     validateIapId, 

                                                     EStarting,

                                                     *iSession );

            ChooseIapComplete( KErrNone, &iChooseIapPref );

            }

        }

    // Snap Id explicitly defined

    // 

    else

        {

        MPMLOGSTRING2(

            "CMPMIapSelection::ExplicitConnectionL - SNAP = %i", snap )

        // If the SNAP contains WLAN IAP, 

        // scan wlan networks

        //

        RArray<TUint> iapPath;

        CleanupClosePushL( iapPath ); 

        //Check if WLAN bearerset is in use

        if ( ( iChooseIapPref.BearerSet() & TExtendedConnPref::EExtendedConnBearerWLAN ) ||

             ( iChooseIapPref.BearerSet() == TExtendedConnPref::EExtendedConnBearerUnknown ) )

            {

            if( iCommsDatAccess->SnapContainsWlanL( snap, iapPath, KMPMNrWlansOne ) )

                {

                // Scan wlan networks. After that execution continues 

                // in CompleteExplicitSnapConnectionL()

                //

                iChooseIapState = EExplicitConnection; 

                iSession->MyServer().Events()->ScanWLANNetworksL( iSession,

                        iSession->ConnectionId(),

                        EWlanScanCallbackChooseIap );

                }

            else

                {

                CompleteExplicitSnapConnectionL();

                }

            }

        else

            {

            CompleteExplicitSnapConnectionL();

            }

        CleanupStack::PopAndDestroy( &iapPath );

        }        

    }

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

// CMPMIapSelection::CompleteExplicitSnapConnectionL

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

//

void CMPMIapSelection::CompleteExplicitSnapConnectionL()

    {

    MPMLOGSTRING( "CMPMIapSelection::CompleteExplicitSnapConnectionL" )

    // Store Snap id

    // 

    TUint32 snap = iChooseIapPref.SnapId();

    RAvailableIAPList availableIAPList;

    CleanupClosePushL( availableIAPList );

    iSession->AvailableUnblacklistedIapsL( availableIAPList, iSession->ConnectionId() );

    TBool   iapTypeLanOrWlan = EFalse;

    TConnectionId connId = iSession->ConnectionId();

    ChooseBestIAPL( iChooseIapPref, availableIAPList, iNextBestExists );

    TUint32 validateIapId = iChooseIapPref.IapId();

    // Check if any suitable IAP's were found, if not then complete selection with error code

    if ( validateIapId == 0 )

        {

        if ( !( iChooseIapPref.NoteBehaviour() & TExtendedConnPref::ENoteBehaviourConnDisableQueries ) &&

                ( iChooseIapPref.ConnType() == TMpmConnPref::EConnTypeDefault ||

                ( iChooseIapPref.ConnType() == TMpmConnPref::EConnTypeExplicit &&

                  iCommsDatAccess->IsInternetSnapL( 0, snap ) ) ) )

            {

            ImplicitConnectionL();

            }

        else

            {

            ChooseIapComplete( KErrNotFound, NULL );

            }

        CleanupStack::PopAndDestroy( &availableIAPList );

        return;

        }

    TUint32 retNetId( 0 );

    iCommsDatAccess->ValidateIapL( connId, 

            validateIapId, 

            retNetId, 

            iapTypeLanOrWlan,

            *iSession );

    // Set validated IAP Id and returned Access Network Id

    // in connection preferences

    //

    iChooseIapPref.SetIapId( validateIapId );

    iChooseIapPref.SetNetId( retNetId );

    if ( !CheckGprsServicesAllowedL( iapTypeLanOrWlan ) )

        {

        ChooseIapComplete( KErrGprsServicesNotAllowed, NULL );

        }

    else if ( !iapTypeLanOrWlan &&                 

               iSession->MyServer().RoamingWatcher()->RoamingStatus() == EMPMRoamingStatusUnknown )

        {

        // In case offline mode is enabled, only LAN or WLAN is allowed.

        // If some other bearer has been requested, then error code 

        // KErrGprsOfflineMode should be returned instead of KErrNone.

        // 

        ChooseIapComplete( KErrGprsOfflineMode, &iChooseIapPref );

        }

    else

        {

        // Check whether confirmation from user is needed for allowing cellular usage

		// This is skipped for VPN (= virtual) IAPs

        if ( ( iSession->IsConfirmFirstL( validateIapId ) ) && 

             ( iSession->MyServer().CommsDatAccess()->CheckWlanL( validateIapId ) == ENotWlanIap ) &&

             !( iSession->MyServer().CommsDatAccess()->IsVirtualIapL( validateIapId ) ) )

            {

            // Check that queries aren't disabled and