/*

* Copyright (c) 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:  Device Management General VoIP Settings Adapter

*

*/

#include <utf.h>

#include <implementationproxy.h> // For TImplementationProxy definition

#include <sysutil.h>

#include <e32property.h>

#include <centralrepository.h>

#include <crcseprofileentry.h>

#include <crcseprofileregistry.h>

#include <settingsinternalcrkeys.h>

#include <featmgr.h>

#include "NSmlDmGeneralVoIPSettingsAdapter.h"

#include "nsmlconstants.h"

#include "nsmldmconstants.h"

#include "nsmldmconst.h"

const TUint KNSmlDMGenVoIPAdapterImplUid = 0x10275413;

const TInt  KNSmlGenVoIPMaxResultLength  = 256;

const TInt  KNSmlGenVoIPMaxUriLength     = 100;

const TInt  KDefaultResultSize           = 64;

const TInt  KTwoSegs                     = 2;

const TInt  KMaxUriLength                = 64;

// Reference: OMA_Device_Management_DDF_for_General_VoIP_Settings

_LIT8( KNSmlDMGenVoIPDDFVersion,            "0.1" );

_LIT8( KNSmlDMGenVoIPNodeName,              "GenVoIP" );

_LIT8( KNSmlDMVoIPNodeName,                 "VoIP" );

_LIT8( KNSmlDMGenVoIPClir,                  "Clir" );

_LIT8( KNSmlDMGenVoIPAnonCallBlockRule,     "AnonCallBlockRule" );

_LIT8( KNSmlDMGenVoIPPreferredTelephony,    "PrefTelephony" );

_LIT8( KNSmlDMGenVoIPDoNotDisturb,          "DoNotDisturb" );

_LIT8( KNSmlDMGenVoIPPSCallWaiting,         "PSCallWaiting" );

_LIT8( KNSmlDMGenVoIPProfileId,             "VoIPProfileId" );

_LIT8( KNSmlDMGenVoIPNodeNameExp,           "Main node for General VoIP settings" );

_LIT8( KNSmlDMGenVoIPClirExp,               "Calling Line Identification Restriction" );

_LIT8( KNSmlDMGenVoIPPSCallWaitingExp,      "PS call waiting" );

_LIT8( KNSmlDMGenVoIPAnonCallBlockRuleExp,  "Anonymous call blocking rule" );

_LIT8( KNSmlDMGenVoIPPreferredTelephonyExp, "Preferred telephony" );

_LIT8( KNSmlDMGenVoIPDoNotDisturbExp,       "Do not disturb" );

_LIT8( KNSmlDMGenVoIPProfileIdExp,          "VoIP node id for linking" );

// Other

_LIT8( KNSmlDMGenVoIPTextPlain,             "text/plain" );

_LIT8( KNSmlDMGenVoIPSeparator,             "/" );

_LIT8( KNSmlDMGenVoIPUriDotSlash,           "./");

_LIT8( KVoipId,                             "VoIPId" );

//MACROS 

#define KNSMLDMURISEPARATORDEF '/'

// Following lines are for enabling debug prints.

#ifdef _DEBUG

#define _DBG_FILE(p) RDebug::Print(_L(p))

#define _DBG_FILE2(p,a) RDebug::Print(_L(p),a)

#else

#define _DBG_FILE(p)

#define _DBG_FILE2(p,a)

#endif // _DEBUG

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

template <class T>

inline void CleanupResetAndDestroy<T>::PushL(T& aRef)

	{CleanupStack::PushL(TCleanupItem(&ResetAndDestroy,&aRef));}

template <class T>

void CleanupResetAndDestroy<T>::ResetAndDestroy(TAny *aPtr)

	{(STATIC_CAST(T*,aPtr))->ResetAndDestroy();}

template <class T>

inline void CleanupResetAndDestroyL(T& aRef)

	{CleanupResetAndDestroy<T>::PushL(aRef);}

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

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

// CNSmlDmGeneralVoIPSettingsAdapter::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CNSmlDmGeneralVoIPSettingsAdapter::ConstructL()

    {

    _DBG_FILE( "CNSmlDmGeneralVoIPSettingsAdapter::ConstructL(): begin" );

    // Check VoIP support from feature manager

    FeatureManager::InitializeLibL();

    TBool support = FeatureManager::FeatureSupported( KFeatureIdCommonVoip );

    FeatureManager::UnInitializeLib();

    if( !support )

        {

        _DBG_FILE( 

            "CNSmlDmGeneralVoIPSettingsAdapter::ConstructL(): no support" );

        User::Leave( KErrNotSupported );

        }

    _DBG_FILE( "CNSmlDmGeneralVoIPSettingsAdapter::ConstructL(): end" );

    }

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

// CNSmlDmGeneralVoIPSettingsAdapter* CNSmlDmGeneralVoIPSettingsAdapter::NewL

// Two-phased constructor.

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

//

CNSmlDmGeneralVoIPSettingsAdapter* CNSmlDmGeneralVoIPSettingsAdapter::NewL( 

    MSmlDmCallback* aDmCallback )

    {

    _DBG_FILE( "CNSmlDmGeneralVoIPSettingsAdapter::NewL(): begin" );

    CNSmlDmGeneralVoIPSettingsAdapter* self = NewLC( aDmCallback );

    CleanupStack::Pop( self );

    _DBG_FILE( "CNSmlDmGeneralVoIPSettingsAdapter::NewL(): end" );

    return self;

    }

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

// CNSmlDmGeneralVoIPSettingsAdapter* CNSmlDmGeneralVoIPSettingsAdapter::NewLC

// Two-phased constructor.

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

//

CNSmlDmGeneralVoIPSettingsAdapter* CNSmlDmGeneralVoIPSettingsAdapter::NewLC( 

    MSmlDmCallback* aDmCallback )

    {

    _DBG_FILE( "CNSmlDmGeneralVoIPSettingsAdapter::NewLC(): begin" );

    CNSmlDmGeneralVoIPSettingsAdapter* self = 

        new ( ELeave ) CNSmlDmGeneralVoIPSettingsAdapter( aDmCallback );

    CleanupStack::PushL( self );

    self->ConstructL();

    self->iDmCallback = aDmCallback;

    _DBG_FILE( "CNSmlDmGeneralVoIPSettingsAdapter::NewLC(): end" );

    return self;

    }

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

// CNSmlDmGeneralVoIPSettingsAdapter::~CNSmlDmGeneralVoIPSettingsAdapter()

// Destructor

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

//

CNSmlDmGeneralVoIPSettingsAdapter::~CNSmlDmGeneralVoIPSettingsAdapter()

    {

    _DBG_FILE( "CNSmlDmGeneralVoIPSettingsAdapter::~CNSmlDmGeneralVoIPSettingsAdapter(): begin" );

    _DBG_FILE( "CNSmlDmGeneralVoIPSettingsAdapter::~CNSmlDmGeneralVoIPSettingsAdapter(): end" );

    }

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

// CNSmlDmGeneralVoIPSettingsAdapter::CNSmlDmGeneralVoIPSettingsAdapter

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

//

CNSmlDmGeneralVoIPSettingsAdapter::CNSmlDmGeneralVoIPSettingsAdapter(

    TAny* aEcomArguments ):CSmlDmAdapter( aEcomArguments )

    {

    _DBG_FILE( "CNSmlDmGeneralVoIPSettingsAdapter::CNSmlDmGeneralVoIPSettingsAdapter( aEcomArguments ): begin" );

    iEntry.iAreSettingsLoaded = EFalse;

    _DBG_FILE( "CNSmlDmGeneralVoIPSettingsAdapter::CNSmlDmGeneralVoIPSettingsAdapter( aEcomArguments ): end" ); 

    }

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

// CNSmlDmGeneralVoIPSettingsAdapter::FetchObjectL

// Fetches the values of leaf objects.

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

//

CSmlDmAdapter::TError CNSmlDmGeneralVoIPSettingsAdapter::FetchObjectL( 

    const TDesC8& aURI, 

    CBufBase& aResult )

    {

    _DBG_FILE( "CNSmlDmGeneralVoIPSettingsAdapter::FetchObjectL(): begin" );

    CSmlDmAdapter::TError status = CSmlDmAdapter::EError;

    TBuf8< KNSmlGenVoIPMaxResultLength > segmentResult;

    TPtrC8 lastURISeg = LastURISeg( aURI );

    TPtrC8 uriTmp = RemoveLastURISeg( aURI );

    TPtrC8 secondLastURISeg = LastURISeg( uriTmp );

    if ( !( iEntry.iAreSettingsLoaded ) )

        {

        TInt err = LoadSettingsL();

        if ( KErrNone != err )

            {

            return status;

            }

        }

    if ( 0 == secondLastURISeg.Compare( KNSmlDMGenVoIPNodeName() )

        && KTwoSegs == NumOfURISegs( aURI ) )

        {

        status = CSmlDmAdapter::EOk;

        // Clir

        if ( KNSmlDMGenVoIPClir() == lastURISeg )

            {

            segmentResult.Num( iEntry.iClir );

            }

        // AnonCallBlockRule

        else if ( KNSmlDMGenVoIPAnonCallBlockRule() == lastURISeg )

            {

            segmentResult.Num( iEntry.iACBRule );

            }

        // PreferredTelephony

        else if ( KNSmlDMGenVoIPPreferredTelephony() == lastURISeg )

            {

            segmentResult.Num( iEntry.iPrefTel );

            }

        // DoNotDisturb

        else if ( KNSmlDMGenVoIPDoNotDisturb() == lastURISeg )

            {

            segmentResult.Num( iEntry.iDnd );

            }

        // PSCallWaiting

        else if ( KNSmlDMGenVoIPPSCallWaiting() == lastURISeg )

            {

            segmentResult.Num( iEntry.iPSCallWaiting );

            }

        // ProfileName

        else if ( KNSmlDMGenVoIPProfileId() == lastURISeg )

            {

            segmentResult.Copy( iEntry.iVoipProfileId );

            }

        else

            {

            status = CSmlDmAdapter::ENotFound;

            }

        }

    else

        {

        status = CSmlDmAdapter::ENotFound;

        }

    if ( CSmlDmAdapter::EOk == status )    

        {

        aResult.InsertL( aResult.Size(), segmentResult );

        }

    _DBG_FILE( "CNSmlDmGeneralVoIPSettingsAdapter::FetchObjectL(): end" );

    return status;

    }

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

// CNSmlDmGeneralVoIPSettingsAdapter::LoadSettingsL

// Loads general VoIP settings from Central Repository.

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

//

TInt CNSmlDmGeneralVoIPSettingsAdapter::LoadSettingsL()

    {

    _DBG_FILE( "CNSmlDmGeneralVoIPSEttingsAdapter::LoadSettingsL(): begin" );

    CRepository* cRepository = CRepository::NewLC( KCRUidRichCallSettings );

    TInt err( KErrNone );

    err = cRepository->Get( KRCSEClir, iEntry.iClir );

    if ( KErrNone == err )

        {

        err = cRepository->Get( KRCSEAnonymousCallBlockRule,

            iEntry.iACBRule );

        }

    if ( KErrNone == err )

        {

        err = cRepository->Get( KRCSEPreferredTelephony, iEntry.iPrefTel );

        }

    if ( KErrNone == err )

        {

        err = cRepository->Get( KRCSEDoNotDisturb, iEntry.iDnd );

        }

    if ( KErrNone == err )

        {

        err = cRepository->Get( KRCSPSCallWaiting, iEntry.iPSCallWaiting );

        }

    if ( KErrNone == err )

        {

        err = ResolvePreferredServiceNameL( *cRepository );

        }

    if ( KErrNone == err )

        {

        iEntry.iAreSettingsLoaded = ETrue;

        }

    CleanupStack::PopAndDestroy( cRepository );

    _DBG_FILE( "CNSmlDmGeneralVoIPSEttingsAdapter::LoadSettingsL(): end" );

    return err;

    }

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

// CNSmlDmGeneralVoIPSettingsAdapter::DesToInt

// Converts a 8 bit descriptor to int.

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

//

TInt CNSmlDmGeneralVoIPSettingsAdapter::DesToInt( 

    const TDesC8& aDes )

    {

    TLex8 lex( aDes );

    TInt value( 0 );

    lex.Val( value );

    return value;

    }

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

// CNSmlDmGeneralVoIPSettingsAdapter::RemoveLastURISeg

// returns parent uri, i.e. removes last uri segment

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

//

TPtrC8 CNSmlDmGeneralVoIPSettingsAdapter::RemoveLastURISeg( 

    const TDesC8& aURI )

    {

    TInt counter( 0 );

    // Check that aURI exists

    if ( 0 < aURI.Length() )

        {

        for ( counter = aURI.Length() - 1; counter >= 0; counter-- )

            {

            if ( KNSMLDMURISEPARATORDEF == aURI[ counter ] )

                {

                break;

                }

            }

        }

    return aURI.Left( counter );

    }

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

// CNSmlDmGeneralVoIPSettingsAdapter::NumOfURISegs

// For getting the number of uri segs

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

//

TInt CNSmlDmGeneralVoIPSettingsAdapter::NumOfURISegs( 

    const TDesC8& aURI )

    {

    TInt numOfURISegs( 1 );

    for ( TInt counter = 0; counter < aURI.Length(); counter++ )

        {

        if ( KNSMLDMURISEPARATORDEF == aURI[ counter ] )

            {

            numOfURISegs++;

            }

        }

    return numOfURISegs;

    }

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

// CNSmlDmGeneralVoIPSettingsAdapter::LastURISeg

// Returns only the last uri segment

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

//

TPtrC8 CNSmlDmGeneralVoIPSettingsAdapter::LastURISeg( 

    const TDesC8& aURI ) const

    {

    _DBG_FILE( "CNSmlDmGeneralVoIPSettingsAdapter::LastURISeg() : begin" );

    TInt counter( 0 );

    // Check that aURI exists

    if ( 0 < aURI.Length() )

        {

        for ( counter = aURI.Length() - 1; counter >= 0; counter-- )

            {

            if ( KNSMLDMURISEPARATORDEF == aURI[ counter ] )

                {

                break;

                }

            }

        }

    _DBG_FILE( "CNSmlDmGeneralVoIPSettingsAdapter::LastURISeg() : end" );

    if ( 0 == counter  )

        {

        return aURI;

        }

    else

        {

        return aURI.Mid( counter + 1 );

        }

    }

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

// CNSmlDmGeneralVoIPSettingsAdapter::RemoveDotSlash

// return uri without dot and slash in start

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

//

TPtrC8 CNSmlDmGeneralVoIPSettingsAdapter::RemoveDotSlash( 

    const TDesC8& aURI )

    {

    if ( 0 == aURI.Find( KNSmlDMGenVoIPUriDotSlash ) )

        {

        return aURI.Right( 

            aURI.Length() - KNSmlDMGenVoIPUriDotSlash().Length() );

        }

    else

        {

        return aURI;

        }

    }

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

// CNSmlDmGeneralVoIPSettingsAdapter::DDFVersionL

// From base class CNSmlDmAdapter.

// Inserts DDF version of the adapter to aDDFVersion

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

//

void CNSmlDmGeneralVoIPSettingsAdapter::DDFVersionL(

    CBufBase& aDDFVersion )

    {

    _DBG_FILE( "CNSmlDmGeneralVoIPSettingsAdapter::DDFVersionL( TDes& aDDFVersion): begin" );

    aDDFVersion.InsertL( 0, KNSmlDMGenVoIPDDFVersion );

    _DBG_FILE( "CNSmlDmGeneralVoIPSettingsAdapter::DDFVersionL( TDes& aDDFVersion): end" );

    }

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

// CNSmlDmGeneralVoIPSettingsAdapter::DDFStructureL

// From base class CNSmlDmAdapter.

// Builds the DDF structure of adapter

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

//

void CNSmlDmGeneralVoIPSettingsAdapter::DDFStructureL( MSmlDmDDFObject& aDDF )

    {

    _DBG_FILE("CNSmlDmGeneralVoIPSettingsAdapter::DDFStructureL(): begin");

    TSmlDmAccessTypes accessTypesGet;

    accessTypesGet.SetGet();

    TSmlDmAccessTypes accessTypesGetAdd;

    accessTypesGetAdd.SetGet();

    accessTypesGetAdd.SetAdd();

    TSmlDmAccessTypes accessTypesGetReplaceAdd;

    accessTypesGetReplaceAdd.SetGet();

    accessTypesGetReplaceAdd.SetReplace();

    accessTypesGetReplaceAdd.SetAdd();

    TSmlDmAccessTypes accessTypesAll;

    accessTypesAll.SetGet();

    accessTypesAll.SetDelete();

    accessTypesAll.SetAdd();

    accessTypesAll.SetReplace();

    // GenVoIP

    MSmlDmDDFObject& genVoIP = aDDF.AddChildObjectL( KNSmlDMGenVoIPNodeName );

    genVoIP.SetAccessTypesL( accessTypesGet );

    genVoIP.SetOccurenceL( MSmlDmDDFObject::EOne );

    genVoIP.SetScopeL( MSmlDmDDFObject::EPermanent );

    genVoIP.SetDFFormatL( MSmlDmDDFObject::ENode );

    genVoIP.AddDFTypeMimeTypeL( KNSmlDMGenVoIPTextPlain );

    genVoIP.SetDescriptionL( KNSmlDMGenVoIPNodeNameExp );

    // Clir

    MSmlDmDDFObject& clir = genVoIP.AddChildObjectL( KNSmlDMGenVoIPClir );

    clir.SetAccessTypesL( accessTypesGetReplaceAdd );

    clir.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne );

    clir.SetScopeL( MSmlDmDDFObject::EDynamic );

    clir.SetDFFormatL( MSmlDmDDFObject::EInt );

    clir.AddDFTypeMimeTypeL( KNSmlDMGenVoIPTextPlain );

    clir.SetDescriptionL( KNSmlDMGenVoIPClirExp );

    // AnonCallBlockRule

    MSmlDmDDFObject& acbRule = genVoIP.AddChildObjectL( 

        KNSmlDMGenVoIPAnonCallBlockRule );

    acbRule.SetAccessTypesL( accessTypesGetReplaceAdd );

    acbRule.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne );

    acbRule.SetScopeL( MSmlDmDDFObject::EDynamic );

    acbRule.SetDFFormatL( MSmlDmDDFObject::EInt );

    acbRule.AddDFTypeMimeTypeL( KNSmlDMGenVoIPTextPlain );

    acbRule.SetDescriptionL( KNSmlDMGenVoIPAnonCallBlockRuleExp );

    // PreferredTelephony

    MSmlDmDDFObject& prefTel = genVoIP.AddChildObjectL( 

        KNSmlDMGenVoIPPreferredTelephony );

    prefTel.SetAccessTypesL( accessTypesGetReplaceAdd );

    prefTel.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne );

    prefTel.SetScopeL( MSmlDmDDFObject::EDynamic );

    prefTel.SetDFFormatL( MSmlDmDDFObject::EInt );

    prefTel.AddDFTypeMimeTypeL( KNSmlDMGenVoIPTextPlain );

    prefTel.SetDescriptionL( KNSmlDMGenVoIPPreferredTelephonyExp );

    // DoNotDisturb

    MSmlDmDDFObject& dnd = genVoIP.AddChildObjectL( 

        KNSmlDMGenVoIPDoNotDisturb );

    dnd.SetAccessTypesL( accessTypesGetReplaceAdd );

    dnd.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne );

    dnd.SetScopeL( MSmlDmDDFObject::EDynamic );

    dnd.SetDFFormatL( MSmlDmDDFObject::EInt );

    dnd.AddDFTypeMimeTypeL( KNSmlDMGenVoIPTextPlain );

    dnd.SetDescriptionL( KNSmlDMGenVoIPDoNotDisturbExp );

    // PSCallWaiting

    MSmlDmDDFObject& psCallWaiting = genVoIP.AddChildObjectL( 

        KNSmlDMGenVoIPPSCallWaiting );

    psCallWaiting.SetAccessTypesL( accessTypesGetReplaceAdd );

    psCallWaiting.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne );

    psCallWaiting.SetScopeL( MSmlDmDDFObject::EDynamic );

    psCallWaiting.SetDFFormatL( MSmlDmDDFObject::EInt );

    psCallWaiting.AddDFTypeMimeTypeL( KNSmlDMGenVoIPTextPlain );

    psCallWaiting.SetDescriptionL( KNSmlDMGenVoIPPSCallWaitingExp );

    // ProfileName

    MSmlDmDDFObject& voipProfileId = genVoIP.AddChildObjectL(

        KNSmlDMGenVoIPProfileId );

    voipProfileId.SetAccessTypesL( accessTypesGetReplaceAdd );

    voipProfileId.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne );

    voipProfileId.SetScopeL( MSmlDmDDFObject::EDynamic );

    voipProfileId.SetDFFormatL( MSmlDmDDFObject::EChr );

    voipProfileId.AddDFTypeMimeTypeL( KNSmlDMGenVoIPTextPlain );

    voipProfileId.SetDescriptionL( KNSmlDMGenVoIPProfileIdExp );

    _DBG_FILE("CNSmlDmGeneralVoIPSettingsAdapter::DDFStructureL(): end");

    }

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

// CNSmlDmGeneralVoIPSettingsAdapter::UpdateLeafObjectL

// From base class CNSmlDmAdapter.

// Updates value of a leaf object

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

//

void CNSmlDmGeneralVoIPSettingsAdapter::UpdateLeafObjectL( 

    const TDesC8& aURI, 

    const TDesC8& /*aLUID*/, 

    const TDesC8& aObject, 

    const TDesC8& /*aType*/, 

    const TInt aStatusRef )

    {

    _DBG_FILE( "CNSmlDmGeneralVoIPSettingsAdapter::UpdateLeafObjectL(): begin" );