/*

* Copyright (c) 2005 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:    DM MMS Settings Adapter

 *

*/

#include <iapprefs.h>

#include <msvids.h>

#include <msvuids.h>

#include <utf.h>

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

#include <commdb.h>

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

#include <mmsclient.h>

#include <ApUtils.h>

#include <MmsConformance.h>

#include <protectdb.h>

#include "nsmldmimpluids.h"

#include "nsmldmmmsadapter.h"

#include "nsmldebug.h"

#include "nsmlconstants.h"

#include "nsmldmconst.h"

#include "nsmldmiapmatcher.h"

#include "nsmldmtreedbclient.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

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

// CNSmlDmMMSAdapter* CNSmlDmMMSAdapter::NewL( )

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

CNSmlDmMMSAdapter* CNSmlDmMMSAdapter::NewL(MSmlDmCallback* aDmCallback )

    {

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

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

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

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

    return self;

    }

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

// CNSmlDmMMSAdapter::CNSmlDmMMSAdapter()

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

CNSmlDmMMSAdapter::CNSmlDmMMSAdapter(MSmlDmCallback* aDmCallback) 

    : CSmlDmAdapter(aDmCallback)

    {

    _DBG_FILE("CNSmlDmMMSAdapter::CNSmlDmMMSAdapter(): begin");

    _DBG_FILE("CNSmlDmMMSAdapter::CNSmlDmMMSAdapter(): end");

    }

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

// CNSmlDmMMSAdapter::ConstructL()

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

void CNSmlDmMMSAdapter::ConstructL()

    {

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

    iStatusRef = KNSmlMMSUndefinedStatusRef;

    iImgSizeStatusRef = KNSmlMMSUndefinedStatusRef;

    iDatabase = CCommsDatabase::NewL(EDatabaseTypeIAP);

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

    }

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

// CNSmlDmMMSAdapter::~CNSmlDmMMSAdapter()

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

CNSmlDmMMSAdapter::~CNSmlDmMMSAdapter()

    {

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

    delete iMmsClient;

    delete iClientMtmRegistry;

    delete iMsvSession;

    delete iMMSSAddr;

    delete iMmsSettings;

	if(iDatabase)

    delete iDatabase;

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

    }

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

//  CNSmlDmMMSAdapter::DDFVersionL()

//  Returns the DDF version of the adapter

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

void CNSmlDmMMSAdapter::DDFVersionL(CBufBase& aDDFVersion)

    {

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

    aDDFVersion.InsertL(0,KNSmlDMMMSDDFVersion);

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

    }

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

//  CNSmlDmMMSAdapter::DDFStructureL()

//  Builds the DDF structure of adapter

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

void CNSmlDmMMSAdapter::DDFStructureL( MSmlDmDDFObject& aDDF )

    {

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

    TSmlDmAccessTypes accessTypesGetAdd;

    accessTypesGetAdd.SetGet();

    accessTypesGetAdd.SetAdd();

    TSmlDmAccessTypes accessTypesGet;

    accessTypesGet.SetGet();

    TSmlDmAccessTypes accessTypesNoDelete;

    accessTypesNoDelete.SetGet();

    accessTypesNoDelete.SetAdd();

    accessTypesNoDelete.SetReplace();

    // MMS

    MSmlDmDDFObject& MMS = aDDF.AddChildObjectL(KNSmlDMMMSNodeName);

    FillNodeInfoL(MMS,accessTypesGet,MSmlDmDDFObject::EOne,

                  MSmlDmDDFObject::EPermanent,MSmlDmDDFObject::ENode,

                  KNSmlDMMMSNodeNameDescription);

    //run time node 

    MSmlDmDDFObject& rtAcc = MMS.AddChildObjectGroupL();

    FillNodeInfoL(rtAcc,accessTypesGet,MSmlDmDDFObject::EOne,

                  MSmlDmDDFObject::EDynamic,MSmlDmDDFObject::ENode,

                  KNSmlDMMMSDynamicNodeDescription);

    //level of mms protocol operations

    MSmlDmDDFObject& mmRecep = rtAcc.AddChildObjectL(KNSmlDMMMSMMRecep);

    FillNodeInfoL(mmRecep,accessTypesNoDelete,MSmlDmDDFObject::EZeroOrOne,

                  MSmlDmDDFObject::EDynamic,MSmlDmDDFObject::EChr,

                  KNSmlDMMMSMMRecepDescription);

    //Creation mode

    MSmlDmDDFObject& creMode = rtAcc.AddChildObjectL(KNSmlDMMMSCreMode);

    FillNodeInfoL(creMode,accessTypesNoDelete,MSmlDmDDFObject::EZeroOrOne,

                  MSmlDmDDFObject::EDynamic,MSmlDmDDFObject::EChr,

                  KNSmlDMMMSCreModeDescription);

    //anonymous messages allowed

    MSmlDmDDFObject& amsg = rtAcc.AddChildObjectL(KNSmlDMMMSAMsg);

    FillNodeInfoL(amsg,accessTypesNoDelete,MSmlDmDDFObject::EZeroOrOne,

                  MSmlDmDDFObject::EDynamic,MSmlDmDDFObject::EBool,

                  KNSmlDMMMSAMsgDescription);

    //adverts messages allowed

    MSmlDmDDFObject& rcvAds = rtAcc.AddChildObjectL(KNSmlDMMMSRcvAds);

    FillNodeInfoL(rcvAds,accessTypesNoDelete,MSmlDmDDFObject::EZeroOrOne,

                  MSmlDmDDFObject::EDynamic,MSmlDmDDFObject::EBool,

                  KNSmlDMMMSRcvAdsDescription);

    //image size in sending

    MSmlDmDDFObject& imgSize = rtAcc.AddChildObjectL(KNSmlDMMMSImgSize);

    FillNodeInfoL(imgSize,accessTypesNoDelete,MSmlDmDDFObject::EZeroOrOne,

                  MSmlDmDDFObject::EDynamic,MSmlDmDDFObject::EChr,

                  KNSmlDMMMSImgSizeDescription);

    //deny delivery report sending

    MSmlDmDDFObject& dRepSnd = rtAcc.AddChildObjectL(KNSmlDMMMSDRepSnd);

    FillNodeInfoL(dRepSnd,accessTypesNoDelete,MSmlDmDDFObject::EZeroOrOne,

                  MSmlDmDDFObject::EDynamic,MSmlDmDDFObject::EBool,

                  KNSmlDMMMSDRepSndDescription);

    //delivery report requested by default

    MSmlDmDDFObject& rcvRep = rtAcc.AddChildObjectL(KNSmlDMMMSRcvRep);

    FillNodeInfoL(rcvRep,accessTypesNoDelete,MSmlDmDDFObject::EZeroOrOne,

                  MSmlDmDDFObject::EDynamic,MSmlDmDDFObject::EBool,

                  KNSmlDMMMSRcvRepDescription);

    //message validity time

    MSmlDmDDFObject& msgVal = rtAcc.AddChildObjectL(KNSmlDMMMSMsgVal);

    FillNodeInfoL(msgVal,accessTypesNoDelete,MSmlDmDDFObject::EZeroOrOne,

                  MSmlDmDDFObject::EDynamic,MSmlDmDDFObject::EChr,

                  KNSmlDMMMSMsgValDescription);

    // MMS/<X>/Con

    MSmlDmDDFObject& con = rtAcc.AddChildObjectL(KNSmlDMMMSCon);

    FillNodeInfoL(con,accessTypesGet,MSmlDmDDFObject::EOne,

                  MSmlDmDDFObject::EDynamic,MSmlDmDDFObject::ENode,

                  KNSmlDMMMSConNodeDescription);

    // MMS/<X>/Con/<X>

    MSmlDmDDFObject& rtCon = con.AddChildObjectL(KNSmlDMMMSConDynamicName16);

    FillNodeInfoL(rtCon,accessTypesGet,MSmlDmDDFObject::EOne,

                  MSmlDmDDFObject::EDynamic,MSmlDmDDFObject::ENode,

                  KNSmlDMMMSConRtNodeDescription);

    // MMS/<X>/Con/<X>/MMSSAddr

    MSmlDmDDFObject& mmsAddr = rtCon.AddChildObjectL(KNSmlDMMMSMMSSAddr);

    FillNodeInfoL(mmsAddr,accessTypesNoDelete,MSmlDmDDFObject::EOne,

                  MSmlDmDDFObject::EDynamic,MSmlDmDDFObject::EChr,

                  KNSmlDMMMSMMSSAddrDescription);

    // MMS/<X>/Con/<X>/MToNapID

    MSmlDmDDFObject& mToNapID = rtCon.AddChildObjectL(KNSmlDMMMSMToNapID);

    FillNodeInfoL(mToNapID,accessTypesGet,MSmlDmDDFObject::EZeroOrOne,

                  MSmlDmDDFObject::EDynamic,MSmlDmDDFObject::ENode,

                  KNSmlDMMMSConRtNodeDescription);

    // MMS/<X>/Con/<X>/MToNapID/<X>

    MSmlDmDDFObject& rtNapIds = mToNapID.AddChildObjectL(KNullDesC8);

    FillNodeInfoL(rtNapIds,accessTypesGet,MSmlDmDDFObject::EZeroOrOne,

                  MSmlDmDDFObject::EDynamic,MSmlDmDDFObject::ENode,

                  KNSmlDMMMSConRtNodeDescription);

    // MMS/<X>/Con/<X>/MToNapID/<X>/MToNapIdL

    MSmlDmDDFObject& mToNapIDL = rtNapIds.AddChildObjectL(KNSmlDMMMSMToNapIDL);

    FillNodeInfoL(mToNapIDL,accessTypesNoDelete,MSmlDmDDFObject::EOneOrMore,

                  MSmlDmDDFObject::EDynamic,MSmlDmDDFObject::EChr,

                  KNSmlDMMMSMToNapIDLDescription);

    RNSmlDMCallbackSession session;

    User::LeaveIfError( session.Connect() );

    CleanupClosePushL(session);

    session.UpdateAclL(KNSmlDMMMSLevel3Parents,KNSmlDmMMSAclGet);

    session.UpdateAclL(KNSmlDMMMSAclName,KNSmlDmMMSAclDefault);

    session.UpdateAclL(KNSmlDMMMSAclMMRecep,KNSmlDmMMSAclDefault);

    session.UpdateAclL(KNSmlDMMMSAclCreMode,KNSmlDmMMSAclDefault);

    session.UpdateAclL(KNSmlDMMMSAclAMsg,KNSmlDmMMSAclDefault);

    session.UpdateAclL(KNSmlDMMMSAclRcvAds,KNSmlDmMMSAclDefault);

    session.UpdateAclL(KNSmlDMMMSAclImgSize,KNSmlDmMMSAclDefault);

    session.UpdateAclL(KNSmlDMMMSAclDRepSnd,KNSmlDmMMSAclDefault);

    session.UpdateAclL(KNSmlDMMMSAclRcvRep,KNSmlDmMMSAclDefault);

    session.UpdateAclL(KNSmlDMMMSAclMsgVal,KNSmlDmMMSAclDefault);

    session.UpdateAclL(KNSmlDMMMSAclMMSSAddr,KNSmlDmMMSAclDefault);

    session.UpdateAclL(KNSmlDMMMSAclPrimaryMToNapIDL,KNSmlDmMMSAclDefault);

    CleanupStack::PopAndDestroy(); //session

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

    }

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

//  CNSmlDmMMSAdapter::UpdateLeafObjectL()

// Updates value of leaf object

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

void CNSmlDmMMSAdapter::UpdateLeafObjectL( const TDesC8& aURI, 

                                           const TDesC8& aLUID, 

                                           const TDesC8& aObject, 

                                           const TDesC8& /*aType*/, 

                                           const TInt aStatusRef )

    {

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

    CSmlDmAdapter::TError status = ValidateUriL( aURI );

    if ( status == EOk )

        {

        _DBG_FILE("CNSmlDmMMSAdapter::UpdateLeafObjectL(): OK update");

        status = UpdateDataL(aURI, aLUID, aObject, aStatusRef);

        }

    // ImgSize and MMSAddr are always stored last, from the 

    // CompleteOutstandingCmdsL() function

    if( ( aStatusRef != iStatusRef ) && (aStatusRef != iImgSizeStatusRef ))

        {

        StoreSettingsL();

        Callback().SetStatusL(aStatusRef, status);

        }

    _DBG_FILE("CNSmlDmMMSAdapter::UpdateLeafObjectL(): end");

    }

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

// CNSmlDmMMSAdapter::DeleteObjectL( const TDesC8& aURI, const TDesC8& aLUID )

// This should delete values or accounts, but in case of MMS adapter the delete 

// is not allowed

// and the adapters returns allways the EError.

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

void CNSmlDmMMSAdapter::DeleteObjectL( const TDesC8& /*aURI*/, 

                                       const TDesC8& /*aLUID*/, 

                                       const TInt aStatusRef )

    {

    _DBG_FILE("CNSmlDmMMSAdapter::DeleteLeafObjectL( ): begin");

    Callback().SetStatusL(aStatusRef, CSmlDmAdapter::EError);

    _DBG_FILE("CNSmlDmMMSAdapter::DeleteLeafObjectL( ): end");

    }

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

//  CNSmlDmMMSAdapter::FetchLeafObjectL( const TDesC8& aURI, 

//  const TDesC8& aLUID,

//  const TDesC8& aType, 

//  const TInt aResultsRef, 

//  const TInt aStatusRef )

//  Fetches the values of leaf objects.

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

void CNSmlDmMMSAdapter::FetchLeafObjectL( const TDesC8& aURI, 

                                          const TDesC8& /*aLUID*/, 

                                          const TDesC8& aType, 

                                          const TInt aResultsRef, 

                                          const TInt aStatusRef )

    {

    _DBG_FILE("CNSmlDmMMSAdapter::FetchLeafObjectL(): begin");

    CBufBase* result = CBufFlat::NewL(64);

    CleanupStack::PushL(result);

    CSmlDmAdapter::TError status = FetchObjectL(aURI, *result);

    if(status == CSmlDmAdapter::EOk)

        {

        Callback().SetResultsL(aResultsRef,*result,aType);

        }

    Callback().SetStatusL(aStatusRef, status);

    CleanupStack::PopAndDestroy(); //result

    _DBG_FILE("CNSmlDmMMSAdapter::FetchLeafObjectL(): end");

    }

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

//  CNSmlDmMMSAdapter::ChildURIListL( const TDesC8& aURI, 

//                                       const TDesC8& /*aLUID*/, 

//                                       const CArrayFix<TSmlDmMappingInfo>& 

//                                       /*aPreviousURISegmentList*/, 

//                                       const TInt aResultsRef, 

//                                       const TInt aStatusRef )

//  Retuns the list of children of the node

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

void CNSmlDmMMSAdapter::ChildURIListL( const TDesC8& aURI, 

                                       const TDesC8& /*aLUID*/, 

                                       const CArrayFix<TSmlDmMappingInfo>& 

                                       /*aPreviousURISegmentList*/, 

                                       const TInt aResultsRef, 

                                       const TInt aStatusRef )

    {

    _DBG_FILE("CNSmlDmMMSAdapter::ChildURIListL(): begin");

    TRAPD(err, CreateMMSClientL());

    if(err!=KErrNone)

        {

        Callback().SetStatusL(aStatusRef, CSmlDmAdapter::EError);

        _DBG_FILE("CNSmlDmMMSAdapter::ChildURIListL(): EError end");

        return;

        }

    CBufBase* currentList = CBufFlat::NewL(1);

    CleanupStack::PushL(currentList);

    TMsvId id = iMmsSettings->Service();

    if(id==KMsvNullIndexEntryId)

        {

        if(aURI.Compare(KNSmlDMMMSNodeName)==0)

            {

            Callback().SetResultsL(aResultsRef,*currentList,KNullDesC8);

            Callback().SetStatusL(aStatusRef, CSmlDmAdapter::EOk);

            _DBG_FILE("CNSmlDmMMSAdapter::ChildURIListL(): end");

            }

        else

            {

            Callback().SetStatusL(aStatusRef, CSmlDmAdapter::ENotFound);

            _DBG_FILE("CNSmlDmMMSAdapter::ChildURIListL(): ENotFound end");

            }

        CleanupStack::PopAndDestroy(); //currentList

        return;

        }

    CSmlDmAdapter::TError status = CSmlDmAdapter::EOk;

    TPtrC8 lastSeg = LastURISeg(aURI);

    TInt num = NumOfURISegs(aURI);

    if(aURI.Compare(KNSmlDMMMSNodeName)==0)

        {

        currentList->InsertL(0,KNSmlDMMMSAccount8);

        }

    else if(num==2&&aURI.Find(KNSmlDMMMSAccount8)>=0)

        {

        currentList->InsertL(0,KNSmlDMMMSListOfLeafsLo);

        }

    else if(num==3&&lastSeg.Compare(KNSmlDMMMSCon)==0)

        {

        currentList->InsertL(0,KNSmlDMMMSConDynamicName8);

        }

    else if(num==4&&lastSeg.Compare(KNSmlDMMMSConDynamicName16)==0)

        {

        currentList->InsertL(0,KNSmlDMMMSListOfLeafsMid);

        }

    else if(num==5&&lastSeg.Compare(KNSmlDMMMSMToNapID)==0)

        {

        currentList->InsertL(0,KNSmlDMMMSValuePrimary);

        }

    else if(num==6&&(lastSeg.Compare(KNSmlDMMMSDynamicPrimary)==0))

        {

        currentList->InsertL(0,KNSmlDMMMSListOfLeafsHi);

        }

    else

        {

        status=CSmlDmAdapter::ENotFound;

        }

    Callback().SetStatusL(aStatusRef, status);

    if(status==CSmlDmAdapter::EOk)

        {

        Callback().SetResultsL(aResultsRef,*currentList,KNullDesC8);

        }

    CleanupStack::PopAndDestroy(); //currentList

    _DBG_FILE("CNSmlDmMMSAdapter::ChildURIListL(): end");

    }

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

// CNSmlDmMMSAdapter::AddNodeObjectL( const TDesC8& aURI, 

// const TDesC8& aParentLUID )

// This should add a new account, but in case of MMS settings only one 

// account exist,

// and so the add is not possible. Returns allways CSmlDmAdapter::EError.

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

void CNSmlDmMMSAdapter::AddNodeObjectL( const TDesC8& /*aURI*/, 

                                        const TDesC8& /*aParentLUID*/, 

                                        const TInt aStatusRef )

    {

    _DBG_FILE("CNSmlDmMMSAdapter::AddNodeObjectL(): begin");

    //If add is needed in future then add call to AddObjectL function here

    Callback().SetStatusL(aStatusRef, CSmlDmAdapter::EError);

    _DBG_FILE("CNSmlDmMMSAdapter::AddNodeObjectL(): end");

    }

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

// CNSmlDmMMSAdapter::UpdateLeafObjectL( const TDesC8& aURI, 

// const TDesC8& aLUID, RWriteStream*& aStream, const TDesC8& aType,

//  const TInt aStatusRef )

// This should update a stream object, but in case of MMS settings streaming is 

// not supported.

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

void CNSmlDmMMSAdapter::UpdateLeafObjectL( const TDesC8& /*aURI*/, 

                                           const TDesC8& /*aLUID*/, 

                                           RWriteStream*& /*aStream*/, 

                                           const TDesC8& /*aType*/, 

                                           const TInt aStatusRef )

    {

    _DBG_FILE("CNSmlDmMMSAdapter::UpdateLeafObjectL(stream): begin");

    Callback().SetStatusL(aStatusRef, CSmlDmAdapter::EError);

    _DBG_FILE("CNSmlDmMMSAdapter::UpdateLeafObjectL(stream): end");

    }

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

// void CNSmlDmMMSAdapter::FetchLeafObjectSizeL( const TDesC8& aURI, 

// const TDesC8& aLUID, const TDesC8& aType, const TInt aResultsRef, 

// const TInt aStatusRef )

// Fetches data object and returns its size.

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

void CNSmlDmMMSAdapter::FetchLeafObjectSizeL( const TDesC8& aURI, 

                                              const TDesC8& /*aLUID*/, 

                                              const TDesC8& aType, 

                                              const TInt aResultsRef, 

                                              const TInt aStatusRef )

    {

    _DBG_FILE("CNSmlDmMMSAdapter::FetchLeafObjectSizeL(): begin");

    CBufBase* result = CBufFlat::NewL(64);

    CleanupStack::PushL(result);

    CSmlDmAdapter::TError status = FetchObjectL(aURI, *result);

    if( status == CSmlDmAdapter::EOk )

        {

        TInt objSizeInBytes = result->Size();

        TBuf8<KNSmlDmMmsObjectSizeWidth> stringObjSizeInBytes;

        stringObjSizeInBytes.Num( objSizeInBytes );

        result->Reset();

        result->InsertL( 0, stringObjSizeInBytes );

        Callback().SetResultsL(aResultsRef, *result, aType);

        }

    Callback().SetStatusL(aStatusRef, status);

    CleanupStack::PopAndDestroy(); //result

    _DBG_FILE("CNSmlDmMMSAdapter::FetchLeafObjectSizeL(): end");

    }

//==============================================================================

// CNSmlDmMMSAdapter::ExecuteCommandL()

//==============================================================================

void CNSmlDmMMSAdapter::ExecuteCommandL( const TDesC8& /*aURI*/, 

                                         const TDesC8& /*aLUID*/, 

                                         const TDesC8& /*aArgument*/, 

                                         const TDesC8& /*aType*/, 

                                         const TInt aStatusRef )

    {

    //Not supported 

    Callback().SetStatusL(aStatusRef, CSmlDmAdapter::EError);

    }

//==============================================================================

// CNSmlDmMMSAdapter::ExecuteCommandL()

//==============================================================================

void CNSmlDmMMSAdapter::ExecuteCommandL( const TDesC8& /*aURI*/, 

                                         const TDesC8& /*aLUID*/, 

                                         RWriteStream*& /*aStream*/, 

                                         const TDesC8& /*aType*/, 

                                         const TInt aStatusRef )

    {

    //Not supported

    Callback().SetStatusL(aStatusRef, CSmlDmAdapter::EError);

    }

//==============================================================================

// CNSmlDmMMSAdapter::CopyCommandL()

//==============================================================================

void CNSmlDmMMSAdapter::CopyCommandL( const TDesC8& /*aTargetURI*/, 

                                      const TDesC8& /*aTargetLUID*/, 

                                      const TDesC8& /*aSourceURI*/, 

                                      const TDesC8& /*aSourceLUID*/, 

                                      const TDesC8& /*aType*/, 

                                      TInt aStatusRef )

    {

    //Not supported

    Callback().SetStatusL(aStatusRef, CSmlDmAdapter::EError);

    }

//==============================================================================

// CNSmlDmMMSAdapter::StartAtomicL()

//==============================================================================

void CNSmlDmMMSAdapter::StartAtomicL()

    {

    //Not supported

    }

//==============================================================================

// CNSmlDmMMSAdapter::CommitAtomicL()

//==============================================================================

void CNSmlDmMMSAdapter::CommitAtomicL()

    {

    //Not supported

    }

//==============================================================================

// CNSmlDmMMSAdapter::RollbackAtomicL()