/*

* Copyright (c) 2006-2006 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 Always-On settings in OMA provisioning.

*

*/

// INCLUDE FILES

#include    <f32file.h>

#include    <CWPCharacteristic.h>

#include    <CWPParameter.h>

#include    <pdpcontextmanagerinternalcrkeys.h>

#include    <centralrepository.h>

#include    "WPAdapterUtil.h"

#include    "alwaysonadapter.h"

#include    "ProvisioningDebug.h"

// CONSTANTS

_LIT( KAlwaysOnAwonPdpcStr, "AWON-PDPC" );

_LIT( KAlwaysOnTRetryStr, "T-RETRY" );

// AlwaysON PDP context status

// Parameters shall be binary encoded using the in-line string.

// Max length for each item is 2bytes.

// Values are XY, where X is related to 3G flag and Y is related to 2G flag.

// Possible values are:

//  *   "00", AlwaysOn is OFF for both 3G and 2G

//  *   "10", AlwaysOn is ON for 3G, OFF for 2G

//  *   "01", AlwaysOn is OFF for 3G, ON for 2G

//  *   "11", AlwaysOn is ON for 3G, ON for 2G

const TInt KAwonPdpc_Off3G_Off2G = 00;

const TInt KAwonPdpc_Off3G_On2G  = 01;

const TInt KAwonPdpc_On3G_Off2G  = 10;

const TInt KAwonPdpc_On3G_On2G   = 11;

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

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

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

// CAlwaysOnAdapter::CAlwaysOnAdapter

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

// might leave.

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

//

CAlwaysOnAdapter::CAlwaysOnAdapter()

    {

    }

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

// CAlwaysOnAdapter::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CAlwaysOnAdapter::ConstructL()

    {

    iPdpCenrep = CRepository::NewL( KCRUidPDPContextManager );

    }

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

// CAlwaysOnAdapter::NewL

// Two-phased constructor.

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

//

CAlwaysOnAdapter* CAlwaysOnAdapter::NewL()

    {

    CAlwaysOnAdapter* self = new( ELeave ) CAlwaysOnAdapter;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CAlwaysOnAdapter::~CAlwaysOnAdapter

// Destructor

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

//

CAlwaysOnAdapter::~CAlwaysOnAdapter()

    {

    delete iVConfigData;

    delete iTempVConfigData;

    delete iPdpCenrep;

    }

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

// CAlwaysOnAdapter::ItemCount

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

//

TInt CAlwaysOnAdapter::ItemCount() const

    {

    // SummaryTitle(), SummaryText(), SaveL(), SetAsDefaultL() and

    // CanSetAsDefault() are called ItemCount() times

    return iVConfigData ? 1 : 0;

    }

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

// CAlwaysOnAdapter::SummaryTitle

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

//

const TDesC16& CAlwaysOnAdapter::SummaryTitle( TInt /*aIndex*/ ) const

    {

    return KNullDesC();

    }

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

// CAlwaysOnAdapter::SummaryText

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

//

const TDesC16& CAlwaysOnAdapter::SummaryText( TInt /*aIndex*/ ) const

    {

    return KNullDesC();

    }

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

// CAlwaysOnAdapter::DetailsL

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

//

TInt CAlwaysOnAdapter::DetailsL( TInt /*aItem*/, MWPPairVisitor& /*aVisitor*/ )

    {

    // Detail view is a feature for later release.

    return KErrNotSupported;

    }

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

// CAlwaysOnAdapter::SaveL

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

//

void CAlwaysOnAdapter::SaveL( TInt /*aItem*/ )

    {

    FLOG( _L( "[Provisioning] CAlwaysOnAdapter::SaveL:" ) );

    __ASSERT_DEBUG( iVConfigData, User::Leave( KErrCorrupt ) );

    User::LeaveIfError( iPdpCenrep->Set( KPDPContextManagerEnableWhenHome,

        TInt( iVConfigData->iAwonPdpcHPLMN ) ) );

    User::LeaveIfError( iPdpCenrep->Set( KPDPContextManagerEnableWhenRoaming,

        TInt( iVConfigData->iAwonPdpcVPLMN ) ) );

    User::LeaveIfError( iPdpCenrep->Set( KPDPContextManagerRetryTimer,

        iVConfigData->iTRetry ) );

    FLOG( _L( "[Provisioning] CStreamingAdapter::SaveL: Done" ) );

    }

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

// CAlwaysOnAdapter::CanSetAsDefault

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

//

TBool CAlwaysOnAdapter::CanSetAsDefault( TInt /*aItem*/ ) const

    {

    return EFalse;

    }

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

// CAlwaysOnAdapter::SetAsDefault

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

//

void CAlwaysOnAdapter::SetAsDefaultL( TInt /*aItem*/ )

    {

    // This shouldn't be called because CanSetAsDefault

    // always returns EFalse.

    }

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

// CAlwaysOnAdapter::VisitL

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

//

void CAlwaysOnAdapter::VisitL( CWPCharacteristic& aCharacteristic )

    {

    switch( aCharacteristic.Type() )

        {

        case KWPVendorConfig:

            {

            // Init settings temporary storage

            InitTempVConfigL();

            // Accept characteristic

            aCharacteristic.AcceptL( *this );

            // Validate data

            if( IsVConfigValid() )

                {

                // data is valid -> assign it to member variable

                delete iVConfigData;

                iVConfigData = iTempVConfigData;

                iTempVConfigData = NULL;

                }

            else

                {

                // data is invalid

                delete iTempVConfigData;

                iTempVConfigData = NULL;

                }

            break;

            }

        default:

            break;

        }

    }

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

// CAlwaysOnAdapter::VisitL

//

//   Used to parse, the following always-on related provisioning settings

//

//   <characteristic type="VENDORCONFIG">

//          <parm name="NAME" value="MRBLOBBY"/>

//          <parm name="AWON-PDPC" value="11"/>

//          <parm name="T-RETRY" value="100"/>

//      </characteristic>

//   </characteristic>

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

//

void CAlwaysOnAdapter::VisitL( CWPParameter& aParameter )

    {

    switch( aParameter.ID() )

        {

        case EWPParameterName:

            iTempVConfigData->iName.Set( aParameter.Value() );

            break;

        case EWPNamedParameter:

            {

            if( aParameter.Name().Compare( KAlwaysOnAwonPdpcStr ) == 0 )

                {

                TInt awonPdpcTemp( KErrNotFound );

                ParseIntegerL( aParameter.Value(), awonPdpcTemp );

                ParseAwonPdpcValuesL( awonPdpcTemp );

                }

            else if( aParameter.Name().Compare( KAlwaysOnTRetryStr ) == 0 )

                {

                ParseIntegerL( aParameter.Value(), iTempVConfigData->iTRetry );

                }

            break;

            }

        default:

            break;

        }

    }

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

// CAlwaysOnAdapter::VisitLinkL

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

//

void CAlwaysOnAdapter::VisitLinkL( CWPCharacteristic& /*aCharacteristic*/ )

    {

    }

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

// CAlwaysOnAdapter::IsVConfigValid

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

//

TBool CAlwaysOnAdapter::IsVConfigValid()

    {

    TBool validity( ETrue );

    // Validity check:

    //

    // T-Retry must be >= 0

    //      ** 0 means infinity

    //      ** > 0 is retry timer value in seconds

    if( iTempVConfigData->iTRetry < 0 )

        {

        validity = EFalse;

        }

    // AWON-PDPC

    //      ** Allowed awon-pdpc values are speficied in the beginning of file

    // There is no need to validate AWON-PDPC because if parsing has succeeded

    // the values are inside correct range.

    return validity;

    }

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

// CAlwaysOnAdapter::InitTempVConfigL

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

//

void CAlwaysOnAdapter::InitTempVConfigL()

    {

    delete iTempVConfigData;

    iTempVConfigData = NULL;

    iTempVConfigData = new ( ELeave ) TAlwaysOnVConfigAdapterData;

    // Initialize iTempVConfigData's members

    iTempVConfigData->iName.Set( KNullDesC );

    TInt temp( 0 );

    User::LeaveIfError(

        iPdpCenrep->Get( KPDPContextManagerEnableWhenHome, temp ) );

    iTempVConfigData->iAwonPdpcHPLMN = TBool( temp );

    User::LeaveIfError(

        iPdpCenrep->Get( KPDPContextManagerEnableWhenRoaming, temp ) );

    iTempVConfigData->iAwonPdpcVPLMN = TBool( temp );

    User::LeaveIfError( iPdpCenrep->Get( KPDPContextManagerRetryTimer,

                                iTempVConfigData->iTRetry ) );

    }

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

// CAlwaysOnAdapter::ParseIntegerL

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

//

void CAlwaysOnAdapter::ParseIntegerL( const TDesC& aPtr, TInt& aInt )

    {

    TLex lex( aPtr );

    User::LeaveIfError( lex.Val( aInt ) );

    }

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

// CAlwaysOnAdapter::ParseAwonPdpcValuesL

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

//

void CAlwaysOnAdapter::ParseAwonPdpcValuesL( TInt aInt )

    {

    switch( aInt )

        {

        case KAwonPdpc_Off3G_Off2G:

            iTempVConfigData->iAwonPdpcHPLMN = EFalse;

            iTempVConfigData->iAwonPdpcVPLMN = EFalse;

            break;

        case KAwonPdpc_Off3G_On2G:

            iTempVConfigData->iAwonPdpcHPLMN = EFalse;

            iTempVConfigData->iAwonPdpcVPLMN = ETrue;

            break;

        case KAwonPdpc_On3G_Off2G:

            iTempVConfigData->iAwonPdpcHPLMN = ETrue;

            iTempVConfigData->iAwonPdpcVPLMN = EFalse;

            break;

        case KAwonPdpc_On3G_On2G:

            iTempVConfigData->iAwonPdpcHPLMN = ETrue;

            iTempVConfigData->iAwonPdpcVPLMN = ETrue;

            break;

        default:

            User::Leave( KErrNotSupported );

            break;

        }

    }

//  End of File