/*

* Copyright (c) 2007 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:   Implementation file for nsmldmvccadapter

*

*/

#include <e32std.h>

#include <escapeutils.h>

#include <spentry.h>

#include <spproperty.h>

#include <nsmldmuri.h>

#include <crcseprofileentry.h>

#include <crcseprofileregistry.h>

#include "nsmldmvccadapter.h"

#include "vccspsettings.h"

#include "vccmiscutils.h"

#include "rubydebug.h"

const TInt KNSmlDMVCC_DefaultResultSize = 255;

/** VCC DDF keywords */

_LIT8( KNSmlDMVCC_DDFVersion,               "1.0" );

_LIT8( KNSmlDMVCC_Node,                     "VCC001" );

_LIT( KNSmlDMVCC_ServiceName,               "VCC" );

/** VCC */ 

_LIT8( KNSmlDMVCC_Name,                     "Name" );

_LIT8( KNSmlDMVCC_VDI,                      "VDI" );

_LIT8( KNSmlDMVCC_VDN,                      "VDN" );

_LIT8( KNSmlDMVCC_PreferredDomain,          "Preferred Domain" );

_LIT8( KNSmlDMVCC_ImmediateDT,              "Immediate DT" );

_LIT8( KNSmlDMVCC_DTCsToIM,                 "DT CS-to-IM CN direction" );

_LIT8( KNSmlDMVCC_DTIMToCs,                 "DT IM CN-to-CS direction" );

_LIT8( KNSmlDMVCC_DTHeldWaitingCalls,       "DT in held_waiting calls" );

_LIT8( KNSmlDMVCC_WlanHOTreshold, 			"WLAN HO Treshold" );

_LIT8( KNSmlDMVCC_WlanHOHysteresis,			"WLAN HO Hysteresis" );

_LIT8( KNSmlDMVCC_WlanHysteresisTimerLow, 	"WLAN Hysteresis Timer Low" );

_LIT8( KNSmlDMVCC_WlanHysteresisTimerHigh, 	"WLAN Hysteresis Timer High" );

_LIT8( KNSmlDMVCC_CSHOTreshold, 			"CS HO Treshold" );

_LIT8( KNSmlDMVCC_CSHOHysteresis, 			"CS HO Hysteresis" );

_LIT8( KNSmlDMVCC_CSHysteresisTimerLow,		"CS Hysteresis Timer Low" );

_LIT8( KNSmlDMVCC_CSHysteresisTimerHigh, 	"CS Hysteresis Timer High" );

_LIT8( KNSmlDMVCC_VoipServiceId, 			"VoIP" );

_LIT8( KNSmlDMVCC_DtAllowedWhenCsOriginated,"DT Allowed When CS Originated" );

_LIT8( KNSmlDMVCC_NodeExp,                  "Main node for VCC settings" );

_LIT8( KNSmlDMVCC_NameExp,                  "Name for the Communication Continuity settings" );

_LIT8( KNSmlDMVCC_VDIExp,                   "VCC Transfer URI " );

_LIT8( KNSmlDMVCC_VDNExp,                   "VCC Transfer Number" );

_LIT8( KNSmlDMVCC_PreferredDomainExp,       "Preferred domain for UE originated calls/sessions" );

_LIT8( KNSmlDMVCC_ImmediateDTExp,           "Initiate a VCC DT immediately when domain available or not" );

_LIT8( KNSmlDMVCC_DTCsToIMExp,              "DT from CS domain to PS is restricted or not" );

_LIT8( KNSmlDMVCC_DTIMToCsExp,              "DT from PS domain to CS is restricted or not" );

_LIT8( KNSmlDMVCC_DTHeldWaitingCallsExp,    "DT restricted during active and a held/waiting call/session" );

_LIT8( KNSmlDMVCC_WlanHOTresholdExp, 		"Handover signal strength treshold value for WLAN" );

_LIT8( KNSmlDMVCC_WlanHOHysteresisExp,		"Handover hysteresis value for WLAN" );

_LIT8( KNSmlDMVCC_WlanHysteresisTimerLowExp,"Handover hysteresis timer value for WLAN used below treshold" );

_LIT8( KNSmlDMVCC_WlanHysteresisTimerHighExp, 	"Handover hysteresis timer value for WLAN used above treshold" );

_LIT8( KNSmlDMVCC_CSHOTresholdExp, 			"Handover signal strength treshold value for CS" );

_LIT8( KNSmlDMVCC_CSHOHysteresisExp, 		"Handover hysteresis value for CS" );

_LIT8( KNSmlDMVCC_CSHysteresisTimerLowExp,	"Handover hysteresis timer value for CS used below treshold" );

_LIT8( KNSmlDMVCC_CSHysteresisTimerHighExp, "Handover hysteresis timer value for CS used above treshold" );

_LIT8( KNSmlDMVCC_VoipServiceIdExp, 		"VoIP Service Id to be associated with VCC" );

_LIT8( KNSmlDMVCC_DmToConRef, 				"ToConRef" );

_LIT8( KNSmlDMVCC_DmConRef, 				"ConRef" );

_LIT8( KNSmlDMVCC_DmToConRefExp, 			"Refers to a collection of connectivity definitions" );

_LIT8( KNSmlDMVCC_DmConRefExp,		 		"Indicates the linkage to connectivity parameters" );

_LIT8( KNSmlDMVCC_DmVoipLinkPrefix, 			"./VoIP");

_LIT8( KNSmlDMVCC_DmVoipId,					"VoIPId");

_LIT8( KNSmlDMVCC_DmVoip,					"VoIP");

_LIT( KVccServiceName,               		"VCC" );

/** Others */

_LIT8( KNSmlDMVCCTextPlain,                 "text/plain" );

_LIT8( KNSmlDMVCCSeparator,                 "/" );

_LIT( KNSmlDMVCCValueNullDesc,              "" );

_LIT( KNSmlDMVCCValueZero,                 "0" );

const TInt KNSmlDMVCCSeparatorChar            = '/';

const TInt KNSmlDMVCCDefaultResultSize        = 64;

const TInt KNSmlDMVCCMaxResultLength          = 256;

const TInt  KNSmlDMVCCMaxUriLength            = 100;

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

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

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

// C++ Constructor

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

//

CNSmlDmVCCAdapter::CNSmlDmVCCAdapter( TAny* aEcomArguments )

: CSmlDmAdapter( aEcomArguments )

    {

    RUBY_DEBUG_BLOCK( "CNSmlDmVCCAdapter::CNSmlDmVCCAdapter" );

    }

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

// Second phase constructor

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

//

void CNSmlDmVCCAdapter::ConstructL()

    {

    RUBY_DEBUG_BLOCKL( "CNSmlDmVCCAdapter::ConstructL" );

    iVCCSettings = CVccSPSettings::NewL();

    iVCCSettings->SetServiceNameL( KNSmlDMVCC_ServiceName );

    iVCCSettings->ReadSettingsL( KVccServiceName );

    }

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

// Two-phased constructor

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

//

CNSmlDmVCCAdapter* CNSmlDmVCCAdapter::NewL( MSmlDmCallback* aDmCallback )

    {

    RUBY_DEBUG_BLOCKL( "CNSmlDmVCCAdapter::NewL" );

    CNSmlDmVCCAdapter* self = CNSmlDmVCCAdapter::NewLC( aDmCallback );

    CleanupStack::Pop( self );

    return self;

    }

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

// Two-phased constructor

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

//

CNSmlDmVCCAdapter* CNSmlDmVCCAdapter::NewLC( MSmlDmCallback* aDmCallback )

    {

    RUBY_DEBUG0( "CNSmlDmVCCAdapter::NewLC --Start" );

    CNSmlDmVCCAdapter* self = new( ELeave ) CNSmlDmVCCAdapter( aDmCallback );

    CleanupStack::PushL( self );

    self->ConstructL();

    RUBY_DEBUG0( "CNSmlDmVCCAdapter::NewLC --End" );

    return self;

    }

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

// Destructor

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

//

CNSmlDmVCCAdapter::~CNSmlDmVCCAdapter()

    {

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

    delete iVCCSettings;

    delete iTempBuf;

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

    }

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

//  

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

//

void CNSmlDmVCCAdapter::DDFVersionL( CBufBase& aVersion )

    {

    RUBY_DEBUG_BLOCK( "CNSmlDmVCCAdapter::DDFVersionL" );

    aVersion.InsertL( 0,KNSmlDMVCC_DDFVersion );

    }

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

//  

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

//

void CNSmlDmVCCAdapter::DDFStructureL( MSmlDmDDFObject& aDDF )

    {

    RUBY_DEBUG_BLOCK( "CNSmlDmVCCAdapter::DDFStructureL" );

    TSmlDmAccessTypes accessTypesGet;

    accessTypesGet.SetGet();

    TSmlDmAccessTypes accessTypesGetReplace;

    accessTypesGetReplace.SetGet();

    accessTypesGetReplace.SetReplace();

    // Main node

    MSmlDmDDFObject& vccNode = aDDF.AddChildObjectL( KNSmlDMVCC_Node );

    vccNode.SetAccessTypesL( accessTypesGet );

    vccNode.SetOccurenceL( MSmlDmDDFObject::EOneOrMore );

    vccNode.SetScopeL( MSmlDmDDFObject::EPermanent );

    vccNode.SetDFFormatL( MSmlDmDDFObject::ENode );

    vccNode.SetDescriptionL( KNSmlDMVCC_NodeExp );

    // Name leaf -read only

    MSmlDmDDFObject& vccName = vccNode.AddChildObjectL( KNSmlDMVCC_Name );    

    vccName.SetAccessTypesL( accessTypesGet );

    vccName.SetOccurenceL( MSmlDmDDFObject::EZeroOrMore );

    vccName.SetScopeL( MSmlDmDDFObject::EPermanent );

    vccName.SetDFFormatL( MSmlDmDDFObject::EChr );

    vccName.AddDFTypeMimeTypeL( KNSmlDMVCCTextPlain );

    vccName.SetDescriptionL( KNSmlDMVCC_NameExp );

    // VDI leaf

    MSmlDmDDFObject& vccVDI = vccNode.AddChildObjectL( KNSmlDMVCC_VDI );    

    vccVDI.SetAccessTypesL( accessTypesGetReplace );

    vccVDI.SetOccurenceL( MSmlDmDDFObject::EOne );

    vccVDI.SetScopeL( MSmlDmDDFObject::EPermanent );

    vccVDI.SetDFFormatL( MSmlDmDDFObject::EChr );

    vccVDI.SetDescriptionL( KNSmlDMVCC_VDIExp );

    // VDN leaf

    MSmlDmDDFObject& vccVDN = vccNode.AddChildObjectL( KNSmlDMVCC_VDN );

    vccVDN.SetAccessTypesL( accessTypesGetReplace );

    vccVDN.SetOccurenceL( MSmlDmDDFObject::EOne );

    vccVDN.SetScopeL( MSmlDmDDFObject::EPermanent );

    vccVDN.SetDFFormatL( MSmlDmDDFObject::EChr );

    vccVDN.SetDescriptionL( KNSmlDMVCC_VDNExp );

    // Preferred domain leaf

    MSmlDmDDFObject& vccPD = 

                          vccNode.AddChildObjectL( KNSmlDMVCC_PreferredDomain );

    vccPD.SetAccessTypesL( accessTypesGetReplace );

    vccPD.SetOccurenceL( MSmlDmDDFObject::EOne );

    vccPD.SetScopeL( MSmlDmDDFObject::EPermanent );

    vccPD.SetDFFormatL( MSmlDmDDFObject::EChr );

    vccPD.AddDFTypeMimeTypeL( KNSmlDMVCCTextPlain );

    vccPD.SetDescriptionL( KNSmlDMVCC_PreferredDomainExp );

    // Immediate DT leaf

    MSmlDmDDFObject& vccIDT = vccNode.AddChildObjectL( KNSmlDMVCC_ImmediateDT );

    vccIDT.SetAccessTypesL( accessTypesGetReplace );

    vccIDT.SetOccurenceL( MSmlDmDDFObject::EOne );

    vccIDT.SetScopeL( MSmlDmDDFObject::EPermanent );

    vccIDT.SetDFFormatL( MSmlDmDDFObject::EChr );

    vccIDT.AddDFTypeMimeTypeL( KNSmlDMVCCTextPlain );

    vccIDT.SetDescriptionL( KNSmlDMVCC_ImmediateDTExp );

    // CS to PS leaf

    MSmlDmDDFObject& vccDTCS = vccNode.AddChildObjectL( KNSmlDMVCC_DTCsToIM );

    vccDTCS.SetAccessTypesL( accessTypesGetReplace );

    vccDTCS.SetOccurenceL( MSmlDmDDFObject::EOne );

    vccDTCS.SetScopeL( MSmlDmDDFObject::EPermanent );

    vccDTCS.SetDFFormatL( MSmlDmDDFObject::EChr );

    vccDTCS.AddDFTypeMimeTypeL( KNSmlDMVCCTextPlain );

    vccDTCS.SetDescriptionL( KNSmlDMVCC_DTCsToIMExp );

    // PS to CS leaf

    MSmlDmDDFObject& vccDTIM = vccNode.AddChildObjectL( KNSmlDMVCC_DTIMToCs );

    vccDTIM.SetAccessTypesL( accessTypesGetReplace );

    vccDTIM.SetOccurenceL( MSmlDmDDFObject::EOne );

    vccDTIM.SetScopeL( MSmlDmDDFObject::EPermanent );

    vccDTIM.SetDFFormatL( MSmlDmDDFObject::EChr );

    vccDTIM.AddDFTypeMimeTypeL( KNSmlDMVCCTextPlain );

    vccDTIM.SetDescriptionL( KNSmlDMVCC_DTIMToCsExp );

    // DT restricted while held or waiting calls leaf

    MSmlDmDDFObject& vccDTHeld = 

                       vccNode.AddChildObjectL( KNSmlDMVCC_DTHeldWaitingCalls );

    vccDTHeld.SetAccessTypesL( accessTypesGetReplace );

    vccDTHeld.SetOccurenceL( MSmlDmDDFObject::EOne );

    vccDTHeld.SetScopeL( MSmlDmDDFObject::EPermanent );

    vccDTHeld.SetDFFormatL( MSmlDmDDFObject::EChr );

    vccDTHeld.AddDFTypeMimeTypeL( KNSmlDMVCCTextPlain );

    vccDTHeld.SetDescriptionL( KNSmlDMVCC_DTHeldWaitingCallsExp );

    // DT Allowed when CS Originated Call

    MSmlDmDDFObject& vccDTAllowedWhenCsOrig = 

               vccNode.AddChildObjectL( KNSmlDMVCC_DtAllowedWhenCsOriginated );

    vccDTAllowedWhenCsOrig.SetAccessTypesL( accessTypesGetReplace );

    vccDTAllowedWhenCsOrig.SetOccurenceL( MSmlDmDDFObject::EOne );

    vccDTAllowedWhenCsOrig.SetScopeL( MSmlDmDDFObject::EPermanent );

    vccDTAllowedWhenCsOrig.SetDFFormatL( MSmlDmDDFObject::EChr );

    vccDTAllowedWhenCsOrig.AddDFTypeMimeTypeL( KNSmlDMVCCTextPlain );

    vccDTAllowedWhenCsOrig.SetDescriptionL( KNSmlDMVCC_DtAllowedWhenCsOriginated );

    // WLAN HO treshold leaf

    MSmlDmDDFObject& vccWLANHotreshold = 

                       vccNode.AddChildObjectL( KNSmlDMVCC_WlanHOTreshold );

    vccWLANHotreshold.SetAccessTypesL( accessTypesGetReplace );

    vccWLANHotreshold.SetOccurenceL( MSmlDmDDFObject::EOne );

    vccWLANHotreshold.SetScopeL( MSmlDmDDFObject::EPermanent );

    vccWLANHotreshold.SetDFFormatL( MSmlDmDDFObject::EChr );

    vccWLANHotreshold.AddDFTypeMimeTypeL( KNSmlDMVCCTextPlain );

    vccWLANHotreshold.SetDescriptionL( KNSmlDMVCC_WlanHOTresholdExp );

    // WLAN HO hysteresis leaf

    MSmlDmDDFObject& vccWLANHoHysteresis = 

                       vccNode.AddChildObjectL( KNSmlDMVCC_WlanHOHysteresis );

    vccWLANHoHysteresis.SetAccessTypesL( accessTypesGetReplace );

    vccWLANHoHysteresis.SetOccurenceL( MSmlDmDDFObject::EOne );

    vccWLANHoHysteresis.SetScopeL( MSmlDmDDFObject::EPermanent );

    vccWLANHoHysteresis.SetDFFormatL( MSmlDmDDFObject::EChr );

    vccWLANHoHysteresis.AddDFTypeMimeTypeL( KNSmlDMVCCTextPlain );

    vccWLANHoHysteresis.SetDescriptionL( KNSmlDMVCC_WlanHOHysteresisExp );

    // WLAN HO hysteresis timer low leaf

    MSmlDmDDFObject& vccWLANHoHysteresisTimerLow = 

                       vccNode.AddChildObjectL( KNSmlDMVCC_WlanHysteresisTimerLow );

    vccWLANHoHysteresisTimerLow.SetAccessTypesL( accessTypesGetReplace );

    vccWLANHoHysteresisTimerLow.SetOccurenceL( MSmlDmDDFObject::EOne );

    vccWLANHoHysteresisTimerLow.SetScopeL( MSmlDmDDFObject::EPermanent );

    vccWLANHoHysteresisTimerLow.SetDFFormatL( MSmlDmDDFObject::EChr );

    vccWLANHoHysteresisTimerLow.AddDFTypeMimeTypeL( KNSmlDMVCCTextPlain );

    vccWLANHoHysteresisTimerLow.SetDescriptionL( KNSmlDMVCC_WlanHysteresisTimerLowExp );

    // WLAN HO hysteresis timer high leaf

    MSmlDmDDFObject& vccWLANHoHysteresisTimerHigh = 

                       vccNode.AddChildObjectL( KNSmlDMVCC_WlanHysteresisTimerHigh );

    vccWLANHoHysteresisTimerHigh.SetAccessTypesL( accessTypesGetReplace );

    vccWLANHoHysteresisTimerHigh.SetOccurenceL( MSmlDmDDFObject::EOne );

    vccWLANHoHysteresisTimerHigh.SetScopeL( MSmlDmDDFObject::EPermanent );

    vccWLANHoHysteresisTimerHigh.SetDFFormatL( MSmlDmDDFObject::EChr );

    vccWLANHoHysteresisTimerHigh.AddDFTypeMimeTypeL( KNSmlDMVCCTextPlain );

    vccWLANHoHysteresisTimerHigh.SetDescriptionL( KNSmlDMVCC_WlanHysteresisTimerHighExp );

    // CS HO treshold leaf

    MSmlDmDDFObject& vccCSHotreshold = 

                       vccNode.AddChildObjectL( KNSmlDMVCC_CSHOTreshold );

    vccCSHotreshold.SetAccessTypesL( accessTypesGetReplace );

    vccCSHotreshold.SetOccurenceL( MSmlDmDDFObject::EOne );

    vccCSHotreshold.SetScopeL( MSmlDmDDFObject::EPermanent );

    vccCSHotreshold.SetDFFormatL( MSmlDmDDFObject::EChr );

    vccCSHotreshold.AddDFTypeMimeTypeL( KNSmlDMVCCTextPlain );

    vccCSHotreshold.SetDescriptionL( KNSmlDMVCC_CSHOTresholdExp );

    // CS HO hysteresis leaf

    MSmlDmDDFObject& vccCSHoHysteresis = 

                       vccNode.AddChildObjectL( KNSmlDMVCC_CSHOHysteresis );

    vccCSHoHysteresis.SetAccessTypesL( accessTypesGetReplace );

    vccCSHoHysteresis.SetOccurenceL( MSmlDmDDFObject::EOne );

    vccCSHoHysteresis.SetScopeL( MSmlDmDDFObject::EPermanent );

    vccCSHoHysteresis.SetDFFormatL( MSmlDmDDFObject::EChr );

    vccCSHoHysteresis.AddDFTypeMimeTypeL( KNSmlDMVCCTextPlain );

    vccCSHoHysteresis.SetDescriptionL( KNSmlDMVCC_CSHOHysteresisExp );

    // CS HO hysteresis timer low leaf

    MSmlDmDDFObject& vccCSHoHysteresisTimerLow = 

                       vccNode.AddChildObjectL( KNSmlDMVCC_CSHysteresisTimerLow );

    vccCSHoHysteresisTimerLow.SetAccessTypesL( accessTypesGetReplace );

    vccCSHoHysteresisTimerLow.SetOccurenceL( MSmlDmDDFObject::EOne );

    vccCSHoHysteresisTimerLow.SetScopeL( MSmlDmDDFObject::EPermanent );

    vccCSHoHysteresisTimerLow.SetDFFormatL( MSmlDmDDFObject::EChr );

    vccCSHoHysteresisTimerLow.AddDFTypeMimeTypeL( KNSmlDMVCCTextPlain );

    vccCSHoHysteresisTimerLow.SetDescriptionL( KNSmlDMVCC_CSHysteresisTimerLowExp );

    // CS HO hysteresis timer high leaf

    MSmlDmDDFObject& vccCSHoHysteresisTimerHigh = 

                       vccNode.AddChildObjectL( KNSmlDMVCC_CSHysteresisTimerHigh );

    vccCSHoHysteresisTimerHigh.SetAccessTypesL( accessTypesGetReplace );

    vccCSHoHysteresisTimerHigh.SetOccurenceL( MSmlDmDDFObject::EOne );

    vccCSHoHysteresisTimerHigh.SetScopeL( MSmlDmDDFObject::EPermanent );

    vccCSHoHysteresisTimerHigh.SetDFFormatL( MSmlDmDDFObject::EChr );

    vccCSHoHysteresisTimerHigh.AddDFTypeMimeTypeL( KNSmlDMVCCTextPlain );

    vccCSHoHysteresisTimerHigh.SetDescriptionL( KNSmlDMVCC_CSHysteresisTimerHighExp );

    // ./VCC001/ToConRef/

    MSmlDmDDFObject& toConRefNode = vccNode.AddChildObjectL(KNSmlDMVCC_DmToConRef);

    toConRefNode.SetAccessTypesL( accessTypesGet );

    toConRefNode.SetOccurenceL( MSmlDmDDFObject::EOne );

    toConRefNode.SetScopeL( MSmlDmDDFObject::EDynamic );

    toConRefNode.SetDFFormatL( MSmlDmDDFObject::ENode );

    toConRefNode.SetDescriptionL( KNSmlDMVCC_DmToConRefExp );

    // ./VCC001/ToConRef/VoIP

    MSmlDmDDFObject& voipNode = toConRefNode.AddChildObjectL( KNSmlDMVCC_VoipServiceId );

    voipNode.SetAccessTypesL( accessTypesGet );

    voipNode.SetOccurenceL( MSmlDmDDFObject::EOne );

    voipNode.SetScopeL( MSmlDmDDFObject::EDynamic );

    voipNode.SetDFFormatL( MSmlDmDDFObject::ENode );

    voipNode.SetDescriptionL( KNSmlDMVCC_VoipServiceIdExp );

    // ./VCC001/ToConRef/VoIP/ConRef

    MSmlDmDDFObject& conRefVoipNode = voipNode.AddChildObjectL(KNSmlDMVCC_DmConRef);

    conRefVoipNode.SetAccessTypesL( accessTypesGetReplace );

    conRefVoipNode.SetOccurenceL( MSmlDmDDFObject::EOne );

    conRefVoipNode.SetScopeL( MSmlDmDDFObject::EDynamic );

    conRefVoipNode.SetDFFormatL( MSmlDmDDFObject::EChr );

    conRefVoipNode.SetDescriptionL( KNSmlDMVCC_DmConRefExp );

    // !NOTE! Ext node not inserted yet

  }

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

//  Note: HBufC* buf points to member iTempBuf that is deleted every time 

//  ConvertToUnicodeL is called and in class' destructor.

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

//

void CNSmlDmVCCAdapter::UpdateLeafObjectL( const TDesC8& aURI, 

            const TDesC8& /*aLUID*/, const TDesC8& aObject, 

            const TDesC8& /*aType*/, TInt aStatusRef )

    {

    RUBY_DEBUG_BLOCK( "CNSmlDmVCCAdapter::UpdateLeafObjectL" );

  	RUBY_DEBUG0( "ReadSPSettings" );

  	iVCCSettings->ReadSettingsL( KVccServiceName );

    CSmlDmAdapter::TError retValue = CSmlDmAdapter::EOk;

    HBufC* buf = ConvertToUnicodeL( aObject );

    // Find the last leaf in URI

    TPtrC8 uriSeg( LastURISeg( aURI ) );

    if ( KNSmlDMVCC_Name() == uriSeg )

        {

        // Don't do anything at the moment

        //iVCCSettings->SetNameL( aObject );

        }

    else if ( KNSmlDMVCC_VDI() == uriSeg )

        {

        if ( KErrNone != iVCCSettings->SetVdiL( buf->Des() ) )

            {

            retValue = CSmlDmAdapter::EInvalidObject;

            }

        }

    else if ( KNSmlDMVCC_VDN() == uriSeg )

        {

        if ( !( iVCCSettings->SetVdnL( buf->Des() ) ) )

            {

            retValue = CSmlDmAdapter::EInvalidObject;

            }

        }

    else if ( KNSmlDMVCC_PreferredDomain() == uriSeg )

        {

        TInt value = iVCCSettings->ConvertToIntL( buf->Des() );

        switch ( value )

            {

            case 0:

            case 1:

            case 2:

            case 3:

                iVCCSettings->SetPreferredDomainL( buf->Des() );

                break;

            default:

                retValue = CSmlDmAdapter::EInvalidObject;

                break;

          }

        }

    else if ( KNSmlDMVCC_ImmediateDT() == uriSeg )

        {

        TInt value = iVCCSettings->ConvertToIntL( buf->Des() );

        switch ( value )

            {

            case 0:

            case 1:

                iVCCSettings->SetImmediateDtL( buf->Des() );

                break;

            default:

                retValue = CSmlDmAdapter::EInvalidObject;

                break;

            }

        }

    else if ( KNSmlDMVCC_DTCsToIM() == uriSeg )

        {

        TInt value = iVCCSettings->ConvertToIntL( buf->Des() );

        switch ( value )

            {

            case 0:

            case 1:

                iVCCSettings->SetDtCsToPsAllowedL( buf->Des() );

                break;

            default:

                retValue = CSmlDmAdapter::EInvalidObject;

                break;

            }

        }

    else if ( KNSmlDMVCC_DTIMToCs() == uriSeg )

        {

        TInt value = iVCCSettings->ConvertToIntL( buf->Des() );

        switch ( value )

            {

            case 0:

            case 1:

                iVCCSettings->SetDtPsToCsAllowedL( buf->Des() );

                break;

            default:

                retValue = CSmlDmAdapter::EInvalidObject;

                break;

            }

        }

    else if ( KNSmlDMVCC_DtAllowedWhenCsOriginated() == uriSeg )

        {

        TInt value = iVCCSettings->ConvertToIntL( buf->Des() );

        switch ( value )

            {

            case 0:

            case 1:

                iVCCSettings->SetDtAllowedWhenCsOriginated( buf->Des() );

                break;

            default:

                retValue = CSmlDmAdapter::EInvalidObject;

                break;

            }

        }

    else if ( KNSmlDMVCC_DTHeldWaitingCalls() == uriSeg )

        {

        TInt value = iVCCSettings->ConvertToIntL( buf->Des() );

        switch ( value )

            {

            case 0:

            case 1:

                iVCCSettings->SetDtHeldWaitingCallsAllowedL( buf->Des() );

                break;

            default:

                retValue = CSmlDmAdapter::EInvalidObject;

                break;

            }

        }

    else if ( KNSmlDMVCC_WlanHOTreshold() == uriSeg )

        {