/*

* Copyright (c) 2002 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:  Declaration of the class CApUtils

*     Contains utility functions for access point handling

*

*/

// INCLUDE FILES

#include "APEngineVariant.hrh"

#include "ApUtils.h"

#include "ApAccessPointItem.h"

#include "ApDataHandler.h"

#include "ApEngineCommons.h"

#include "ApEngineLogger.h"

#include <e32des16.h>

#include <es_sock.h>

#include <es_enum.h>

#include    <featmgr.h>

#include <WlanCdbCols.h>

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

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

// construct/destruct/copy

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

// CApUtils::NewLC

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

//

EXPORT_C CApUtils* CApUtils::NewLC( CCommsDatabase& aDb )

    {

    CLOG( ( EUtil, 0, _L( "-> CApUtils::NewLC" ) ) );

    CApUtils* db = new( ELeave ) CApUtils;

    CleanupStack::PushL( db );

    db->ConstructL( aDb );

    CLOG( ( EUtil, 1, _L( "<- CApUtils::NewLC" ) ) );

    return db;

    }

// Destructor

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

// CApUtils::~CApUtils

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

//

EXPORT_C CApUtils::~CApUtils()

    {

    if ( iExt )

        {

        if ( iExt->iIsFeatureManagerInitialised )

            {

            FeatureManager::UnInitializeLib();

            }

        }    

    delete iExt;

    CLOG( ( EUtil, 0, _L( "<-> CApUtils::~CApUtils" ) ) );

    }

// C++ default constructor can NOT contain any code that

// might leave.

//

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

// CApUtils::CApUtils

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

//

EXPORT_C CApUtils::CApUtils()

    {

    }

// Symbian OS default constructor can leave.

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

// CApUtils::ConstructL

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

//

EXPORT_C void CApUtils::ConstructL( CCommsDatabase& aDb )

    {

    CLOG( ( EUtil, 0, _L( "-> CApUtils::ConstructL" ) ) );

    iDb = &aDb;

    iExt = new ( ELeave )TUtilsExtra;

    FeatureManager::InitializeLibL();

    iExt->iIsFeatureManagerInitialised = ETrue;    

    iExt->iVariant = ApCommons::GetVariantL();

#ifdef __TEST_CDMA_WRITE_PROTECT

    iExt->iVariant |= KApUiEditOnlyVPNs;

#endif // __TEST_CDMA_WRITE_PROTECT

    iExt->iWlanSupported = 

        FeatureManager::FeatureSupported( KFeatureIdProtocolWlan );

#ifdef __TEST_WLAN_SUPPORT

    iExt->iWlanSupported = ETrue;

#endif // __TEST_WLAN_SUPPORT

    CLOG( ( EUtil, 1, _L( "<- CApUtils::ConstructL" ) ) );

    }

// utilities

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

// CApUtils::IsAPInUseL

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

//

EXPORT_C TBool CApUtils::IsAPInUseL( TUint32 aUid )

    {

    CLOG( ( EUtil, 0, _L( "-> CApUtils::IsAPInUseL" ) ) );

    TBool retval( EFalse );

#ifdef __WINS__

    // just to satisfy compiler...

    aUid++;

#else // 

    RSocketServ rs;

    RConnection rc;

    TUint32 iap( 0 );

    TBool ownTransaction = ApCommons::StartPushedTransactionLC( *iDb, ETrue );

    TRAP_IGNORE( iap = IapIdFromWapIdL( aUid ) );

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

    User::LeaveIfError( rc.Open( rs ) );

    TUint count( 0 );

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

    // Go on only if there is any

    if ( count )

        {

        for( TUint i = 1; i <= count; i++)

            {

            TPckgBuf<TConnectionInfo> connInfo;

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

            if ( iap == connInfo().iIapId )

                { 

                // IAP is in use, break

                retval = ETrue;

                break;

                }

            }

        }

    rc.Close();

    rs.Close();    

    if ( ownTransaction )

        {

        ApCommons::CommitTransaction( *iDb );

        CleanupStack::Pop(); // RollbackTransactionOnLeave

        }

#endif // __WINS__     

    CLOG( ( EUtil, 1, _L( "<- CApUtils::IsAPInUseL" ) ) );

    return ( retval );

    }

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

// CApUtils::WapBearerTypeL

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

//

EXPORT_C void CApUtils::WapBearerTypeL( TUint32 aUid, TDes& aBearer )

    {

    CLOG( ( EUtil, 0, _L( "-> CApUtils::WapBearerTypeL" ) ) );

    TBool ownTransaction = ApCommons::StartPushedTransactionLC( *iDb );

    DoWapBearerTypeL( aUid, aBearer );

    if ( ownTransaction )

        {

        ApCommons::CommitTransaction( *iDb );

        CleanupStack::Pop(); // RollbackTransactionOnLeave

        }

    CLOG( ( EUtil, 1, _L( "<- CApUtils::WapBearerTypeL" ) ) );

    }

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

// CApUtils::BearerTypeL

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

//

EXPORT_C TApBearerType CApUtils::BearerTypeL( TUint32 aUid )

    {

    CLOG( ( EUtil, 0, _L( "-> CApUtils::BearerTypeL" ) ) );

    TBool ownTransaction = ApCommons::StartPushedTransactionLC( *iDb );

    TApBearerType retval = EApBearerTypeAllBearers;

    retval = DoBearerTypeL( aUid );

    if ( ownTransaction )

        {

        ApCommons::CommitTransaction( *iDb );

        CleanupStack::Pop(); // RollbackTransactionOnLeave

        }

    CLOG( ( EUtil, 1, _L( "<- CApUtils::BearerTypeL" ) ) );

    return retval;

    }

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

// CApUtils::ISPTypeL

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

//

EXPORT_C void CApUtils::ISPTypeL( TUint32 aUid, TCommsDbIspType& aIspType )

    {

    CLOG( ( EUtil, 0, _L( "-> CApUtils::ISPTypeL" ) ) );

    TBool ownTransaction = ApCommons::StartPushedTransactionLC( *iDb );

    DoISPTypeL( aUid, aIspType );

    if ( ownTransaction )

        {

        ApCommons::CommitTransaction( *iDb );

        CleanupStack::Pop(); // RollbackTransactionOnLeave

        }

    CLOG( ( EUtil, 1, _L( "<- CApUtils::ISPTypeL" ) ) );

    }

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

// CApUtils::IsValidNameL

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

//

EXPORT_C TBool CApUtils::IsValidNameL( const TDesC& aNameText )

    {

    CLOG( ( EUtil, 0, _L( "<-> CApUtils::IsValidNameL" ) ) );

    return IsValidNameL( aNameText, 0 );

    }

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

// CApUtils::MakeValidName

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

//

EXPORT_C TBool CApUtils::MakeValidNameL( TDes& aNameText )

    {

    CLOG( ( EUtil, 0, _L( "-> CApUtils::MakeValidNameL" ) ) );

    TBool ownTransaction = ApCommons::StartPushedTransactionLC( *iDb );

    HBufC* buf = HBufC::NewLC( KModifiableTextLength );

    TPtr ptr( buf->Des() );

    ptr.Copy( aNameText );

    TBool nameChanged( EFalse );

    HBufC* sgd = ApCommons::DoMakeValidNameL( *iDb,

                                               nameChanged,

                                               buf,

                                               0,

                                               EFalse );

    if ( nameChanged )

        {

        aNameText.Copy( *sgd );

        }

    CleanupStack::PopAndDestroy( buf ); // buf

    delete sgd;

    if ( ownTransaction )

        {

        ApCommons::CommitTransaction( *iDb );

        CleanupStack::Pop(); // RollbackTransactionOnLeave

        }

    CLOG( ( EUtil, 1, _L( "<- CApUtils::MakeValidNameL" ) ) );

    return nameChanged;

    }

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

// CApUtils::NameL

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

//

EXPORT_C void CApUtils::NameL( TUint32 aUid, TDes& aName )

    {

    CLOG( ( EUtil, 0, _L( "-> CApUtils::NameL" ) ) );

    TBool ownTransaction = ApCommons::StartPushedTransactionLC( *iDb );

    DoNameL( aUid, aName );

    if ( ownTransaction )

        {

        ApCommons::CommitTransaction( *iDb );

        CleanupStack::Pop(); // RollbackTransactionOnLeave

        }

    CLOG( ( EUtil, 1, _L( "<- CApUtils::NameL" ) ) );

    }

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

// CApUtils::SetNameL

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

//

EXPORT_C void CApUtils::SetNameL( TDes& aName, TUint32 aUid )

    {

    CLOG( ( EUtil, 0, _L( "-> CApUtils::SetNameL" ) ) );

    if ( iExt->iVariant & KApUiEditOnlyVPNs )

        {

        User::Leave( KErrNotSupported );

        }

    TBool ownTransaction = ApCommons::StartPushedTransactionLC( *iDb );

    DoSetNameL( aName, aUid );

    if ( ownTransaction )

        {

        ApCommons::CommitTransaction( *iDb );

        CleanupStack::Pop(); // RollbackTransactionOnLeave

        }

    CLOG( ( EUtil, 1, _L( "<- CApUtils::SetNameL" ) ) );

    }

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

// CApUtils::SetISPTypeL

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

//

EXPORT_C void CApUtils::SetISPTypeL( TUint32 aUid, TCommsDbIspType aIspType )

    {

    CLOG( ( EUtil, 0, _L( "-> CApUtils::SetISPTypeL" ) ) );

    if ( iExt->iVariant & KApUiEditOnlyVPNs )

        {

        User::Leave( KErrNotSupported );

        }

    TBool ownTransaction = ApCommons::StartPushedTransactionLC( *iDb );

    DoSetISPTypeL( aUid, aIspType );

    if ( ownTransaction )

        {

        ApCommons::CommitTransaction( *iDb );

        CleanupStack::Pop(); // RollbackTransactionOnLeave

        }

    CLOG( ( EUtil, 1, _L( "<- CApUtils::SetISPTypeL" ) ) );

    }

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

// CApUtils::IapIdFromWapIdL

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

//

EXPORT_C TUint32 CApUtils::IapIdFromWapIdL( TUint32 aUid )

    {

    CLOG( ( EUtil, 0, _L( "-> CApUtils::IapIdFromWapIdL" ) ) );

    TBool ownTransaction = ApCommons::StartPushedTransactionLC( *iDb );

    TUint32 retval( 0 );

    CCommsDbTableView* wapt;

    wapt = iDb->OpenViewMatchingUintLC( TPtrC(WAP_ACCESS_POINT),

                                       TPtrC(COMMDB_ID), aUid );

    User::LeaveIfError( wapt->GotoFirstRecord() );

    HBufC* wapBearer = ApCommons::ReadText16ValueLC

                                                (

                                                wapt,

                                                TPtrC(WAP_CURRENT_BEARER)

                                                );

    if ( *wapBearer == TPtrC(WAP_IP_BEARER) )

        {

        CCommsDbTableView* bearert;

        bearert = iDb->OpenViewMatchingUintLC( TPtrC(*wapBearer),

                                            TPtrC(WAP_ACCESS_POINT_ID), aUid );

        User::LeaveIfError( bearert->GotoFirstRecord() );

        ApCommons::ReadUintL( bearert, TPtrC(WAP_IAP), retval );

        CleanupStack::PopAndDestroy( bearert ); // bearert

        }

    else

        {

        User::Leave( KErrInvalidBearerType );

        }

    CleanupStack::PopAndDestroy( 2, wapt ); // wapBearer, wapt

    if ( ownTransaction )

        {

        ApCommons::CommitTransaction( *iDb );

        CleanupStack::Pop(); // RollbackTransactionOnLeave

        }

    CLOG( ( EUtil, 1, _L( "<- CApUtils::IapIdFromWapIdL" ) ) );

    return retval;

    }

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

// CApUtils::WapIdFromIapIdL

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

//

EXPORT_C TUint32 CApUtils::WapIdFromIapIdL( TUint32 aUid )

    {

    CLOG( ( EUtil, 0, _L( "-> CApUtils::WapIdFromIapIdL" ) ) );

    TBool ownTransaction = ApCommons::StartPushedTransactionLC( *iDb );

    TUint32 retval( 0 );

    CCommsDbTableView* bearert;

    bearert = iDb->OpenViewMatchingUintLC( TPtrC(WAP_IP_BEARER),

                                          TPtrC(WAP_IAP), aUid );

    User::LeaveIfError( bearert->GotoFirstRecord() );

    ApCommons::ReadUintL( bearert, TPtrC(WAP_ACCESS_POINT_ID), retval );

    CleanupStack::PopAndDestroy( bearert ); // bearert

    if ( ownTransaction )

        {

        ApCommons::CommitTransaction( *iDb );

        CleanupStack::Pop(); // RollbackTransactionOnLeave

        }

    CLOG( ( EUtil, 1, _L( "<- CApUtils::WapIdFromIapIdL" ) ) );

    return retval;

    }

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

// CApUtils::HasMandatoryFieldsFilledL

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

//

EXPORT_C TBool CApUtils::HasMandatoryFieldsFilledL( TUint32 aUid )

    {

    CLOG( ( EUtil, 0, _L( "-> CApUtils::HasMandatoryFieldsFilledL" ) ) );

    TBool retval( EFalse );

    TBool isOwn = ApCommons::StartPushedTransactionLC( *iDb );

    retval= DoHasMandatoryFieldsFilledL( aUid );

    if ( isOwn )

        {

        ApCommons::CommitTransaction( *iDb );

        CleanupStack::Pop(); // RollbackTransactionOnLeave

        }

    CLOG( ( EUtil, 1, _L( "<- CApUtils::HasMandatoryFieldsFilledL" ) ) );

    return retval;

    }

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

// CApUtils::IAPExistsL

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

//

EXPORT_C TBool CApUtils::IAPExistsL( TUint32 aUid )

    {

    CLOG( ( EUtil, 0, _L( "<-> CApUtils::IAPExistsL" ) ) );

    return DoesExistsL( TPtrC( IAP ), aUid );

    }

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

// CApUtils::WapApExistsL

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

//

EXPORT_C TBool CApUtils::WapApExistsL( TUint32 aUid )

    {

    CLOG( ( EUtil, 0, _L( "<-> CApUtils::WapApExistsL" ) ) );

    return DoesExistsL( TPtrC( WAP_ACCESS_POINT ), aUid );

    }

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

// CApUtils::DoHasMandatoryFieldsFilledL

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

//

EXPORT_C TBool CApUtils::DoHasMandatoryFieldsFilledL(

                                                  TUint32 aUid,

                                                  CCommsDbTableView* aWapt,

                                                  TApBearerType aBearertype )

    {

    CLOG( ( EUtil, 0, _L( "-> CApUtils::DoHasMandatoryFieldsFilledL" ) ) );

    TBool retval( EFalse );

    TInt need2pop( 0 );

    // if not contains, retval = False...

    // Mandatory WAP settings are:

    // CSD: StartPage, GatewayAddr

    // Note: SMS bearer had been dropped.

    // SMS: ServerNumber, ServiceNumber

    // Gprs: StartPage, GatewayAddr

    // Cdma: StartPage, GatewayAddr

    // Start with CSD/GPRS:

    if ( aBearertype == EApBearerTypeAllBearers )

        {

        aBearertype = BearerTypeL( aUid );

        }

    if ( aBearertype == EApBearerTypeAllBearers )