/*

*  Name        : nsmldmstreamingadapter.cpp

*  Part of     : nsmldmstreamingadapter

*  Interface   : ecom / SmlDmAdapter

*

* Copyright (c) 2009 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 of dm adapters

* 	This is part of omadmextensions.

*

*/

//INCLUDE FILES

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

#include <centralrepository.h>

#include <commdb.h>

#include <cdbcols.h>             // CommsDB columname defs

#include <ApUtils.h>

#include <e32base.h>

#include <e32std.h>

#include <e32const.h>

#include <mpsettingsmodel.h>

#include <e32msgqueue.h>

#include "nsmldebug.h"

#include "nsmlconstants.h"

#include "nsmldmconst.h"

#include "nsmlstreamingadapter.h"

#include "nsmldmiapmatcher.h"

#include "streamingadapterCRKeys.h"

#ifndef __WINS__

// This lowers the unnecessary compiler warning (armv5) to remark.

// "Warning:  #174-D: expression has no effect..." is caused by 

// DBG_ARGS8 macro in no-debug builds.

#pragma diag_remark 174

#endif

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

// CNSmlDmStreamingAdapter* CNSmlDmStreamingAdapter::NewL( )

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

CNSmlDmStreamingAdapter* CNSmlDmStreamingAdapter::NewL(MSmlDmCallback* aDmCallback )

    {

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

    CNSmlDmStreamingAdapter* self = NewLC( aDmCallback );

    CleanupStack::Pop();

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

    return self;

    }

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

// CNSmlDmStreamingAdapter* CNSmlDmStreamingAdapter::NewLC( )

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

CNSmlDmStreamingAdapter* CNSmlDmStreamingAdapter::NewLC(MSmlDmCallback* aDmCallback )

    {

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

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

    CleanupStack::PushL(self);

    self->ConstructL();

    self->iDmCallback = aDmCallback;

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

    return self;

    }

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

// CNSmlDmStreamingAdapter::~CNSmlDmStreamingAdapter()

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

CNSmlDmStreamingAdapter::~CNSmlDmStreamingAdapter()

    {

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

    if(iModel)

        delete iModel;

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

    }

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

// CNSmlDmStreamingAdapter::CNSmlDmStreamingAdapter()

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

CNSmlDmStreamingAdapter::CNSmlDmStreamingAdapter(TAny* aEcomArguments):CSmlDmAdapter(aEcomArguments)

    {

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

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

    }

void CNSmlDmStreamingAdapter::ConstructL()

    {

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

        if ( !iModel )

                {

                RImplInfoPtrArray impl; 

                CleanupStack::PushL( TCleanupItem( Cleanup, &impl ) );

                CMPSettingsModel::ListImplementationsL( impl );

                if( impl.Count() > 0 )

                    {

                    _DBG_FILE("CStreamingAdapter::ConstructL: Creating CMPSettingsModel");

                    // using the first available implementation

                    iModel= CMPSettingsModel::NewL( impl[0]->ImplementationUid() );

                    _DBG_FILE("CStreamingAdapter::ConstructL: Creating CMPSettingsModel Done" );

                    }

                CleanupStack::PopAndDestroy(); // implArray

                // Load default values

                //iModel->LoadSettingsL(EConfigDefault);

                }

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

    }

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

// CNSmlDmStreamingAdapter::SetLeafPropertiesL()

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

void CNSmlDmStreamingAdapter::SetLeafPropertiesL( MSmlDmDDFObject& aObject, 

                                                const TSmlDmAccessTypes& aAccessTypes, 

                                                const TDesC8& aDescription ) const

    {

    aObject.SetAccessTypesL( aAccessTypes );

    aObject.SetScopeL( MSmlDmDDFObject::EPermanent );

    aObject.SetDFFormatL( MSmlDmDDFObject::EChr );

    aObject.AddDFTypeMimeTypeL( KNSmlDMStreamingAdapterTextPlain );

    aObject.SetDescriptionL( aDescription );

    }

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

//  CNSmlDmStreamingAdapter::DDFVersionL()

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

void CNSmlDmStreamingAdapter::DDFVersionL(CBufBase& aDDFVersion)

    {

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

    aDDFVersion.InsertL(0,KNSmlDMStreamingAdapterDDFVersion);

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

    }

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

//  CNSmlDmStreamingAdapter::DDFStructureL()

//

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

void CNSmlDmStreamingAdapter::DDFStructureL( MSmlDmDDFObject& aDDF )

    {

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

    TSmlDmAccessTypes accessTypes;

    accessTypes.SetGet();

    TSmlDmAccessTypes accessNoDeleteTypes;

    accessNoDeleteTypes.SetGet();

    accessNoDeleteTypes.SetReplace();

    _DBG_FILE("CNSmlDmStreamingAdapter::DDFStructureL(): Creating Node KNSmlDMStreamingAdapterNodeName");

    MSmlDmDDFObject& dmStreamingAdap = aDDF.AddChildObjectL( KNSmlDMStreamingAdapterNodeName );

    dmStreamingAdap.SetAccessTypesL( accessTypes ); 

    dmStreamingAdap.SetScopeL( MSmlDmDDFObject::EPermanent );

    dmStreamingAdap.SetDescriptionL( KNSmlDMStreamingAdapterDescription );

  	_DBG_FILE("CNSmlDmStreamingAdapter::DDFStructureL(): Creating Node KNSmlDMStreamingAdapterName");

    MSmlDmDDFObject& confName = dmStreamingAdap.AddChildObjectL(KNSmlDMStreamingAdapterName);

    FillNodeInfoL(  confName, 

                    accessNoDeleteTypes,

                    MSmlDmDDFObject::EOne,

                    MSmlDmDDFObject::EPermanent,

                    MSmlDmDDFObject::EChr,

                    KNSmlDMStreamingAdapterNameDescription );

    _DBG_FILE("CNSmlDmStreamingAdapter::DDFStructureL(): Creating Node KNSmlDMStreamingAdapterToProxy");

    MSmlDmDDFObject& toProxyID = dmStreamingAdap.AddChildObjectL(KNSmlDMStreamingAdapterToProxy);

    FillNodeInfoL(  toProxyID, 

                    accessNoDeleteTypes,

                    MSmlDmDDFObject::EOne,

                    MSmlDmDDFObject::EPermanent,

                    MSmlDmDDFObject::EChr,

                    KNSmlDMStreamingAdapterToProxyDescription );

    _DBG_FILE("CNSmlDmStreamingAdapter::DDFStructureL(): Creating Node KNSmlDMStreamingAdapterToNapID");

    MSmlDmDDFObject& toNapID = dmStreamingAdap.AddChildObjectL(KNSmlDMStreamingAdapterToNapID);

    FillNodeInfoL(  toNapID, 

                    accessNoDeleteTypes,

                    MSmlDmDDFObject::EOne,

                    MSmlDmDDFObject::EPermanent,

                    MSmlDmDDFObject::EChr,

                    KNSmlDMStreamingAdapterToNapIDDescription );

    _DBG_FILE("CNSmlDmStreamingAdapter::DDFStructureL(): Creating Node KNSmlDMStreamingAdapterNetInfo");

    MSmlDmDDFObject& netInfo = dmStreamingAdap.AddChildObjectL(KNSmlDMStreamingAdapterNetInfo);

    FillNodeInfoL(  netInfo, 

                    accessTypes,

                    MSmlDmDDFObject::EOne,

                    MSmlDmDDFObject::EPermanent,

                    MSmlDmDDFObject::ENode,

                    KNSmlDMStreamingAdapterNetInfo );

    _DBG_FILE("CNSmlDmStreamingAdapter::DDFStructureL(): Creating Node KNSmlDMStreamingAdapterNetInfoGPRS");

    MSmlDmDDFObject& netInfoGPRS = netInfo.AddChildObjectL(KNSmlDMStreamingAdapterNetInfoGPRS);

    FillNodeInfoL(  netInfoGPRS, 

                    accessNoDeleteTypes,

                    MSmlDmDDFObject::EOne,

                    MSmlDmDDFObject::EPermanent,

                    MSmlDmDDFObject::EChr,

                    KNSmlDMStreamingAdapterNetInfo );

    _DBG_FILE("CNSmlDmStreamingAdapter::DDFStructureL(): Creating Node KNSmlDMStreamingAdapterNetInfoEGPRS");

    MSmlDmDDFObject& netInfoEGPRS = netInfo.AddChildObjectL(KNSmlDMStreamingAdapterNetInfoEGPRS);

    FillNodeInfoL(  netInfoEGPRS, 

                    accessNoDeleteTypes,

                    MSmlDmDDFObject::EOne,

                    MSmlDmDDFObject::EPermanent,

                    MSmlDmDDFObject::EChr,

                    KNSmlDMStreamingAdapterNetInfo );

    _DBG_FILE("CNSmlDmStreamingAdapter::DDFStructureL(): Creating Node KNSmlDMStreamingAdapterNetInfoWCDMA");

    MSmlDmDDFObject& netInfoWCDMA = netInfo.AddChildObjectL(KNSmlDMStreamingAdapterNetInfoWCDMA);

    FillNodeInfoL(  netInfoWCDMA, 

                    accessNoDeleteTypes,

                    MSmlDmDDFObject::EOne,

                    MSmlDmDDFObject::EPermanent,

                    MSmlDmDDFObject::EChr,

                    KNSmlDMStreamingAdapterNetInfo );

    _DBG_FILE("CNSmlDmStreamingAdapter::DDFStructureL(): Creating Node KNSmlDMStreamingAdapterNetInfoCDMA2000");

    MSmlDmDDFObject& netInfoCDMA2000 = netInfo.AddChildObjectL(KNSmlDMStreamingAdapterNetInfoCDMA2000);

    FillNodeInfoL(  netInfoCDMA2000, 

                    accessNoDeleteTypes,

                    MSmlDmDDFObject::EOne,

                    MSmlDmDDFObject::EPermanent,

                    MSmlDmDDFObject::EChr,

                    KNSmlDMStreamingAdapterNetInfo );

    _DBG_FILE("CNSmlDmStreamingAdapter::DDFStructureL(): Creating Node KNSmlDMStreamingAdapterNetInfoWLAN");

    MSmlDmDDFObject& netInfoWLAN = netInfo.AddChildObjectL(KNSmlDMStreamingAdapterNetInfoWLAN);

    FillNodeInfoL(  netInfoWLAN, 

                    accessNoDeleteTypes,

                    MSmlDmDDFObject::EOne,

                    MSmlDmDDFObject::EPermanent,

                    MSmlDmDDFObject::EChr,

                    KNSmlDMStreamingAdapterNetInfo );

    _DBG_FILE("CNSmlDmStreamingAdapter::DDFStructureL(): Creating Node KNSmlDMStreamingAdapterNetInfoCDMA");

    MSmlDmDDFObject& netInfoCDMA = netInfo.AddChildObjectL(KNSmlDMStreamingAdapterNetInfoCDMA);

    FillNodeInfoL(  netInfoCDMA, 

                    accessNoDeleteTypes,

                    MSmlDmDDFObject::EOne,

                    MSmlDmDDFObject::EPermanent,

                    MSmlDmDDFObject::EChr,

                    KNSmlDMStreamingAdapterNetInfo );

    _DBG_FILE("CNSmlDmStreamingAdapter::DDFStructureL(): Creating Node KNSmlDMStreamingAdapterNetInfoHSDPA");

    MSmlDmDDFObject& netInfoHSDPA = netInfo.AddChildObjectL(KNSmlDMStreamingAdapterNetInfoHSDPA);

    FillNodeInfoL(  netInfoHSDPA, 

                    accessNoDeleteTypes,

                    MSmlDmDDFObject::EOne,

                    MSmlDmDDFObject::EPermanent,

                    MSmlDmDDFObject::EChr,

                    KNSmlDMStreamingAdapterNetInfo );

    _DBG_FILE("CNSmlDmStreamingAdapter::DDFStructureL(): Creating Node KNSmlDMStreamingAdapterMinUdpPort");

    MSmlDmDDFObject& minUdpPort = dmStreamingAdap.AddChildObjectL(KNSmlDMStreamingAdapterMinUdpPort);

    FillNodeInfoL(  minUdpPort, 

                    accessNoDeleteTypes,

                    MSmlDmDDFObject::EOne,

                    MSmlDmDDFObject::EPermanent,

                    MSmlDmDDFObject::EInt,

                    KNSmlDMStreamingAdapterMinUdpPortDescription );

    _DBG_FILE("CNSmlDmStreamingAdapter::DDFStructureL(): Creating Node KNSmlDMStreamingAdapterMaxUdpPort");

    MSmlDmDDFObject& maxUdpPort = dmStreamingAdap.AddChildObjectL(KNSmlDMStreamingAdapterMaxUdpPort);

    FillNodeInfoL(  maxUdpPort, 

                    accessNoDeleteTypes,

                    MSmlDmDDFObject::EOne,

                    MSmlDmDDFObject::EPermanent,

                    MSmlDmDDFObject::EInt,

                    KNSmlDMStreamingAdapterMaxUdpPortDescription );

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

    }

void CNSmlDmStreamingAdapter::SetNetInfoL(const TDesC8& aObject,const TDesC8 &aDes,TDataBearer aBearer,const TInt aStatusRef,const TInt aMnMaxBw, const TInt aMxMaxBw,const TInt aMnSusBw,const TInt aMxSusBw)

	{

	TInt aSusBw;

  TInt aMaxBw;

  TLex8 aConv;      

  TInt err;

  //aConv = aObject;

  TInt ret = aObject.Locate(KCommaSep()[0]);

  TInt ret1 = aObject.LocateReverse(KCommaSep()[0]);

  TInt len = aObject.Length() - (ret1 + 1);

  TPtrC8 segment1 = aObject.Right( len );

  aConv = segment1;

  TPtrC8 firstSeg = aObject.Left( ret );

  if(firstSeg.Compare(aDes))

      {

            DBG_ARGS8(_S8("CNSmlDmStreamingAdapter::SetNetInfoL() - %d:  Error in SetMaxBandwidth"), aBearer);

      iDmCallback->SetStatusL( aStatusRef, CSmlDmAdapter::EInvalidObject);

      return;

      }

  err = aConv.Val(aMaxBw);

  if(err != KErrNone)

      {

            DBG_ARGS8(_S8("CNSmlDmStreamingAdapter::SetNetInfoL() - %d: Error in Conversion"), aBearer);

      iDmCallback->SetStatusL( aStatusRef, CSmlDmAdapter::EError);

      return;

      }

  if(aMaxBw > 0)

  	{

  	err = iModel->SetMaxBandwidth(aMaxBw,aBearer);

  	}

  else

  	{

  	_DBG_FILE("CNSmlDmStreamingAdapter::UpdateLeafObjectL(): Error in SetMaxBandwidth");

    iDmCallback->SetStatusL( aStatusRef, CSmlDmAdapter::EError);

    return;

    }

  if(err != KErrNone)

      {

      DBG_ARGS8(_S8("CNSmlDmStreamingAdapter::SetNetInfoL() - %d: Error in SetMaxBandwidth"), aBearer);

      iDmCallback->SetStatusL( aStatusRef, CSmlDmAdapter::EError);

      return;

      //return retValue;

      }

  TBuf8<KMaxLengthTempInfo> aSusBf;

  for(TInt i = (ret+1); i < (ret1); i++)

      {

      aSusBf.Append(aObject[i]);

      }

  aConv = aSusBf;

  err = aConv.Val(aSusBw);

  if(err != KErrNone)

      {

            DBG_ARGS8(_S8("CNSmlDmStreamingAdapter::SetNetInfoL() - %d: Error in Conversion"), aBearer);

      iDmCallback->SetStatusL( aStatusRef, CSmlDmAdapter::EError);

      return;

      }

  if(aSusBw > 0)

  	{

  	err = iModel->SetSustainBandwidth(aSusBw,aBearer);

  	}

  else

  	{

  	_DBG_FILE("CNSmlDmStreamingAdapter::UpdateLeafObjectL(): Error in SetSustainBandwidth");

    iDmCallback->SetStatusL( aStatusRef, CSmlDmAdapter::EError);

    return;

    }

    if(err != KErrNone)

		    {

		    DBG_ARGS8(_S8("CNSmlDmStreamingAdapter::SetNetInfoL() - %d: Error in SetSustainBandwidth"), aBearer);

		    iDmCallback->SetStatusL( aStatusRef, CSmlDmAdapter::EError);

		    return;

		    }

    if(aMaxBw > aMxMaxBw || aMaxBw < aMnMaxBw)

  	    {

        DBG_ARGS8(_S8("CNSmlDmStreamingAdapter::SetNetInfoL() - %d: Error Invalid aMaxBw"), aBearer);

        iDmCallback->SetStatusL( aStatusRef, CSmlDmAdapter::EError);

        return;

        }

    if(aSusBw > aMxSusBw || aSusBw < aMnSusBw)

        {

        DBG_ARGS8(_S8("CNSmlDmStreamingAdapter::SetNetInfoL() - %d: Error Invalid aSusBw"), aBearer);

        iDmCallback->SetStatusL( aStatusRef, CSmlDmAdapter::EError);

        return;

        }

  iModel->StoreSettingsL();

  iDmCallback->SetStatusL( aStatusRef, CSmlDmAdapter::EOk);

	}

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

//  CNSmlDmStreamingAdapter::UpdateLeafObjectL()

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

void CNSmlDmStreamingAdapter::UpdateLeafObjectL( const TDesC8& aURI, 

                                               const TDesC8& aLUID, 

                                               const TDesC8& aObject, 

                                               const TDesC8& aType, 

                                               const TInt aStatusRef )

    {

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

		//CSmlDmAdapter::TError retValue = CSmlDmAdapter::EOk;

    TInt ret = aURI.LocateReverse(KNSmlURISeparator()[0]);

    if ( ret == KErrNotFound ) 

        {

        //retValue = CSmlDmAdapter::EError;

        iDmCallback->SetStatusL( aStatusRef, CSmlDmAdapter::EError );

        }

    else

        {

        //iDmCallback->SetStatusL( aStatusRef, CSmlDmAdapter::EOk );

        TInt len = aURI.Length() - (ret + 1);

        TPtrC8 segment = aURI.Right( len );

        if(segment == KNSmlDMStreamingAdapterName)

            {

            	// Set for Streaming Configuration Name

            _DBG_FILE("CNSmlDmStreamingAdapter::UpdateLeafObjectL(): KNSmlDMStreamingAdapterName");

            TBuf<KMaxLengthStreamingName> aBuf;

            TInt aErr;

            CRepository* centrep( NULL);

            aBuf.Zero();

            if(aObject.Length() <= KMaxLengthStreamingName)

               {

            aBuf.Copy(aObject);

               }

            else

                {

                _DBG_FILE("CNSmlDmStreamingAdapter::UpdateLeafObjectL(): Error in KMaxLengthStreamingName");

                iDmCallback->SetStatusL( aStatusRef, CSmlDmAdapter::ETooLargeObject);

                return;

                }

            centrep = CRepository::NewLC( KCRUidStreamingAdapter );

            if ( centrep )

                {

                _DBG_FILE("CNSmlDmStreamingAdapter::UpdateLeafObjectL(): Inside Cenrep Get");

                aErr = centrep->Set( KStreamingConfigurationName, aBuf );

                if(aErr != KErrNone)

                    {

                    _DBG_FILE("CNSmlDmStreamingAdapter::UpdateLeafObjectL(): Error in CenRep Get");

                    iDmCallback->SetStatusL( aStatusRef, CSmlDmAdapter::EError);

                    CleanupStack::PopAndDestroy(centrep);	

                    return;

                    }

                CleanupStack::PopAndDestroy(centrep);

                iModel->StoreSettingsL();

                iDmCallback->SetStatusL( aStatusRef, CSmlDmAdapter::EOk );

                }

            else

                {

                _DBG_FILE("CNSmlDmStreamingAdapter::UpdateLeafObjectL(): Error in Creating the cenrep");

                iDmCallback->SetStatusL( aStatusRef, CSmlDmAdapter::EError );

                }

            }

        else if(segment == KNSmlDMStreamingAdapterToProxy)

            {

            	// Set for Streaming settings proxy address

            _DBG_FILE("CNSmlDmStreamingAdapter::UpdateLeafObjectL(): KNSmlDMStreamingAdapterToProxy");

            TBuf<KMaxLengthToProxy> aBuf;

            if(aObject.Length() <= KMaxLengthToProxy)

               {

            aBuf.Copy(aObject);

               }

           else

               {

               _DBG_FILE("CNSmlDmStreamingAdapter::UpdateLeafObjectL(): Error in KMaxLengthToProxy");

               iDmCallback->SetStatusL( aStatusRef, CSmlDmAdapter::ETooLargeObject);

               return;

               }

            ret = iModel->SetProxyHostNameL(aBuf);

            if(ret != KErrNone)

                {

                DBG_ARGS8(_S8("CNSmlDmStreamingAdapter::UpdateLeafObjectL(): Error in SetProxyHostNameL %d"), ret);

                iDmCallback->SetStatusL( aStatusRef, CSmlDmAdapter::EError );

                return;

                }

            iModel->StoreSettingsL();    

            iDmCallback->SetStatusL( aStatusRef, CSmlDmAdapter::EOk );    

            }

        else if(segment == KNSmlDMStreamingAdapterToNapID)

            {

           	SetDefaultApL(aObject,aStatusRef);

           	/*

            TInt aNap;

            TUint32 aNapId;

            TLex8 aConv;

            aConv = aObject;

            CNSmlDMIAPMatcher* iapmatch = CNSmlDMIAPMatcher::NewL( &Callback() );

            CleanupStack::PushL(iapmatch);

            aNap = iapmatch->IAPIdFromURIL(aObject);

            if(aNap == KErrNotFound)

                {

                DBG_ARGS8(_S8("CNSmlDmStreamingAdapter::UpdateLeafObjectL(): Error in IAPIdFromURIL %d"), aNap);

                iDmCallback->SetStatusL( aStatusRef, CSmlDmAdapter::EInvalidObject );

                return;

                }

            aNapId = aNap;

            CleanupStack::PopAndDestroy(); // iapMatch

            TInt ret;// = aConv.Val(aNapId,EDecimal);

            ret = iModel->SetDefaultAp(aNapId);

            if(ret == KErrNone)

                {

                DBG_ARGS8(_S8("CNSmlDmStreamingAdapter::UpdateLeafObjectL(): SetDefaultAp success %d"), ret);

                iModel->StoreSettingsL();

                iDmCallback->SetStatusL( aStatusRef, CSmlDmAdapter::EOk );