/*

* 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:   Bearer management DM adapter. Provides handling of 

                Bearer management related settings in Device management

*

*/

#include <ecom/implementationproxy.h>

#include <cmdestinationext.h>

#include "nsmldmbmadapter.h"

#include "bmadapterlogger.h"

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

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

// Maps plugin UID to its factory function (constructor)

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

const TImplementationProxy ImplementationTable[] =

    {

    IMPLEMENTATION_PROXY_ENTRY(0x101f6d2f, 

                               CNSmlDmBmAdapter::NewL)

    };

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

// For ecom plugin implementation

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

EXPORT_C const TImplementationProxy* ImplementationGroupProxy( TInt& aTableCount )

    {

    aTableCount = sizeof(ImplementationTable) / sizeof(TImplementationProxy);

    return ImplementationTable;

    }

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

// CNSmlDmBmAdapter::NewL

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

CNSmlDmBmAdapter* CNSmlDmBmAdapter::NewL( MSmlDmCallback* aDmCallback )

    {

    BMADAPTERLOGSTRING("CNSmlDmBmAdapter::NewL: Start")

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

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop( self );

    BMADAPTERLOGSTRING("CNSmlDmBmAdapter::NewL: End")

    return self;

    }

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

// CNSmlDmBmAdapter::CNSmlDmBmAdapter

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

CNSmlDmBmAdapter::CNSmlDmBmAdapter( MSmlDmCallback* aDmCallback ) 

    : CSmlDmAdapter( aDmCallback )

    {

    }

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

// CNSmlDmBmAdapter::ConstructL

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

void CNSmlDmBmAdapter::ConstructL()

    {

    BMADAPTERLOGSTRING( "CNSmlDmBmAdapter::CNSmlDmBmAdapter: Start" )

    iSettingStore = CNSmlDmBmSettingStore::NewL( this );

    BMADAPTERLOGSTRING( "CNSmlDmBmAdapter::CNSmlDmBmAdapter: End" )

    }

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

// CNSmlDmBmAdapter::~CNSmlDmBmAdapter

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

CNSmlDmBmAdapter::~CNSmlDmBmAdapter()

    {

    BMADAPTERLOGSTRING( "CNSmlDmBmAdapter::~CNSmlDmBmAdapter: Start" )

    iBuffer.ResetAndDestroy();

    iBuffer.Close();

    delete iSettingStore;

    BMADAPTERLOGSTRING( "CNSmlDmBmAdapter::~CNSmlDmBmAdapter: End" )

    }

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

// CNSmlDmBmAdapter::DDFVersionL

// Returns ddf version nr

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

void CNSmlDmBmAdapter::DDFVersionL( CBufBase& aDDFVersion )

    {

    BMADAPTERLOGSTRING( "CNSmlDmBmAdapter::DDFVersionL: Start" )

    aDDFVersion.InsertL( 0, KNSmlDmBMAdapterDDFVersion );

    BMADAPTERLOGSTRING( "CNSmlDmBmAdapter::DDFVersionL:End" )

    }

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

// CNSmlDmBmAdapter::DDFStructureL

//  Constructs the DDF structure

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

void CNSmlDmBmAdapter::DDFStructureL( MSmlDmDDFObject& aDDF )

    {

    BMADAPTERLOGSTRING( "CNSmlDmBmAdapter::DDFStructureL: Start" )

    TSmlDmAccessTypes accessTypes;

    // BearerManagementSNAP

    MSmlDmDDFObject& bm = aDDF.AddChildObjectL( KNSmlDmBMAdapterBM );

    accessTypes.SetGet();

    accessTypes.SetAdd();

    bm.SetAccessTypesL( accessTypes );

    bm.SetOccurenceL( MSmlDmDDFObject::EOne );

    bm.SetScopeL( MSmlDmDDFObject::EPermanent );

    bm.SetDFFormatL( MSmlDmDDFObject::ENode );

    bm.AddDFTypeMimeTypeL( KNSmlDmBMAdapterTextPlain );

    bm.SetDescriptionL( KNSmlDmBMAdapterBMDescription );

    accessTypes.Reset();

    // BearerManagementSNAP/<X>

    MSmlDmDDFObject& dynamic1 = bm.AddChildObjectGroupL();

    accessTypes.SetAdd();

    accessTypes.SetDelete();

    accessTypes.SetGet();

    accessTypes.SetReplace();

    dynamic1.SetAccessTypesL( accessTypes );

    dynamic1.SetOccurenceL( MSmlDmDDFObject::EZeroOrMore );

    dynamic1.SetScopeL( MSmlDmDDFObject::EDynamic );

    dynamic1.SetDFFormatL( MSmlDmDDFObject::ENode );

    dynamic1.AddDFTypeMimeTypeL( KNSmlDmBMAdapterTextPlain );

    dynamic1.SetDescriptionL( KNSmlDmBMAdapterDynamicDescription );

    accessTypes.Reset();

    // BearerManagementSNAP/<X>/Name

    MSmlDmDDFObject& name = dynamic1.AddChildObjectL( KNSmlDmBMAdapterName );

    accessTypes.SetAdd();

    accessTypes.SetGet();

    accessTypes.SetReplace();

    name.SetAccessTypesL( accessTypes );

    name.SetOccurenceL( MSmlDmDDFObject::EOne );

    name.SetScopeL( MSmlDmDDFObject::EDynamic );

    name.SetDFFormatL( MSmlDmDDFObject::EChr );

    name.SetDescriptionL( KNSmlDmBMAdapterNameDescription );

    accessTypes.Reset();

    // BearerManagementSNAP/<X>/IAPPrioityList

    MSmlDmDDFObject& iapList = 

    dynamic1.AddChildObjectL( KNSmlDmBMAdapterIAPPriorityList );

    accessTypes.SetAdd();

    accessTypes.SetGet();

    accessTypes.SetReplace();

    iapList.SetAccessTypesL( accessTypes );

    iapList.SetOccurenceL( MSmlDmDDFObject::EOne );

    iapList.SetScopeL( MSmlDmDDFObject::EDynamic );

    iapList.SetDFFormatL( MSmlDmDDFObject::EChr );

    iapList.SetDescriptionL( KNSmlDmBMAdapterIAPPriorityListDescription );

    accessTypes.Reset();

    // BearerManagementSNAP/<X>/EmbeddedSNAP

    MSmlDmDDFObject& embedded = 

    dynamic1.AddChildObjectL( KNSmlDmBMAdapterEmbeddedSNAP );

    accessTypes.SetAdd();

    accessTypes.SetDelete();

    accessTypes.SetGet();

    accessTypes.SetReplace();

    embedded.SetAccessTypesL( accessTypes );

    embedded.SetOccurenceL( MSmlDmDDFObject::EZeroOrOne );

    embedded.SetScopeL( MSmlDmDDFObject::EDynamic );

    embedded.SetDFFormatL( MSmlDmDDFObject::EChr );

    embedded.SetDescriptionL( KNSmlDmBMAdapterEmbeddedSNAPDescription );

    accessTypes.Reset();

    // BearerManagementSNAP/<X>/Metadata

    MSmlDmDDFObject& metadata = 

    dynamic1.AddChildObjectL( KNSmlDmBMAdapterMetadata );

    accessTypes.SetAdd();

    accessTypes.SetGet();

    accessTypes.SetReplace();

    metadata.SetAccessTypesL( accessTypes );

    metadata.SetOccurenceL( MSmlDmDDFObject::EOne );

    metadata.SetScopeL( MSmlDmDDFObject::EDynamic );

    metadata.SetDFFormatL( MSmlDmDDFObject::EInt );

    metadata.SetDescriptionL( KNSmlDmBMAdapterMetadataDescription );

    accessTypes.Reset();

    // BearerManagementSNAP/<X>/Protected

    MSmlDmDDFObject& protection = 

    dynamic1.AddChildObjectL( KNSmlDmBMAdapterProtected );

    accessTypes.SetAdd();

    accessTypes.SetGet();

    accessTypes.SetReplace();

    protection.SetAccessTypesL( accessTypes );

    protection.SetOccurenceL( MSmlDmDDFObject::EOne );

    protection.SetScopeL( MSmlDmDDFObject::EDynamic );

    protection.SetDFFormatL( MSmlDmDDFObject::EInt );

    protection.SetDescriptionL( KNSmlDmBMAdapterProtectedDescription );

    accessTypes.Reset(); 

    // BearerManagementSNAP/<X>/Hidden

    MSmlDmDDFObject& hidden = dynamic1.AddChildObjectL( KNSmlDmBMAdapterHidden );

    accessTypes.SetAdd();

    accessTypes.SetGet();

    accessTypes.SetReplace();

    hidden.SetAccessTypesL( accessTypes );

    hidden.SetOccurenceL( MSmlDmDDFObject::EOne );

    hidden.SetScopeL( MSmlDmDDFObject::EDynamic );

    hidden.SetDFFormatL( MSmlDmDDFObject::EBool );

    hidden.SetDescriptionL( KNSmlDmBMAdapterHiddenDescription );

    accessTypes.Reset(); 

    BMADAPTERLOGSTRING( "CNSmlDmBmAdapter::DDFStructureL: End" )

    }

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

// CNSmlDmBmAdapter::UpdateLeafObjectL

//  Adds or updates leaf node value. If snap object is 

//  in buffer this command is also buffered. Also if leaf node 

//  is embedded snap and that snap is buffered, the argument command

//  is buffered.

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

void CNSmlDmBmAdapter::UpdateLeafObjectL( const TDesC8& aURI, 

                                          const TDesC8& aLUID, 

                                          const TDesC8& aObject, 

                                          const TDesC8& /*aType*/, 

                                          TInt aStatusRef )

    {

    BMADAPTERLOGSTRING( "CNSmlDmBmAdapter::UpdateLeafObjectL: Start" )

    BMADAPTERLOGSTRING4( "\tUpdateLeafObjectL  \tURI: %S, \n\tLUID: %S,\

                         \tobject: %S ", 

                        &aURI, &aLUID, &aObject )

    TInt snapId = MapPredefinedSnapsL( aURI, aLUID );

    // Check if parent snap node is found in the buffered settings

    CSmlDmBmSettingsElement* snap = 

    GetSnapIfBuffered( RemoveLastURISeg( aURI ) );

    // data for buffered SNAP -> Store command into buffer    

    if ( snap )

        {

        CSmlDmBmCommandElement* cmd = 

        CSmlDmBmCommandElement::NewLC( ETrue, 

                                       aStatusRef,

                                       KNSmlDmBmInvalidRef, 

                                       CNSmlDmBmAdapter::EAddCmd,

                                       LastURISeg( aURI ), 

                                       aObject);

        snap->NodeBuf().AppendL(cmd);

        CleanupStack::Pop( cmd );

        BMADAPTERLOGSTRING2( "\tSnap %S found, buffering cmd", 

                            snap->MappingName() )

        }

    // updates for an existing SNAP

    else

        {

        // If setting embedded SNAP node and the embedded SNAP node is still 

        // buffered -> Buffer also this command

        if( !LastURISeg( aURI ).Compare( KNSmlDmBMAdapterEmbeddedSNAP ) )

            {

            snap = GetSnapIfBuffered( aObject );

                // embedded SNAP is buffered

                if ( snap )

                    {

                    CSmlDmBmCommandElement* cmd = 

                    CSmlDmBmCommandElement::NewLC( ETrue, 

                                                   aStatusRef,

                                                   KNSmlDmBmInvalidRef, 

                                                   CNSmlDmBmAdapter::EAddCmd,

                                                   LastURISeg( aURI ), 

                                                   aObject);

                    // buffer this command

                    CSmlDmBmSettingsElement* setting = 

                    CSmlDmBmSettingsElement::NewLC( RemoveLastURISeg( aURI ) );

                    // Check if SNAP was predefined or not

                    if( snapId == KErrNotFound )

                        {

                        snapId = DesToIntL( aLUID );

                        }

                    setting->SetLuid( snapId );

                    iBuffer.AppendL( setting );

                    CleanupStack::Pop( setting );

                    setting->NodeBuf().AppendL(cmd);

                    CleanupStack::Pop( cmd );

                    BMADAPTERLOGSTRING2( "\tEmbedded Snap %S buffered, buffering cmd", 

                                         snap->MappingName() )

                    BMADAPTERLOGSTRING( "CNSmlDmBmAdapter::UpdateLeafObjectL: End" )

                    return;

                    }

            }

        // execute command and return status  

        CSmlDmBmCommandElement* cmd = 

        CSmlDmBmCommandElement::NewLC( ETrue, 

                                       aStatusRef,

                                       KNSmlDmBmInvalidRef, 

                                       CNSmlDmBmAdapter::EAddCmd,

                                       LastURISeg( aURI ), 

                                       aObject);

        if( snapId == KErrNotFound )

            {

            snapId = DesToIntL( aLUID );

            }

        iSettingStore->ExecuteCmdL( *cmd, snapId );

        BMADAPTERLOGSTRING2( "\tCmd executed with status: %d", 

                              cmd->Status() )

        Callback().SetStatusL( aStatusRef, cmd->Status() );

        CleanupStack::PopAndDestroy( cmd );

        }

    BMADAPTERLOGSTRING( "CNSmlDmBmAdapter::UpdateLeafObjectL: End" )

    }

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

// CNSmlDmBmAdapter::DeleteObjectL

//  Deletes node or leaf object. If the snap this command relates to is

//  buffered, also the delete command is buffered.

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

void CNSmlDmBmAdapter::DeleteObjectL( const TDesC8& aURI, 

                                      const TDesC8& aLUID,

                                      TInt aStatusRef )

    {

    BMADAPTERLOGSTRING( "CNSmlDmBmAdapter::DeleteObjectL: Start" )

    BMADAPTERLOGSTRING3( "\tDeleteObjectL  \tURI: %S, \tLUID: %S", 

                         &aURI, &aLUID )

    CSmlDmBmCommandElement* cmd;

    TInt snapId = MapPredefinedSnapsL( aURI, aLUID );

    // check if node or leaf object and create command accordingly

    // when updating, make sure that cmd is constructed

    if ( NumOfURISegs( aURI  ) == KNsmlDmBmSNAPNodeDepth )

        {

        cmd = CSmlDmBmCommandElement::NewLC( EFalse, 

                                             aStatusRef,

                                             KNSmlDmBmInvalidRef, 

                                             CNSmlDmBmAdapter::EDeleteCmd,

                                             KNullDesC8, KNullDesC8 );

        }

    else if ( ! LastURISeg( aURI ).Compare( KNSmlDmBMAdapterEmbeddedSNAP() ) )

        {

        cmd = CSmlDmBmCommandElement::NewLC( ETrue, 

                                             aStatusRef,

                                             KNSmlDmBmInvalidRef, 

                                             CNSmlDmBmAdapter::EDeleteCmd,

                                             LastURISeg( aURI ), 

                                             KNullDesC8 );

        }

    else

        {

        // unsupported node, framework should check this

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

        BMADAPTERLOGSTRING( "\tCNSmlDmBmAdapter::DeleteObjectL: \

        Error, unsupported node" )

        return;

        }

    // If this SNAP still in buffer -> buffer command for later execution

    // Check if SNAP is found in the buffered settings

    CSmlDmBmSettingsElement* snap = NULL;

    if( cmd->Leaf() )

        {

        snap = GetSnapIfBuffered( RemoveLastURISeg( aURI ) );

        }

    else

        {

        snap = GetSnapIfBuffered( aURI );

        }

    // when updating make sure that cmd is removed from cleanup 

    // stack and deleted if necessary

    // if cmd for buffered snap append cmd to buffer

    if ( snap )

        {

        snap->NodeBuf().AppendL( cmd );

        CleanupStack::Pop( cmd );

        BMADAPTERLOGSTRING2( "\tSnap %S found, buffering cmd", 

                            snap->MappingName() )

        }

    // if existing node, execute command

    else if( aLUID.Length() > 0 || snapId != KErrNotFound )

        {

        if( snapId == KErrNotFound )

            {

            snapId = DesToIntL( aLUID );

            }

        iSettingStore->ExecuteCmdL( *cmd, snapId );

        BMADAPTERLOGSTRING2( "\tCmd executed with status: %d ", 

                              cmd->Status() )

        Callback().SetStatusL( aStatusRef, cmd->Status() );

        CleanupStack::PopAndDestroy( cmd );

        }

        // unknown node    

    else

        {

        BMADAPTERLOGSTRING( "\tUnknown node\n" )

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

        CleanupStack::PopAndDestroy( cmd );

        }

    BMADAPTERLOGSTRING( "CNSmlDmBmAdapter::DeleteObjectL: End" )

    }

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

// CNSmlDmBmAdapter::FetchLeafObjectL

//  Fetches leaf object value. If the snap is buffered also this command 

//  will

//  be buffered.

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

void CNSmlDmBmAdapter::FetchLeafObjectL( const TDesC8& aURI, 

                                         const TDesC8& aLUID, 

                                         const TDesC8& /*aType*/, 

                                         const TInt aResultsRef, 

                                         const TInt aStatusRef )

    {

    BMADAPTERLOGSTRING( "NSmlDmBMAdapter::FetchLeafObjectL: Start" )

    BMADAPTERLOGSTRING3( "\tFetchLeafObjectL  \tURI: %S, \tLUID: %S,", 

                        &aURI, &aLUID )

    TInt snapId = MapPredefinedSnapsL( aURI, aLUID );                         

    // check if parent snap node is buffered 

    CSmlDmBmSettingsElement* snap = 

    GetSnapIfBuffered( RemoveLastURISeg( aURI ) );

    // data for buffered SNAP -> Store command into buffer    

    if ( snap )

        {

        CSmlDmBmCommandElement* cmd = 

        CSmlDmBmCommandElement::NewLC( ETrue, 

                                       aStatusRef, 

                                       aResultsRef, 

                                       CNSmlDmBmAdapter::EGetCmd,

                                       LastURISeg( aURI ), 

                                       KNullDesC8);

        snap->NodeBuf().AppendL( cmd );

        CleanupStack::Pop( cmd );

        BMADAPTERLOGSTRING2( "\tSnap %S found, buffering cmd", 

                            snap->MappingName() )

        }

    // otherwise execute cmd right away

    else

        {

        CSmlDmBmCommandElement* cmd = 

        CSmlDmBmCommandElement::NewLC( ETrue, 

                                       aStatusRef, 

                                       aResultsRef, 

                                       CNSmlDmBmAdapter::EGetCmd,

                                       LastURISeg( aURI ), 

                                       KNullDesC8);

        if( snapId == KErrNotFound )

            {

            snapId = DesToIntL( aLUID );

            }

        iSettingStore->ExecuteCmdL( *cmd, snapId );

        BMADAPTERLOGSTRING2( "\tCmd executed with status: %d ", 

                              cmd->Status() )

        // if executed return status

        if ( cmd->Executed() ) 

            {

            Callback().SetStatusL( aStatusRef, cmd->Status() );

            // if successful set results

            if ( cmd->Status() == CSmlDmAdapter::EOk )

                {

                BMADAPTERLOGSTRING2( "\tCmd executed with result: %S ", 

                                      cmd->Data() )

                CBufBase* result = CBufFlat::NewL( cmd->Data()->Size() );

                CleanupStack::PushL( result );

                result->InsertL( 0, *cmd->Data() );

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

                CleanupStack::PopAndDestroy( result );

                }

            }

        else

            {

            // failed to execute command

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

            }

        CleanupStack::PopAndDestroy( cmd );

        }

    BMADAPTERLOGSTRING( "NSmlDmBMAdapter::FetchLeafObjectL: End" )

    }

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

//  CNSmlDmBmAdapter::FetchLeafObjectSizeL

//  Fetches leaf object size. If the snap is buffered also this command will

//  be buffered.

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

void CNSmlDmBmAdapter::FetchLeafObjectSizeL( const TDesC8& aURI, 

                                             const TDesC8& aLUID,

                                             const TDesC8& /* aType */, 

                                             TInt aResultsRef,

                                             TInt aStatusRef )

    {

    BMADAPTERLOGSTRING( "CNSmlDmBmAdapter::FetchLeafObjectSizeL: Start" )

    BMADAPTERLOGSTRING3( "\tFetchLeafObjectSizeL  \tURI: %S, \tLUID: %S,", 

                         &aURI, &aLUID )

    TInt snapId = MapPredefinedSnapsL( aURI, aLUID );

    // check if parent snap node is buffered 

    CSmlDmBmSettingsElement* snap = 

    GetSnapIfBuffered( RemoveLastURISeg( aURI ) );

    // data for buffered SNAP -> Store command into buffer    

    if ( snap )

        {

        CSmlDmBmCommandElement* cmd = 

        CSmlDmBmCommandElement::NewLC( ETrue, 

                                       aStatusRef, 

                                       aResultsRef, 

                                       CNSmlDmBmAdapter::EGetSizeCmd,

                                       LastURISeg( aURI ), 

                                       KNullDesC8);

        snap->NodeBuf().AppendL( cmd );