/*

* 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 CVpnApItem class.

*

*/

// INCLUDE FILES

#include    <f32file.h>

#include    <bautils.h>

#include    <barsc.h>

#include    <txtetext.h>

#include    <data_caging_path_literals.hrh>

#include    "VpnApItem.h"

#include    "ApEngineLogger.h"

#include    "ApEngineConsts.h"

#include    "ApEngineCommons.h"

// CONSTANTS

const TInt KApItemInitialTxtBufSize = 0;

const TInt KVpnDefProxyPortNumber = 80;

// DUPLCIATE as I can not touch original, but do need the file here, too...

/// ROM drive.

_LIT( KApEngineResDriveZ, "z:" );

/// ApEngine resource file name.

_LIT( KApEngineResFileName, "ApEngine.rsc" );

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

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

// CVpnApItem::NewLC

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

//

EXPORT_C CVpnApItem* CVpnApItem::NewLC()

    {

    CLOG( ( EApItem, 0, _L( "-> CVpnApItem::NewL" ) ) );

    CVpnApItem* self = new ( ELeave ) CVpnApItem;

    CleanupStack::PushL( self );

    self->ConstructL();

    CLOG( ( EApItem, 1, _L( "<- CVpnApItem::NewL" ) ) );

    return self;

    }

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

// CVpnApItem::~CVpnApItem

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

//

EXPORT_C CVpnApItem::~CVpnApItem()

    {

    CLOG( ( EApItem, 0, _L( "<-> CVpnApItem::~CVpnApItem" ) ) );

    delete iName;

    delete iPolicy;

    delete iProxyServerAddress;

    delete iRealIapName;

    delete iPolicyId;

    delete iVpnIapNetworkName;

    }

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

// CVpnApItem::ConstructL

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

//

EXPORT_C void CVpnApItem::ConstructL()

    {

    CLOG( ( EApItem, 0, _L( "-> CVpnApItem::ConstructL" ) ) );

    // as we are in ConstructL called from NewLC,

    // 'this' is already on the CleanupStack,

    // so do not push members onto it!

    iName = HBufC::NewL( KApItemInitialTxtBufSize );

    iPolicy = HBufC::NewL( KApItemInitialTxtBufSize );

    iProxyServerAddress = HBufC::NewL( KApItemInitialTxtBufSize );

    iRealIapName = HBufC::NewL( KApItemInitialTxtBufSize );

    iPolicyId = HBufC::NewL( KApItemInitialTxtBufSize );

    iVpnIapNetworkName = HBufC::NewL( KApItemInitialTxtBufSize );

    RFs fs;

    CleanupClosePushL<RFs>( fs );

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

    // can't use resource here because it is not added yet....

    TFileName resourceFile;

    resourceFile.Append( KApEngineResDriveZ );

    resourceFile.Append( KDC_RESOURCE_FILES_DIR );

    resourceFile.Append( KApEngineResFileName );

    BaflUtils::NearestLanguageFile( fs, resourceFile );

    RResourceFile rf;

    CleanupClosePushL<RResourceFile>( rf );

    rf.OpenL( fs, resourceFile );

    rf.ConfirmSignatureL( 0 );

    HBufC8* readBuffer = rf.AllocReadLC( R_APNG_DEFAULT_VPN_AP_NAME );

    // as we are expecting HBufC16...

    __ASSERT_DEBUG( ( readBuffer->Length()%2 ) == 0,

                    ApCommons::Panic( EWrongResourceFormat ) );

    const TPtrC16 ptrReadBuffer( (TText16*) readBuffer->Ptr(),

                                 ( readBuffer->Length() + 1 ) >> 1 );

    HBufC16* textBuffer=HBufC16::NewL( ptrReadBuffer.Length() );

    *textBuffer=ptrReadBuffer;

    CleanupStack::PopAndDestroy( readBuffer ); // readbuffer

    CleanupStack::PushL( textBuffer );

    WriteTextL( EApVpnWapAccessPointName, *textBuffer );

    WriteUint( EApVpnProxyPortNumber, KVpnDefProxyPortNumber );

    CleanupStack::PopAndDestroy( 3 ); // textbuffer, fs, rf

    CLOG( ( EApItem, 0, _L( "<- CVpnApItem::ConstructL" ) ) );

    }

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

// CVpnApItem::CVpnApItem

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

//

EXPORT_C CVpnApItem::CVpnApItem()

    {

    CLOG( ( EApItem, 0, _L( "<-> CVpnApItem::CVpnApItem" ) ) );

    }

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

// CVpnApItem::CopyFromL

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

//

EXPORT_C void CVpnApItem::CopyFromL( const CVpnApItem& aCopyFrom  )

    {

    CLOG( ( EApItem, 0, _L( "-> CVpnApItem::CopyFromL" ) ) );

    iVpnTableId = aCopyFrom.iVpnTableId;

    iVpnIapId = aCopyFrom.iVpnIapId;

    iRealIapId = aCopyFrom.iRealIapId;

    iVpnRealWapId = aCopyFrom.iVpnRealWapId;

    iVirtualBearerID = aCopyFrom.iVirtualBearerID;

    iProxyPort = aCopyFrom.iProxyPort;

    iHomeNetwork = aCopyFrom.iHomeNetwork;

    WriteTextL( EApVpnWapAccessPointName, *aCopyFrom.iName );

    WriteTextL( EApVpnPolicy, *aCopyFrom.iPolicy );

    WriteLongTextL( EApVpnProxyServerAddress, *aCopyFrom.iProxyServerAddress );

    WriteTextL( EApVpnRealIapName, *aCopyFrom.iRealIapName );

    WriteTextL( EApVpnPolicyId, *aCopyFrom.iPolicyId );

    WriteTextL( EApVpnIapNetworkName, *aCopyFrom.iVpnIapNetworkName );

    CLOG( ( EApItem, 0, _L( "<- CVpnApItem::CopyFromL" ) ) );

    }

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

// CVpnApItem::operator==

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

//

EXPORT_C TBool CVpnApItem::operator==( const CVpnApItem& aItem ) const

    {

    CLOG( ( EApItem, 0, _L( "-> CVpnApItem::operator==" ) ) );

    TBool retval( EFalse );

    if ( ( iVpnTableId == aItem.iVpnTableId ) &&

         ( iVpnIapId == aItem.iVpnIapId ) &&

         ( iRealIapId == aItem.iRealIapId ) &&

         ( iVpnRealWapId == aItem.iVpnRealWapId ) &&

         ( iVirtualBearerID == aItem.iVirtualBearerID ) &&

         ( iProxyPort == aItem.iProxyPort ) &&

         ( iHomeNetwork == aItem.iHomeNetwork )

         )

        {

        if (

           ( iName->Compare( *aItem.iName ) == 0 )

           && ( iPolicy->Compare( *aItem.iPolicy ) == 0 )

           && ( iProxyServerAddress->Compare( 

                            *aItem.iProxyServerAddress ) == 0 )

           && ( iRealIapName->Compare( *aItem.iRealIapName ) == 0 )

           && ( iPolicyId->Compare( *aItem.iPolicyId ) == 0 )

           && ( iVpnIapNetworkName->Compare( 

                            *aItem.iVpnIapNetworkName ) == 0 )

            )

            {

            retval = ETrue;

            }

        }

    CLOG( ( EApItem, 0, _L( "<- CVpnApItem::operator==" ) ) );

    return ( retval );

    }

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

// CVpnApItem::operator!=

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

//

EXPORT_C TBool CVpnApItem::operator!=( const CVpnApItem& aItem ) const

    {

    CLOG( ( EApItem, 0, _L( "-> CVpnApItem::operator!=" ) ) );

    TBool ret = ( *this == aItem );

    CLOG( ( EApItem, 1, _L( "<- CVpnApItem::operator!=" ) ) );

    return ( !ret );

    }

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

// CVpnApItem::ReadTextL

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

//

EXPORT_C void CVpnApItem::ReadTextL( const TVpnApMember aColumn, 

                                     TDes16& aValue )

    {

    CLOG( ( EApItem, 0, _L( "-> CVpnApItem::ReadTextL" ) ) );

    switch ( aColumn )

        {

        case EApVpnWapAccessPointName:

            {

            aValue.SetLength( iName->Length() );

            aValue.Format( KFormat, iName );

            break;

            }

        case EApVpnProxyServerAddress:

            {

            // make it large enough to hold

            aValue.SetLength( iProxyServerAddress->Length() );

            aValue.Format( KFormat, iProxyServerAddress );

            break;

            }

        case EApVpnPolicy:

            {

            aValue.SetLength( iPolicy->Length() );

            aValue.Format( KFormat, iPolicy );

            break;

            }

        case EApVpnRealIapName:

            {

            aValue.SetLength( iRealIapName->Length() );

            aValue.Format( KFormat, iRealIapName );

            break;

            }

        case EApVpnPolicyId:

            {

            aValue.SetLength( iPolicyId->Length() );

            aValue.Format( KFormat, iPolicyId );

            break;

            }

        case EApVpnIapNetworkName:

            {

            aValue.SetLength( iVpnIapNetworkName->Length() );

            aValue.Format( KFormat, iVpnIapNetworkName );

            break;

            }

        default:

            {

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

            User::Leave( KErrInvalidColumn );

            }

        }

    CLOG( ( EApItem, 1, _L( "<- CVpnApItem::ReadTextL" ) ) );

    }

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

// CVpnApItem::ReadConstLongTextL

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

//

EXPORT_C const HBufC* CVpnApItem::ReadConstLongTextL( 

                                         const TVpnApMember aColumn 

                                                    )

    {

    CLOG( ( EApItem, 0, _L( "-> CVpnApItem::ReadConstLongTextL" ) ) );

    HBufC* retval = NULL;

    switch ( aColumn )

        {

        case EApVpnProxyServerAddress:

            {

            retval = iProxyServerAddress;

            break;

            }

        default:

            {

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

            User::Leave( KErrInvalidColumn );

            break;

            }

        }

    CLOG( ( EApItem, 1, _L( "<- CVpnApItem::ReadConstLongTextL" ) ) );

    return retval;

    }

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

// CVpnApItem::ReadUint

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

//

EXPORT_C TInt CVpnApItem::ReadUint( const TVpnApMember aColumn, 

                                    TUint32& aValue )

    {

    CLOG( ( EApItem, 0, _L( "-> CVpnApItem::ReadUint" ) ) );

    TInt retval ( KErrNone );

    switch ( aColumn )

    {

        case EApVpnWapAccessPointID:

            {

            aValue = iVpnWapId;

            break;

            }

        case EApVpnIapID:

            {

            aValue = iVpnIapId;

            break;

            }

        case EApVpnRealIapID:

            {

            aValue = iRealIapId;

            break;

            }

        case EApVpnRealWapID:

            {

            aValue = iVpnRealWapId;

            break;

            }

        case EApVpnProxyPortNumber:

            {

            aValue = iProxyPort;

            break;

            }

        case EApVpnHomeNetworkID:

            {

            aValue = iHomeNetwork;

            break;

            }

        case EApVpnIapNetworkID:

            {

            aValue = iVpnIapNetwork;

            break;

            }

        default :

            {

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

            retval = KErrInvalidColumn;

            break;

            }

        }

    CLOG( ( EApItem, 1, _L( "<- CVpnApItem::ReadUint" ) ) );

    return retval;

    }

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

// CVpnApItem::ReadBool

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

//

EXPORT_C TInt CVpnApItem::ReadBool( const TVpnApMember /*aColumn*/, 

                                    TBool& /*aValue*/ )

    {

    CLOG( ( EApItem, 0, _L( "-> CVpnApItem::ReadBool" ) ) );

    // This is just a placeholder API for possible expansion...

    TInt retval( KErrNone );

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

    retval = KErrInvalidColumn;

    CLOG( ( EApItem, 1, _L( "<- CVpnApItem::ReadBool" ) ) );

    return retval;

    }

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

// CVpnApItem::WriteTextL

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

//

EXPORT_C TInt CVpnApItem::WriteTextL( const TVpnApMember aColumn,

                                      const TDesC16& aValue )

    {

    CLOG( ( EApItem, 0, _L( "-> CVpnApItem::WriteTextL" ) ) );

    TInt retval( KErrNone );

    switch ( aColumn )

    {

        case EApVpnWapAccessPointName:

            {

            HBufC* sgd = aValue.AllocLC();

            sgd->Des().Trim();

            ReAllocL( iName, *sgd);

            CleanupStack::PopAndDestroy( sgd ); // sgd

            break;

            }

        case EApVpnPolicy:

            {

            ReAllocL( iPolicy, aValue);

            break;

            }

        case EApVpnProxyServerAddress:

            {

            ReAllocL( iProxyServerAddress, aValue);

            break;

            }

        case EApVpnRealIapName:

            {

            ReAllocL( iRealIapName, aValue );

            break;

            }

        case EApVpnPolicyId:

            {

            ReAllocL( iPolicyId, aValue );

            break;

            }

        case EApVpnIapNetworkName:

            {

            ReAllocL( iVpnIapNetworkName, aValue );

            break;

            }

        default:

            {

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

            retval = KErrInvalidColumn;

            break;

            }

        }

    CLOG( ( EApItem, 1, _L( "<- CVpnApItem::WriteTextL" ) ) );

    return retval;

    }

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

// CVpnApItem::WriteLongTextL

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

//

EXPORT_C TInt CVpnApItem::WriteLongTextL( const TVpnApMember aColumn,

                                          const TDesC& aValue )

    {

    CLOG( ( EApItem, 0, _L( "-> CVpnApItem::WriteLongTextL" ) ) );

    TInt retval( KErrNone );

    switch ( aColumn )

        {

        case EApVpnProxyServerAddress:

            {

            ReAllocL( iProxyServerAddress, aValue);

            break;

            }

        default:

            {

            // unknown column...

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

            retval = KErrInvalidColumn;

            break;

            }

        }

    CLOG( ( EApItem, 1, _L( "<- CVpnApItem::WriteLongTextL" ) ) );

    return retval;

    }

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

// CVpnApItem::WriteUint

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

//

EXPORT_C TInt CVpnApItem::WriteUint( const TVpnApMember aColumn,

                                     const TUint32& aValue )

    {

    CLOG( ( EApItem, 0, _L( "-> CVpnApItem::WriteUint" ) ) );

    TInt retval( KErrNone );

    switch ( aColumn )

        {

        case EApVpnWapAccessPointID:

            {

            iVpnWapId = aValue;

            break;

            }

        case EApVpnIapID:

            {

            iVpnIapId = aValue;

            break;

            }

        case EApVpnRealIapID:

            {

            iRealIapId= aValue;

            break;

            }

        case EApVpnRealWapID: