/*

* Copyright (c) 2002-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:  Connection manager for ROAP

*

*/

// INCLUDE FILES

#include <cmconnectionmethod.h>

#include <cmdestination.h>

#include <cmconnectionmethoddef.h>

#include <cmmanager.h>

#include <centralrepository.h>

#include <cdblen.h>

#include <es_enum.h>

#ifdef __SERIES60_NATIVE_BROWSER

#endif

#include "RoapConnection.h"

#include "RoapDef.h"

#include "RoapLog.h"

#ifndef __SERIES60_NATIVE_BROWSER

    const TUid KCRUidBrowser   = {0x10008D39};

    const TUint32 KBrowserDefaultAccessPoint =  0x0000000E;

    const TUint32 KBrowserAccessPointSelectionMode = 0x0000001E;

    const TUint32 KBrowserNGDefaultSnapId = 0x00000053;

#endif

// ================= LOCAL FUNCTIONS =========================================

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

// IapIdOfDefaultSnapL

// for trapping purposes only

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

//

LOCAL_C TUint32 IapIdOfDefaultSnapL(

    RCmManager& aCmManager,

    const TUint32 aDefaultSnap )

    {

    RCmDestination dest( aCmManager.DestinationL( aDefaultSnap ) );

    CleanupClosePushL( dest );

    TUint32 iapIdOfDest( 0 );

    if ( dest.ConnectionMethodCount() <= 0 )

        {

        User::Leave( KErrNotFound );

        }

    RCmConnectionMethod cMeth( dest.ConnectionMethodL( 0 ) );

    CleanupClosePushL( cMeth );

    iapIdOfDest = cMeth.GetIntAttributeL( CMManager::ECmIapId );

    CleanupStack::PopAndDestroy( &cMeth );

    CleanupStack::PopAndDestroy( &dest );

    return iapIdOfDest;

    }

// ================= MEMBER FUNCTIONS =======================

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

// Roap::CRoapConnection::NewL

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

//

Roap::CRoapConnection* Roap::CRoapConnection::NewL()

    {

    CRoapConnection* conn = new (ELeave) CRoapConnection();

    CleanupStack::PushL( conn );

    conn->ConstructL();

    CleanupStack::Pop( conn );

    return conn;

    }

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

// Roap::CRoapConnection::~CRoapConnection

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

//

Roap::CRoapConnection::~CRoapConnection()

    {

    Cancel();

    iConnection.Close();

    iSocketServ.Close();

    }

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

// Roap::CRoapConnection::ConnectL

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

//

void Roap::CRoapConnection::ConnectL

( TUint32 aIap, TRequestStatus* aStatus )

    {

    LOGLIT( "CRoapConnection::ConnectL" )

    const TInt KAlwaysAskSelectionMode( 1 );

    const TInt KDestinationSelectionMode( 2 );

    if ( iState == EInit )

        {

        // Not connected. Attach to existing connection, or create new one if

        // allowed.

        iStatus = KErrRoapGeneral;

        // Make this part atomic by pushing closes on the stack.

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

        CleanupClosePushL<RSocketServ>( iSocketServ );

        User::LeaveIfError( iConnection.Open( iSocketServ ) );

        CleanupClosePushL<RConnection>( iConnection );

        TConnectionInfoBuf connInfo;

        TInt ap = 0;

        TInt alwaysAsk = 0;

        TUint count;

        User::LeaveIfError( iConnection.EnumerateConnections( count ) );

        TUint i;

        if ( count )

            {

            // Select from existing connections. Try to make AP match.

            for ( i = count; i; i-- )

                {

                // Note: GetConnectionInfo expects 1-based index.

                User::LeaveIfError( iConnection.GetConnectionInfo( i, connInfo ) );

                if ( aIap == 0 || connInfo().iIapId == aIap )

                    {

                    // "Accept any" or AP match. Attach to this one.

                    break;

                    }

                }

            if ( !i )

                {

                // No AP match, select AP with largest index.

                User::LeaveIfError

                    ( iConnection.GetConnectionInfo( count, connInfo ) );

                }

            User::LeaveIfError

                ( iConnection.Attach( connInfo, RConnection::EAttachTypeNormal ) );

            iState = EConnected;

            iStatus = KErrNone;

            }

        else

            {

            // No existing connections, create new one.

#ifdef __WINS__

            // WINS connection creation does not work if preferences are given.

            // Defaults are to be used always.

            iConnection.Start( iStatus );

#else

            // Note: the TCommDbConnPref must NOT be stack variable.

            // It must persist until completion of RConnection::Start().

            iConnPref.SetDirection( ECommDbConnectionDirectionOutgoing );

            //iConnPref.SetDialogPreference( ECommDbDialogPrefWarn )

            iConnPref.SetBearerSet( ECommDbBearerCSD | ECommDbBearerWcdma );

            // New connection is always created with user-selected AP

            // so 0 is used instead of aIap.

            TInt defaultSnap( 0 );

            CRepository* repository( NULL );

            repository = CRepository::NewL( KCRUidBrowser );

            CleanupStack::PushL( repository );

            repository->Get( KBrowserDefaultAccessPoint, ap);

            repository->Get( KBrowserAccessPointSelectionMode, alwaysAsk );

            repository->Get( KBrowserNGDefaultSnapId, defaultSnap );

            CleanupStack::PopAndDestroy( repository );

            repository = NULL;

            TUint32 iapd32 = 0;

            TInt err = KErrNone;

            if ( ap <= KErrNotFound && defaultSnap <= KErrNotFound )

                {

                alwaysAsk = KAlwaysAskSelectionMode;

                }

            else

                {

                RCmManager cmManager;

                cmManager.OpenLC();

                if ( !alwaysAsk )

                    {

                    TRAP( err, iapd32 = cmManager.GetConnectionMethodInfoIntL(

                            ap, CMManager::ECmIapId ) );

                    }

                else if ( alwaysAsk == KDestinationSelectionMode )

                    {

                    TRAP( err, iapd32 = IapIdOfDefaultSnapL(

                            cmManager, defaultSnap ) );

                    }

                CleanupStack::PopAndDestroy( &cmManager );

                }

            if ( err || alwaysAsk == KAlwaysAskSelectionMode )

                {

                // Always ask

                LOGLIT( "SetDialogPreference( ECommDbDialogPrefPrompt )" )

                iConnPref.SetDialogPreference( ECommDbDialogPrefPrompt );

                iapd32 = 0;

                }

            else

                {

                // User defined

                LOGLIT( "SetDialogPreference( ECommDbDialogPrefDoNotPrompt )" )

                iConnPref.SetDialogPreference( ECommDbDialogPrefDoNotPrompt );

                }

            iConnPref.SetIapId( iapd32 );

            iConnection.Start( iConnPref, iStatus );

#endif

            iState = EConnecting;

            SetActive();    // The only path with a real async request.

            }

        CleanupStack::Pop( 2, &iSocketServ ); // closing iConn and iSockServ

        // End of atomic part.

        }

    else

        {

        // Not expecting this to be called in other states.

        }

    iParentStatus = aStatus;

    *iParentStatus = KRequestPending;

    if ( !IsActive() )

        {

        // Unless we have an outstanding connect request (iConn.Start),

        // we are done.

        User::RequestComplete( iParentStatus, iStatus.Int() );

        iParentStatus = NULL;

        }

    }

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

// Roap::CRoapConnection::Close

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

//

void Roap::CRoapConnection::Close()

    {

    LOGLIT( "CRoapConnection::Close" )

    Cancel();

    iConnection.Close();

    iSocketServ.Close();

    iState = EInit;

    }

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

// Roap::CRoapConnection::IsConnected

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

//

TBool Roap::CRoapConnection::IsConnected( TUint32& aIap )

    {

    LOGLIT( "CRoapConnection::IsConnected" )

    TBool connected( EFalse );

    if( iState == EConnected )

        {

        TBuf<KCommsDbSvrMaxColumnNameLength * 2 + 1> iapId;

        _LIT( KFormatIapId, "%S\\%S" );

        TPtrC iap( IAP );

        TPtrC id( COMMDB_ID );

        iapId.Format( KFormatIapId, &iap, &id );

        TInt err = iConnection.GetIntSetting( iapId, aIap );

        connected = err ? EFalse : ETrue;

        }

    return connected;

    }

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

// Roap::CRoapConnection::CRoapConnection

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

//

Roap::CRoapConnection::CRoapConnection()

: CActive( CActive::EPriorityStandard ),

  iState( EInit )

    {

    CActiveScheduler::Add( this );

    }

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

// Roap::CRoapConnection::ConstructL

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

//

void Roap::CRoapConnection::ConstructL()

    {

    }

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

// Roap::CRoapConnection::DoCancel

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

//

void Roap::CRoapConnection::DoCancel()

    {

    LOGLIT( "CRoapConnection::DoCancel" )

    iConnection.Close();

    iSocketServ.Close();

    User::RequestComplete( iParentStatus, KErrCancel );

    }

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

// Roap::CRoapConnection::RunL

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

//

void Roap::CRoapConnection::RunL()

    {

    LOGLIT( "CCRoapConnection::RunL" )

    User::LeaveIfError( iStatus.Int() );    // Handle errors in RunError().

    iState = EConnected;

    User::RequestComplete( iParentStatus, iStatus.Int() );

    iParentStatus = NULL;

    }

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

// Roap::CRoapConnection::RunError

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

//

TInt Roap::CRoapConnection::RunError( TInt  /* aError */ )

    {

    LOGLIT( "CRoapConnection::RunError" )

    iConnection.Close();

    iSocketServ.Close();

    iState = EInit;

    User::RequestComplete( iParentStatus, iStatus.Int() );

    iParentStatus = NULL;

    return KErrNone;

    }

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

// Roap::CRoapConnection::SocketServ

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

//

RSocketServ& Roap::CRoapConnection::SocketServ()

    {

    return iSocketServ;

    }

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

// Roap::CRoapConnection::Conn

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

//

RConnection& Roap::CRoapConnection::Conn()

    {

    return iConnection;

    }