/*

* 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 "mpmdialog.h"

#include "mpmserversession.h"

#include "mpmcommsdataccess.h"

#include "mpmconnmonevents.h"

#include "mpmconfirmdlgstarting.h"

#include "mpmdefaultconnection.h"

#include "mpmwlanquerydialog.h"

#include "extendedconnpref.h"

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

// CMPMIapSelection::CMPMIapSelection

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

//

CMPMIapSelection::CMPMIapSelection( CMPMCommsDatAccess*  aCommsDatAccess,

                                    CMPMServerSession*   aSession )

    : iChooseIapState( ENoConnection ),

      iCommsDatAccess( aCommsDatAccess ),

      iStoredIapInfo(),

      iSession( aSession ),

      iConfirmDlgStarting( NULL ),

      iDialog( NULL ),

      iWlanDialog( NULL ),

      iNextBestExists( EFalse ),

      iUserSelectionIapId( 0 ),

      iUserSelectionSnapId( 0 ),

      iImplicitState( EImplicitStart ),

      iOfflineNoteResponse( EOfflineResponseUndefined ),

      iIsRoaming( EFalse ),

      iNewWlansAllowed ( EFalse )

    {

    }

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

// CMPMIapSelection::ConstructL

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

//

void CMPMIapSelection::ConstructL()

    {

    }

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

// CMPMIapSelection::NewL

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

//

CMPMIapSelection* CMPMIapSelection::NewL( CMPMCommsDatAccess*  aCommsDatAccess,

                                          CMPMServerSession*   aSession )

    {

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

                                                              aSession );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CMPMIapSelection::~CMPMIapSelection

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

//

CMPMIapSelection::~CMPMIapSelection()

    {

    // stop confirm dialog in case one exists

    //

    StopDisplayingStartingDlg();

    // Cancel WLAN availability check in case it is active

    //

    if ( iSession )

        {

    	  iSession->MyServer().Events()->CancelCheckWlanWlanAvailability( this );	

        }	

    delete iConfirmDlgStarting;

    delete iDialog;

    delete iWlanDialog;

    }

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

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

    if ( iSession->IsWlanOnlyL( iNewWlansAllowed ) )

        {

        if ( iChooseIapPref.BearerSet() ==

             TExtendedConnPref::EExtendedConnBearerUnknown )

            {

            // Force bearerset to WLAN if received bearerset was empty

            iChooseIapPref.SetBearerSet(

                TExtendedConnPref::EExtendedConnBearerWLAN );

            }

        else if ( iChooseIapPref.BearerSet() &

                  TExtendedConnPref::EExtendedConnBearerWLAN )

            {

            // Force bearerset to WLAN only in case where wlan was included

            // in the received bearerset.

            iChooseIapPref.SetBearerSet(

                TExtendedConnPref::EExtendedConnBearerWLAN );          

            }

        else

            {

            // If wlan was not included in received bearerset,

            // complete selection with error code

            ChooseIapComplete( KErrPermissionDenied,

                               iSession->MyServer().UserConnPref() );

            return; 

            }

        }

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

        }

    else if ( iap ) 

        {      

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

                iap )

        iChooseIapPref.SetIapId( iap );

        iChooseIapPref.SetSnapId( 0 );

        }

    MPMLOGSTRING2( "CMPMIapSelection::ChooseIapL: IapID: %i",

            iChooseIapPref.IapId() )

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

        if ( ( iChooseIapPref.BearerSet() ==

               TExtendedConnPref::EExtendedConnBearerWLAN ) && 

                ( bearerType == EMPMBearerTypePacketData ) && 

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

            {

            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;

            }

        TCmDefConnType type( TCmDefConnType( 0 ) );

        TUint32 id( 0 );

        iSession->MyServer().DefaultConnection()->GetDefaultConnectionL( type, id );

        MPMLOGSTRING3( "CMPMIapSelection::ChooseIapL:\

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

        if( type == ECmDefConnConnectionMethod )

            {

            iChooseIapPref.SetIapId( id );

            iChooseIapPref.SetSnapId( 0 );

            ExplicitConnectionL();

            }

        else if( type == ECmDefConnDestination )

            { 

            iChooseIapPref.SetSnapId( id );

            ExplicitConnectionL();

            }

        else

            {

            if( iCommsDatAccess->IsSnapEmptyL( id ) )

                {

                // start implicit connection

                ImplicitConnectionL();

                return;

                }

            iChooseIapPref.SetSnapId( id );

            // start connection as if explicitly defined 

            // by application

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

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

        // 

        if ( !iapTypeLanOrWlan && iSession->IsPhoneOfflineL() )

            {

            ChooseIapComplete( KErrGprsOfflineMode, &iChooseIapPref );

            }

        else

            {

            TWlanIapType wlanType = iCommsDatAccess->CheckWlanL( validateIapId );

            if( wlanType != ENotWlanIap )

                {

                iChooseIapState = EExplicitConnection;

                iWlanDialog = CMPMWlanQueryDialog::NewL( *this, validateIapId );

                iWlanDialog->StartWlanQueryL();

                return;                

                }

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

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

            if ( iSession->IsConfirmFirstL( validateIapId ) )

                {

                // Check whether queries are disabled

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

                    {

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

                        {

                        // Check if cellular data usage query has already been presented to the user in this country

                       if ( iSession->MyServer().RoamingWatcher()->AskCellularDataUsageAbroad() == true )

                            {

                            TConnectionId connId = iSession->ConnectionId();

                            // International roaming

                            iConfirmDlgStarting = CMPMConfirmDlgStarting::NewL( 

                                                  *this, 

                                                  connId,

                                                  snap, 

                                                  validateIapId, 

                                                  CMPMConfirmDlg::EConfirmDlgVisitorNetwork,

                                                  iChooseIapPref,

                                                  iSession->MyServer(),

                                                  *iSession,

                                                  EExplicitConnection );

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

            {

                {

                // User allows only WLAN connections, check WLAN availability.

                // A note will be shown if no WLANs are available.

                //

                iSession->MyServer().Events()->CheckWlanAvailabilityL( this );

                }

            else 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::UpdateConnectionDialog

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

//

void CMPMIapSelection::UpdateConnectionDialogL()

    {

    if( iDialog )

        {

        MPMLOGSTRING( "CMPMIapSelection::UpdateConnectionDialogL data will be updated" )

        iDialog->PublishSortSnapInfoL();

        }

    }

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

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

        {

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