/*

* Copyright (c) 2006-2008 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 Vcc settings in provisioning.

*

*/

#include <e32base.h>

#include <commdb.h>

#include <CWPAdapter.h>

#include <CWPCharacteristic.h>

#include <CWPParameter.h>

#include <utf.h>

#include <wpvccadapterrsc.rsg>

#include <crcseprofileentry.h>

#include <crcseprofileregistry.h>

#include <WPAdapterUtil.h>

#include "wpvccadapter.h"

#include "rubydebug.h"

#include "vccspsettings.h"

#include "wpvccadapteruids.h"

#include <cch.h>

#include "vccsettingsreader.h"

#include <sipmanagedprofileregistry.h>

#include <sipprofile.h>

#include <spsettings.h>

#include <spproperty.h>

#include <cmmanagerext.h>

#include <cmdestinationext.h>

/** Name of *this adapter */

_LIT( KVccResourceFileNameWithoutSuffix,  "wpvccadapterrsc" );

/** Provisioning file format specific settings */

// OMA Experimental values, registered by OMNA only for advisory purposes

// range 0x4000 to 0x1FFFFF

_LIT( KVccAppID,        "w9054" );        

_LIT8( KVoIPAppID8,     "w9013" );  	  // OMA CP registration document for VoIP

_LIT( KVdi,             "VDI" );          // 

_LIT( KVdn,             "VDN" );          // 

_LIT( KPreferredDomain, "PREF-DOMAIN" );  // 

_LIT( KImmediateDT,     "IMMEDIATE-DOMAIN-TRANSFER" );   // 

_LIT( KDtCsToPsAllowed, "DT-CS-TO-PS-ALLOWED" );      // 

_LIT( KDtPsToCsAllowed, "DT-PS-TO-CS-ALLOWED" );     // 

_LIT( KDtHeldwaitingCallsAllowed, "DT-HELD-WAITING-CALLS-ALLOWED" );     // 

_LIT( KWlanHOTreshold, "WLAN-HO-THRESHOLD-VALUE" );

_LIT( KWlanHOHysteresis, "WLAN-HO-HYSTERESIS-VALUE" );

_LIT( KWlanHysteresisTimerLow, "WLAN-HYSTERESIS-TIMER-LOW" );

_LIT( KWlanHysteresisTimerHigh, "WLAN-HYSTERESIS-TIMER-HIGH" );

_LIT( KCSHOTreshold, "CS-HO-THRESHOLD-VALUE" );

_LIT( KCSHOHysteresis, "CS-HO-HYSTERESIS-VALUE" );

_LIT( KCSHysteresisTimerLow, "CS-HYSTERESIS-TIMER-LOW" );

_LIT( KCSHysteresisTimerHigh, "CS-HYSTERESIS-TIMER-HIGH" );

_LIT( KDtAllowedWhenCsOriginated, "DT-ALLOWED-WHEN-CS-ORIGINATED" );

_LIT16( KDefaultName, "VCC application settings" );

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

// ResetAndDestroyEntries

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

//

void ResetAndDestroyProfileEntries( TAny* anArray )

    {

    RPointerArray<CRCSEProfileEntry>* array =

        reinterpret_cast<RPointerArray<CRCSEProfileEntry>*>( anArray );

    if (array)

        {

        array->ResetAndDestroy();

        array->Close();

        }

    }

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

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

// C++ constructor

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

//

CWPVccAdapter::CWPVccAdapter() : CWPAdapter()

    {

    }

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

// Symbian 2nd phase constructor

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

//

void CWPVccAdapter::ConstructL()

    {

    RUBY_DEBUG_BLOCKL( "CWPVccAdapter::ConstructL" );

    TFileName fileName;

    // ReadHBufCL needs the path where the resource file is.

    // Actually, the WPAdapterUtil only uses the drive part of the string

    // (which is normally "z:")

    // The resource file name must not contain the suffix since it is

    // added.

    Dll::FileName( fileName );

    iTitle = WPAdapterUtil::ReadHBufCL(

        fileName, KVccResourceFileNameWithoutSuffix, R_QTN_SM_HEAD_VCC );

     }

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

// Constructor

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

//

CWPVccAdapter* CWPVccAdapter::NewL()

    {

    RUBY_DEBUG_BLOCKL( "CWPVccAdapter::NewL" );

    CWPVccAdapter* self = new( ELeave ) CWPVccAdapter;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// Destructor

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

//

CWPVccAdapter::~CWPVccAdapter()

    {

    RUBY_DEBUG0( "CWPVccAdapter::~CWPVccAdapter() - ENTER" );

    iToAppReferences.Close();

    delete iTitle;

    delete iAppID;

    delete iVccItem;

    delete iNewVccItem;

    RUBY_DEBUG0( "CWPVccAdapter::~CWPVccAdapter() - EXIT" );

    }

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

// Not currently supported.

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

//

TInt CWPVccAdapter::ContextExtension( MWPContextExtension*& /*aExtension*/ )

    {

    RUBY_DEBUG_BLOCK( "CWPVccAdapter::ContextExtension" );

    return KErrNotSupported;

    }

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

// Not currently supported.

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

//

const TDesC8& CWPVccAdapter::SaveDataL( TInt /*aIndex*/ ) const

    {

    RUBY_DEBUG_BLOCK( "CWPVccAdapter::SaveDataL" );

    User::Leave( KErrNotSupported );

    // Nothing returned cause we leave.

    return KNullDesC8;

    }

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

// Not currently supported.

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

//

void CWPVccAdapter::DeleteL( const TDesC8& /*aSaveData*/ )

    {

    RUBY_DEBUG_BLOCK( "CWPVccAdapter::DeleteL" );

    User::Leave( KErrNotSupported );

    }

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

// Returns UID of the adapter (*this).

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

//

TUint32 CWPVccAdapter::Uid() const

    {

    RUBY_DEBUG_BLOCK( "CWPVccAdapter::Uid" );

    return KProvisioningVccAdapterImplementationUid; //iDtor_ID_Key.iUid;

    }

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

// Used to query for the detail information about the Vcc profile.

// Not currently supported.

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

//

TInt CWPVccAdapter::DetailsL( TInt, MWPPairVisitor& )

    {

    RUBY_DEBUG_BLOCK( "CWPVccAdapter::DetailsL" );

    return KErrNotSupported;

    }

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

// Returns the amount of Vcc data items (always 1 if data got, otherwise 0).

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

//

TInt CWPVccAdapter::ItemCount() const

    {

    RUBY_DEBUG_BLOCK( "CWPVccAdapter::ItemCount" );

    return iVccItem ? 1 : 0;

    }

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

// Returns summary title of the Vcc profile received in configuration

// message.

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

//

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

    {

    RUBY_DEBUG_BLOCK( "CWPVccAdapter::SummaryTitle" );

    return *iTitle;

    }

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

// Returns summary text of the Vcc profile received in configuration

// message. Returns NULL descriptor if no settings received.

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

//

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

    {

    RUBY_DEBUG_BLOCK( "CWPVccAdapter::SummaryText" );

	if ( iVccItem )

	    {

	    RUBY_DEBUG0( "-vccitem Name" );

	    return iVccItem->ServiceName();

	    }

    else

        {

        RUBY_DEBUG0( " - default text NO ITEM!" );

        return KDefaultName;

        }

    }

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

// Saves Vcc item (whole profile). If no settings are received, leaves with

// errorcode KErrGeneral.

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

//

void CWPVccAdapter::SaveL( TInt /*aIndex*/ )

    {

    RUBY_DEBUG_BLOCK( "CWPVccAdapter::SaveL" );

    TRAP_IGNORE( RemoveVCCSettingsL() );

	// Lets do the saving when framework calls savingFinalisedL method

    }

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

// Tells if current profile can be set as a default profile. Since Vcc

// currently supports only single profile, return value is always false.

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

//

TBool CWPVccAdapter::CanSetAsDefault( TInt /*aIndex*/ ) const

    {

    RUBY_DEBUG_BLOCK( "CWPVccAdapter::CanSetAsDefault" );

    return EFalse;

    }

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

// Sets the Vcc item on place pointed by index given in parameter as default.

// Since Vcc currently supports only single profile and CanSetAsDefault method

// always returns false, this method should never be called. It is unsupported

// and does nothing. Derivation of this method is done only to fulfill the

// demands of s60 Coding conventions, Symbian OS, C++ and other entities

// setting boundaries for specific software as *this.

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

//

void CWPVccAdapter::SetAsDefaultL( TInt /*aIndex*/ )

    {

    RUBY_DEBUG_BLOCK( "CWPVccAdapter::SetAsDefaultL" );

    // This shouldn't be called because CanSetAsDefault

    // always returns EFalse

    User::Leave( KErrNotSupported );

    }

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

// This method is called by the provisioning framework to "visit" an adapter

// plugin (*this). Plugin then checks if the visiting aCharacteristic are

// of the particular type that this plugin wants to handle, and if so, it

// invites the visitor deeper in to more intimate series of visits through

// overloaded VisitL method with CWPParameter& visitor aboard.

// Generally this plugin is interested in two type of visitors, one called

// KWPApplication (carrying application level data), and other called

// KWPNapDef (carrying data needed to establish new IAPs).

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

//

void CWPVccAdapter::VisitL( CWPCharacteristic& aCharacteristic )

    {

    RUBY_DEBUG_BLOCK( "CWPVccAdapter::VisitL char" );

    switch ( aCharacteristic.Type() )

        {

        case KWPApplication:

            {

            RUBY_DEBUG0( " - KWPApplication create new item" );

            iNewVccItem = CVccSPSettings::NewL();

            iCurrentCharacteristicType = aCharacteristic.Type() ;

            aCharacteristic.AcceptL( *this );

            if( iAppID && *iAppID == KVccAppID )

                {

                RUBY_DEBUG0( "- VCC AppId used" );

                delete iVccItem;

                iVccItem = iNewVccItem;

                }

            else

                {

                delete iNewVccItem;

                }

            iNewVccItem = NULL;   

            }break;

        default:

            {

            }break;

        }

    }

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

// This "visit" method should be called by all params in CWPCharacteristic&

// visitors invited welcome in VisitL( CWPCharacteristic& ) overload. The

// information in visiting params are then stored to VccItem datastructure for

// future use.

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

//

void CWPVccAdapter::VisitL( CWPParameter& aParameter )

    {

    RUBY_DEBUG0( "VisitL param" );

    switch( aParameter.ID() )

        {

        case EWPParameterAppID:

            {

	        RUBY_DEBUG0( "- got EWPParameterAppID");

            delete iAppID; 

	        iAppID = NULL;

	        iAppID = aParameter.Value().AllocL();

            }break;

        case EWPNamedParameter:

            {

            RUBY_DEBUG0( "- got EWPNamedParameter populate VCC item" );

            if( !iNewVccItem )

                {

                RUBY_DEBUG0( "- NO VCC item " );

                return;

                }

            TPtrC value( aParameter.Value() );

            if ( aParameter.Name().Compare( KVdi )  == KErrNone )

                {

                RUBY_DEBUG1( "- got VDI:%S" , 

                             &value );

                iNewVccItem->SetVdiL( value );

                }

            else if ( aParameter.Name().Compare( KVdn )  == KErrNone  )

                {

                RUBY_DEBUG1( "- got VDN:%S" ,

                             &value );

#if defined( _DEBUG )                

                TInt val = aParameter.Name().Compare( KVdn );

                TBool valb (!val);

#endif                

                RUBY_DEBUG1( "- got val:%d", val );

                RUBY_DEBUG1( "- got valb:%d", valb );

                iNewVccItem->SetVdnL( value );

                }

            else if ( aParameter.Name().Compare( KPreferredDomain ) == KErrNone )

                {

                RUBY_DEBUG1( "- got Preferred Domain:%S" ,

                             &value );

                iNewVccItem->SetPreferredDomainL( value );

                }

            else if ( aParameter.Name().Compare( KImmediateDT )  == KErrNone  )

                {

                RUBY_DEBUG1( "- got Immediate DT:%S" , 

                            &value );

                iNewVccItem->SetImmediateDtL( value );

                }

            else if ( aParameter.Name().Compare( KDtCsToPsAllowed ) == KErrNone )

                {

                RUBY_DEBUG1( "- got DT from CS to PS allowed:%S" ,

                             &value );

                iNewVccItem->SetDtCsToPsAllowedL( value );

                }

            else if ( aParameter.Name().Compare( KDtPsToCsAllowed ) == KErrNone )

                {

                RUBY_DEBUG1( "- got DT from CS to PS allowed:%S" ,

                             &value );

                iNewVccItem->SetDtPsToCsAllowedL( value );

                }

            else if ( aParameter.Name().Compare( 

                            KDtHeldwaitingCallsAllowed )  == KErrNone )

                {

                RUBY_DEBUG1( "- got DT from CS to PS allowed:%S" ,

                             &value );

                iNewVccItem->SetDtHeldWaitingCallsAllowedL( value );

                }

            else if ( aParameter.Name().Compare( 

                            KWlanHOTreshold )  == KErrNone )

                {

                RUBY_DEBUG1( "- got DT from WLAN HO Treshold value:%S" ,

                             &value );

                iNewVccItem->SetDtWlanHoTresholdL( value );

                }

            else if ( aParameter.Name().Compare( 

                            KWlanHOHysteresis )  == KErrNone )

                {

                RUBY_DEBUG1( "- got DT from WLAN HO hysteresis value:%S" ,

                             &value );

                iNewVccItem->SetDtWlanHoHysteresisL( value );

                }

            else if ( aParameter.Name().Compare( 

                            KWlanHysteresisTimerLow )  == KErrNone )

                {

                RUBY_DEBUG1( "- got DT from WLAN Hysteresis timer low:%S" ,

                             &value );

                iNewVccItem->SetDtWlanHoHysteresisTimerLowL( value );

                }

            else if ( aParameter.Name().Compare( 

                            KWlanHysteresisTimerHigh )  == KErrNone )

                {

                RUBY_DEBUG1( "- got DT from WLAN Hysteresis timer high:%S" ,

                             &value );

                iNewVccItem->SetDtWlanHoHysteresisTimerHighL( value );

                }

            else if ( aParameter.Name().Compare( 

                            KCSHOTreshold )  == KErrNone )

                {

                RUBY_DEBUG1( "- got DT from CS HO Treshold value:%S" ,

                             &value );

                iNewVccItem->SetDtCsHoTresholdL( value );

                }

            else if ( aParameter.Name().Compare( 

                            KCSHOHysteresis )  == KErrNone )

                {

                RUBY_DEBUG1( "- got DT from CS HO hysteresis value:%S" ,

                             &value );

                iNewVccItem->SetDtCsHoHysteresisL( value );

                }

            else if ( aParameter.Name().Compare( 

                            KCSHysteresisTimerLow )  == KErrNone )

                {

                RUBY_DEBUG1( "- got DT from CS Hysteresis timer low:%S" ,

                             &value );

                iNewVccItem->SetDtCsHoHysteresisTimerLowL( value );

                }

            else if ( aParameter.Name().Compare( 

                            KCSHysteresisTimerHigh )  == KErrNone )

                {

                RUBY_DEBUG1( "- got DT from CS Hysteresis timer high:%S" ,

                             &value );

                iNewVccItem->SetDtCsHoHysteresisTimerHighL( value );

                }

            else if( aParameter.Name().Compare( 

                        KDtAllowedWhenCsOriginated )  == KErrNone )

                {

                RUBY_DEBUG1( "- got DT allowed when CS originated:%S" ,

                                             &value );

                iNewVccItem->SetDtAllowedWhenCsOriginated( value );

                }

            else

                {

                RUBY_DEBUG0( "- no such VCC param" );    

                }    

            break;

            }

        case EWPParameterProviderID: // APPLICATION/PROVIDER-ID

            {

            if( iNewVccItem != NULL )

                {

                RUBY_DEBUG0( "- got EWPParameterProviderID" );

                iNewVccItem->SetProviderIdL( aParameter.Value() );

                }

            } break;

        case EWPParameterName: // APPLICATION/NAME

            {

            if( iNewVccItem != NULL )

                {

                RUBY_DEBUG0( "- got EWPParameterName" );

                iNewVccItem->SetServiceNameL( aParameter.Value() );

                }

            } break;

        case EWPParameterToAppRef:

            {

            RUBY_DEBUG1("-got EWPParameterToAppRef: %S", &aParameter.Value());

            iToAppReferences.Append(aParameter.Value());

            break;

            }