/*

* 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 class CApDataHandler

*

*/

// INCLUDE FILES

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <nifvar_internal.h>

#endif

#include "APEngineVariant.hrh"

#include <cdbcols.h>

#include <commdb.h>

#include <cdbpreftable.h>

#include <etelpckt.h>

#include <featmgr.h>

#ifdef __TEST_USE_SHARED_DATA

    #include <SharedDataClient.h>

    #include <sharedDataValues.h>

#endif //__TEST_USE_SHARED_DATA

#include <WlanCdbCols.h>

#include "ApDataHandler.h"

#include "ApAccessPointItem.h"

#include "ApEngineCommons.h"

#include "ApUtils.h"

#include "ApEngineVer.h"

#include "ApEngineLogger.h"

#include "ApNetworkItem.h"

#include "APItemExtra.h"

#include "APItemCdmaData.h"

#include "APItemWlanData.h"

#include "ApSpeedLookup.h"

#include <WEPSecuritySettingsUI.h>

#include <WPASecuritySettingsUI.h>

// CONSTANTS

#if defined(_DEBUG)

    _LIT( KErrInvalidIntendedType, "Invalid intended default type" );

#endif // (_DEBUG)

_LIT( KErrNoSuchCase, "No such case" );

// Agreed GPRS_QOS_WARNING_TIMEOUT Value

const TInt KGprsOsTimeout = -1;

/**

* General Settings UID

*/

#ifdef __TEST_USE_SHARED_DATA

    LOCAL_D const TUid KGeneralSettingsUid = { 0X100058EC };

#endif // __TEST_USE_SHARED_DATA

_LIT( KWlanBearerName, "WLANBearer" );

_LIT( KWlanBearerAgent, "wlanagt.agt" );

_LIT( KWlanBearerNif, "wlannif" );

_LIT( KWlanLDDName, "not used" );

_LIT( KWlanPDDName, "not used" );

const TInt KWlanLastSocketActivityTimeout = -1;

const TInt KWlanLastSessionClosedTimeout = 1;

const TInt KWlanLastSocketClosedTimeout = -1;

// MACROS

// LOCAL FUNCTION PROTOTYPES

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

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

// might leave.

//

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

// CApDataHandler::NewLC

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

//

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

    {

    CLOG( ( EHandler, 0, _L( "-> CApDataHandler::NewLC" ) ) );

    CApDataHandler* db = new( ELeave ) CApDataHandler;

    CleanupStack::PushL( db );

    db->ConstructL( aDb );

    CLOG( ( EHandler, 1, _L( "<- CApDataHandler::NewLC" ) ) );

    return db;

    }

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

// CApDataHandler::~CApDataHandler

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

//

EXPORT_C CApDataHandler::~CApDataHandler()

    {

    if ( iExt )

        {

        if ( iExt->iIsFeatureManagerInitialised )

            {

            FeatureManager::UnInitializeLib();

            }

        }

    delete iExt;

    }

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

// CApDataHandler::CApDataHandler

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

//

EXPORT_C CApDataHandler::CApDataHandler( )

    {

    iDb = NULL;

    }

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

// CApDataHandler::ConstructL

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

//

EXPORT_C void CApDataHandler::ConstructL( CCommsDatabase& aDb )

    {

    CLOG( ( EHandler, 0, _L( "-> CApDataHandler::ConstructL" ) ) );

    iExt = new ( ELeave )THandlerExtra;

    iExt->iIsFeatureManagerInitialised = EFalse;

    iExt->iIsIpv6Supported = EFalse;

    FeatureManager::InitializeLibL();

    iExt->iIsFeatureManagerInitialised = ETrue;

    iExt->iIsIpv6Supported = 

                            FeatureManager::FeatureSupported( KFeatureIdIPv6 );

#ifdef __TEST_IPV6_SUPPORT    

    iExt->iIsIpv6Supported = ETrue;

#endif //  __TEST_IPV6_SUPPORT    

    iDb = &aDb;

#ifdef __TEST_USE_SHARED_DATA

    iExt->iIsAppHscsdSupport = 

        ApCommons::IsGivenSharedDataSupportL( KGeneralSettingsUid, 

                                              KGSHSCSDAccessPoints );

#else

    iExt->iIsAppHscsdSupport = ETrue;

#endif // __TEST_USE_SHARED_DATA

#ifdef __TEST_HSCSD_SUPPORT

    iExt->iIsAppHscsdSupport = ETrue;

#endif // __TEST_HSCSD_SUPPORT

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

#ifdef __TEST_CDMA_WRITE_PROTECT

    iExt->iVariant |= KApUiEditOnlyVPNs;

#endif // __TEST_CDMA_WRITE_PROTECT

    CLOG( ( EHandler, 1, _L( "<- CApDataHandler::ConstructL" ) ) );

    }

// query

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

// CApDataHandler::AccessPointDataL

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

//

EXPORT_C void CApDataHandler::AccessPointDataL( TUint32 aUid,

                                              CApAccessPointItem& aApItem )

    {

    CLOG( ( EHandler, 0, _L( "-> CApDataHandler::AccessPointDataL" ) ) );

    // returns the AP data of the record with the UID aUid

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

    DoAccessPointDataL( aUid, aApItem );

    if ( ownTransaction )

        {

        ApCommons::CommitTransaction( *iDb );

        CleanupStack::Pop(); // RollbackTransactionOnLeave

        }

    aApItem.SanityCheckOk();

    CLOG( ( EHandler, 1, _L( "<- CApDataHandler::AccessPointDataL" ) ) );

    }

// update

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

// CApDataHandler::UpdateAccessPointDataL

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

//

EXPORT_C void CApDataHandler::UpdateAccessPointDataL

                                                (

                                                CApAccessPointItem& aApItem,

                                                TBool& aNameChanged

                                                )

    {

    CLOG( ( EHandler, 0, _L( "-> CApDataHandler::UpdateAccessPointDataL" ) ) );

    if ( iExt->iVariant & KApUiEditOnlyVPNs )

        {

        User::Leave( KErrNotSupported );

        }

    // update access point data.

    aApItem.SanityCheckOk();

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

    DoUpdateAccessPointDataL( aApItem, EFalse, aNameChanged );

    if ( ownTransaction )

        {

        ApCommons::CommitTransaction( *iDb );

        CleanupStack::Pop(); // RollbackTransactionOnLeave

        }

    CLOG( ( EHandler, 1, _L( "<- CApDataHandler::UpdateAccessPointDataL" ) ) );

    }

// Creating new AP

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

// CApDataHandler::CreateCopyFromL

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

//

EXPORT_C TUint32 CApDataHandler::CreateCopyFromL( TUint32 aBaseId )

    {

    CLOG( ( EHandler, 0, _L( "-> CApDataHandler::CreateCopyFromL" ) ) );

    if ( iExt->iVariant & KApUiEditOnlyVPNs )

        {

        User::Leave( KErrNotSupported );

        }

    CApAccessPointItem* holder = CApAccessPointItem::NewLC();

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

    AccessPointDataL( aBaseId, *holder );

    TUint32 oldwlanid( 0 );

    holder->ReadUint( EApIapServiceId, oldwlanid );

    TUint32 retval( 0 );

    TBool aNameChanged( EFalse );

    TApBearerType bearer = holder->BearerTypeL();

    CWEPSecuritySettings* wepSecSettings = NULL;

    CWPASecuritySettings* wpaSecSettings( NULL );

    // only one of the above might be loaded once, so after copying

    // we might need to PopAndDestroy only one item

    TBool pushed(EFalse);

    if ( bearer == EApBearerTypeWLAN )

        {

        TUint32 secmode( 0 );

        holder->ReadUint( EApWlanSecurityMode, secmode );

        switch ( secmode )

            {

            case EOpen:

                {

                break;

                }

            case EWep:

                {

                wepSecSettings = CWEPSecuritySettings::NewL();

                CleanupStack::PushL( wepSecSettings );

                pushed = ETrue;

                TUint32 wlanid( 0 );

                holder->ReadUint( EApIapServiceId, wlanid );

                wepSecSettings->LoadL( wlanid, *iDb );

                break;

                }

            case E802_1x:

                {

                wpaSecSettings = 

                    CWPASecuritySettings::NewL( ESecurityMode8021x );

                CleanupStack::PushL( wpaSecSettings );

                pushed = ETrue;

                TUint32 wlanid( 0 );

                holder->ReadUint( EApIapServiceId, wlanid );

                wpaSecSettings->LoadL( wlanid, *iDb );

                break;

                }

            case EWpa:

            case EWpa2:

                {

                wpaSecSettings = 

                        CWPASecuritySettings::NewL( ESecurityModeWpa );

                CleanupStack::PushL( wpaSecSettings );

                pushed = ETrue;

                TUint32 wlanid( 0 );

                holder->ReadUint( EApIapServiceId, wlanid );

                wpaSecSettings->LoadL( wlanid, *iDb );

                break;

                }

            default:

                {

                __ASSERT_DEBUG( EFalse, ApCommons::Panic( ENotSupported ) );

                // do nothing in urel

                break;

                }

            }

        }

    retval = DoUpdateAccessPointDataL( *holder, ETrue, aNameChanged );

    if ( bearer == EApBearerTypeWLAN )

        {

        TUint32 wlanid(0);

        holder->ReadUint( EApIapServiceId, wlanid );        

        // now check if it is WEP...

        // read up security mode

        TUint32 secmode( 0 );

        holder->ReadUint( EApWlanSecurityMode, secmode );

        switch ( secmode )

            {

            case EOpen:

                {

                break;

                }

            case EWep:

                {

                // we have to try to save

                wepSecSettings->SaveL( wlanid, *iDb );

                break;

                }

            case E802_1x:

                {

                wpaSecSettings->SaveL( wlanid, *iDb, 

                                       ESavingNewAPAsACopy, oldwlanid );

                break;

                }

            case EWpa:

            case EWpa2:

                {

                wpaSecSettings->SaveL( wlanid, *iDb,

                                       ESavingNewAPAsACopy, oldwlanid );

                break;

                }

            default:

                {

                __ASSERT_DEBUG( EFalse, ApCommons::Panic( ENotSupported ) );

                // do nothing in urel

                break;

                }

            }

        }

    if ( pushed )        

        {

        CleanupStack::PopAndDestroy(); // the sec. settings

        }

    if ( ownTransaction )

        {

        ApCommons::CommitTransaction( *iDb );

        CleanupStack::Pop(); // RollbackTransactionOnLeave

        }

    CleanupStack::PopAndDestroy( holder );    // holder

    CLOG( ( EHandler, 1, _L( "<- CApDataHandler::CreateCopyFromL" ) ) );

    return retval;

    }

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

// CApDataHandler::CreateFromDataL

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

//

EXPORT_C TUint32 CApDataHandler::CreateFromDataL( CApAccessPointItem& aApItem )

    {

    CLOG( ( EHandler, 0, _L( "-> CApDataHandler::CreateFromDataL" ) ) );

    if ( iExt->iVariant & KApUiEditOnlyVPNs )

        {

        User::Leave( KErrNotSupported );

        }

    aApItem.SanityCheckOk();

    TBool aNameChanged( EFalse );

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

    TUint32 retval = DoUpdateAccessPointDataL( aApItem, ETrue, aNameChanged );

    if ( ownTransaction )

        {

        ApCommons::CommitTransaction( *iDb );

        CleanupStack::Pop(); // RollbackTransaction

        }

    CLOG( ( EHandler, 1, _L( "<- CApDataHandler::CreateFromDataL" ) ) );

    return retval;

    }

// Remove

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

// CApDataHandler::RemoveAP

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

//

EXPORT_C void CApDataHandler::RemoveAPL( TUint32 aUid )

    {

    CLOG( ( EHandler, 0, _L( "-> CApDataHandler::RemoveAPL" ) ) );

    if ( iExt->iVariant & KApUiEditOnlyVPNs )

        {

        User::Leave( KErrNotSupported );

        }

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

    DoRemoveAPL( aUid );

    if ( ownTransaction )

        {

        ApCommons::CommitTransaction( *iDb );

        CleanupStack::Pop(); // RollbackTransactionOnLeave

        }

    CLOG( ( EHandler, 1, _L( "<- CApDataHandler::RemoveAPL" ) ) );

    }

// Getting default access point

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

// CApDataHandler::DefaultL

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

//

EXPORT_C TUint32 CApDataHandler::DefaultL( TBool aIsWap ) const

    {

    CLOG( ( EHandler, 0, _L( "-> CApDataHandler::DefaultL" ) ) );

    // get default AP...

    // first get global settings...

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

    TUint32 value = DoGetDefaultL( aIsWap, NULL );

    if ( ownTransaction )

        {

        ApCommons::CommitTransaction( *iDb );

        CleanupStack::Pop(); // RollbackTransactionOnLeave

        }

    CLOG( ( EHandler, 1, _L( "<- CApDataHandler::DefaultL" ) ) );

    return value;

    }

// Setting as default

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

// CApDataHandler::SetAsDefaultL

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

//

EXPORT_C void CApDataHandler::SetAsDefaultL( TUint32 aUid,

                                            TCommsDbIspType aIntendedType )

    {

    CLOG( ( EHandler, 0, _L( "-> CApDataHandler::SetAsDefaultL" ) ) );

    if ( iExt->iVariant & KApUiEditOnlyVPNs )

        {

        User::Leave( KErrNotSupported );

        }

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

    DoSetAsDefaultL( aUid, aIntendedType );

    if ( ownTransaction )

        {

        ApCommons::CommitTransaction( *iDb );

        CleanupStack::Pop(); // RollbackTransactionOnLeave

        }

    CLOG( ( EHandler, 1, _L( "<- CApDataHandler::SetAsDefaultL" ) ) );

    }

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

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

// Connection Preferene Handling

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

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

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

// CApDataHandler::SetPreferredIfDbIapTypeL

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

//

EXPORT_C void CApDataHandler::SetPreferredIfDbIapTypeL

                                    (

                                    TUint32 aRank,

                                    TCommDbConnectionDirection aDirection,

                                    TUint32 aBearers,

                                    TCommDbDialogPref aPrompt,

                                    TUint32 aIAP,

                                    TBool aOverwrite

                                    )

    {

    CLOG( ( EHandler, 0, 

        _L( "-> CApDataHandler::SetPreferredIfDbIapTypeL" ) ) );