/*

* 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:  DCMO DM Adapter implementation

*

*/

// INCLUDE

#include <implementationproxy.h>

#include <smldmadapter.h>

#include <data_caging_path_literals.hrh>

#include <centralrepository.h>

#include <e32base.h>

#include <ecom.h>

#include <utf.h>

#include <SettingEnforcementInfo.h> // DCMO Enforcement

#include "nsmldebug.h"

#include "dcmodmadapter.h"

#include "dcmointerface.h"

// CONSTANTS

#define MAXBUFLEN 255

_LIT8( KTextType,"text/plain" ); // Leaf inputs

_LIT8( KDCMODMAdapterVersion, "1.0" ); // Adapter version

_LIT8( KDCMORootNode, "DCMO" ); // root URI

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

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

// CDcmoDMAdapter::NewL

// Symbian 1st phase contructor

// (static, may leave)

// Status : Draft

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

//

CDcmoDMAdapter* CDcmoDMAdapter::NewL( MSmlDmCallback* aCallback )

    {

    CDcmoDMAdapter* self = NewLC( aCallback );

    CleanupStack::Pop( self );

    return self;

    }

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

// CDcmoDMAdapter::NewLC

// Symbian 1st phase contructor. Push object to cleanup-stack

// (static, may leave)

// Status : Draft

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

//

CDcmoDMAdapter* CDcmoDMAdapter::NewLC( MSmlDmCallback* aCallback )

    {

    	_DBG_FILE( "CDcmoDMAdapter NewLC : begin"  );

    	CDcmoDMAdapter* self = new ( ELeave ) CDcmoDMAdapter( aCallback );

    	CleanupStack::PushL( self );

    	self->ConstructL();

    	_DBG_FILE( "CDcmoDMAdapter NewLC : end"  );

    	return self;

    }

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

// CDcmoDMAdapter::CDcmoDMAdapter()

// C++ Constructor

// Status : Draft

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

CDcmoDMAdapter::CDcmoDMAdapter( TAny* aEcomArguments )

    : CSmlDmAdapter::CSmlDmAdapter( aEcomArguments )

    {

    	_DBG_FILE( "CDcmoDMAdapter Constructor"  );

    }

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

// CDcmoDMAdapter::ConstructL

// 2nd phase contructor

// (may leave)

// Status : Draft

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

//

void CDcmoDMAdapter::ConstructL()

    {

    	_DBG_FILE( "CDcmoDMAdapter::ConstructL"  );

    	idcmoClient = RDCMOClient::NewL();

    	iExtOpNode = EFalse;	

    }

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

// CDcmoDMAdapter::~CDcmoDMAdapter()

// C++ Destructor

// Status : Draft

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

//

CDcmoDMAdapter::~CDcmoDMAdapter()

    {

    	_DBG_FILE( "CDcmoDMAdapter Destructor"  );

    	if( idcmoClient )

    		{

    			idcmoClient->Close();

    			delete idcmoClient;

    		}

    	idcmoClient = NULL;

    }

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

// CDcmoDMAdapter::DDFVersionL

// Return DM plug-in version

// (may leave)

// Status : Draft

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

//

void CDcmoDMAdapter::DDFVersionL( CBufBase& aDDFVersion )

    {

    // Insert version information

    _DBG_FILE( "CDcmoDMAdapter::DDFVersionL" );

    aDDFVersion.InsertL( 0, KDCMODMAdapterVersion );

    }

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

// CDcmoDMAdapter::DDFStructureL

// Return DM plug-in structure

// (may leave)

// Status : Draft

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

//

void CDcmoDMAdapter::DDFStructureL( MSmlDmDDFObject& aDDF )

    {

    // Declare accesses

    _DBG_FILE( "CDcmoDMAdapter::DDFStructureL begin" );

    TSmlDmAccessTypes accessTypes;

    accessTypes.SetGet();    

    // Create root node 

    MSmlDmDDFObject& root = aDDF.AddChildObjectL( KDCMORootNode );

    FillNodeInfoL( root,

                   accessTypes,

                   MSmlDmDDFObject::EPermanent,

                   MSmlDmDDFObject::ENode,

                   MSmlDmDDFObject::EOne,

                   KNullDesC8(),

                   KTextType );

   	root.SetDFTitleL( KNSmlDCMOAdapterTitle );

   	DDFDCMOAdaptersL(root);

   	_DBG_FILE( "CDcmoDMAdapter::DDFStructureL end" );

    }

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

// CDcmoDMAdapter::StreamingSupport

// Return streaming support status, set supported item size

// Status : Draft

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

//

TBool CDcmoDMAdapter::StreamingSupport( TInt& /* aItemSize */ )

    {

    // Not supported

    _DBG_FILE( "CDcmoDMAdapter::StreamingSupport"  );

    return EFalse;

    }

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

// CDcmoDMAdapter::StreamCommittedL

// Commit stream buffer

// (may leave)

// Status : Draft

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

//

void CDcmoDMAdapter::StreamCommittedL()

    {        

    _DBG_FILE("CDcmoDMAdapter::StreamCommitted"  );

    // Intentionally left empty 

    }

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

// CDcmoDMAdapter::CompleteOutstandingCmdsL

// Complete outstanding commands

// (may leave)

// Status : Draft

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

//

void CDcmoDMAdapter::CompleteOutstandingCmdsL()

    {

    _DBG_FILE( "CDcmoDMAdapter::CompleteOutstandingCmdsL"  );

    }

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

// CDcmoDMAdapter::FillNodeInfoL

// Fill node info

// (may leave)

// Status : Draft

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

//

void CDcmoDMAdapter::FillNodeInfoL( MSmlDmDDFObject& aDDFObject, 

                                     TSmlDmAccessTypes& aAccessTypes, 

                                     MSmlDmDDFObject::TScope aScope,

                                     MSmlDmDDFObject::TDFFormat aFormat, 

                                     MSmlDmDDFObject::TOccurence aOccurence,

                                     const TDesC8& aDescription,

                                     const TDesC8& aMIMEType )

    {

    _DBG_FILE( "CDcmoDMAdapter::FillNodeInfoL - begin"  );

    aDDFObject.SetAccessTypesL( aAccessTypes );

    aDDFObject.SetScopeL( aScope );

    aDDFObject.SetOccurenceL( aOccurence );

    aDDFObject.SetDFFormatL( aFormat );

    aDDFObject.SetDescriptionL( aDescription );

    if ( aFormat != MSmlDmDDFObject::ENode )

        {

        aDDFObject.AddDFTypeMimeTypeL( aMIMEType );

        }

    _DBG_FILE( "CDcmoDMAdapter::FillNodeInfoL - end"  );    

    }

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

// CDcmoDMAdapter::CopyCommandL

// Copy object

// (may leave)

// Status : Draft

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

//

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

                                    const TDesC8& /*aTargetLUID*/,

                                    const TDesC8& /*aSourceURI*/, 

                                    const TDesC8& /*aSourceLUID*/,

                                    const TDesC8& /*aType*/, 

                                    TInt aStatusRef )

    {

    // Not supported

    _DBG_FILE( "CDcmoDMAdapter::CopyCommandL"  );

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

    }

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

// DeleteObjectL

// Delete object

// (may leave)

// Status : Draft

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

//

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

                                     const TDesC8& /* aLUID */,

                                     TInt aStatusRef )

    {

    // Not supported

    _DBG_FILE( "CDcmoDMAdapter::DeleteObjectL"  );

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

    }

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

// CDcmoDMAdapter::FetchLeafObjectL

// Fetch leaf

// (may leave)

// Status : Draft

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

//

void CDcmoDMAdapter::FetchLeafObjectL( const TDesC8& aURI, 

                                        const TDesC8& /* aLUID */,

								        const TDesC8& aType, 

								        TInt aResultsRef,

								        TInt aStatusRef )

    {

    _DBG_FILE( "CDcmoDMAdapter::FetchLeafObjectL - begin"  );

    MSmlDmAdapter::TError retValue = CSmlDmAdapter::EOk; 

		TDCMOStatus err (EDcmoFail);

    TBool dcmoEnforce=EFalse;

	  TRAPD(eError, dcmoEnforce =CheckEnforcementL())

	  if(!(eError==KErrNone && dcmoEnforce))

	  {

	  	 // Respond

	  	retValue = CSmlDmAdapter::ENotAllowed;

  		Callback().SetStatusL( aStatusRef, retValue );

  		return;

	  }

		TBuf<MAXBUFLEN> iName;

		TPtrC8 category = GetCategoryFromUriL( aURI );

		iName.Copy ( category );

		CBufBase *lObject = CBufFlat::NewL( 128 );

    CleanupStack::PushL( lObject );

    lObject->Reset();

    TBool value;

    TInt group;

		if(aURI.Find(KNSmlDdfProperty)!= KErrNotFound)

		{

			 _DBG_FILE( "CDcmoDMAdapter::FetchLeafObjectL - In Property"  );

			TBuf<KDCMOMaxStringSize> property;

			err = idcmoClient->GetDCMOStrAttributeValue(iName, EProperty,property); 

			lObject->Reset();

			TBuf8<KDCMOMaxStringSize> tmp;

			tmp.Copy(property);

			lObject->InsertL(lObject->Size(),tmp);

		}

		else if(aURI.Find(KNSmlDdfGroup)!= KErrNotFound)

		{

			 _DBG_FILE( "CDcmoDMAdapter::FetchLeafObjectL - In Group"  );

			err = idcmoClient->GetDCMOIntAttributeValue(iName, EGroup, group); 

			switch(group)

			{

				case EHardware			: 	lObject->InsertL(lObject->Size(),KNSmlHardware);

										break;

				case EIO						:	lObject->InsertL(lObject->Size(),KNSmlIO);

										break;

				case EConnectivity	:	lObject->InsertL(lObject->Size(),KNSmlConnectivity);

										break;

				case ESoftware			:	lObject->InsertL(lObject->Size(),KNSmlSoftware);

										break;

				case EService				:	lObject->InsertL(lObject->Size(),KNSmlService);

										break;	

				default : retValue = CSmlDmAdapter::ENotFound;

			}

		}			

		else if(aURI.Find(KNSmlDdfDescription)!= KErrNotFound)

		{

			 _DBG_FILE( "CDcmoDMAdapter::FetchLeafObjectL - In Description"  );

			TBuf<KDCMOMaxStringSize> description;

			err = idcmoClient->GetDCMOStrAttributeValue(iName, EDescription, description); 

			lObject->Reset();

			TBuf8<KDCMOMaxStringSize> tmp;

			tmp.Copy(description);

			lObject->InsertL(lObject->Size(),tmp);

		}

		else if(aURI.Find(KNSmlDdfAttached)!= KErrNotFound)

		{

			 _DBG_FILE( "CDcmoDMAdapter::FetchLeafObjectL - In Attached"  );

			err = idcmoClient->GetDCMOIntAttributeValue(iName, EAttached, value); 

			if(value)

				lObject->InsertL(lObject->Size(),KNSmlTrue);

			else

				lObject->InsertL(lObject->Size(),KNSmlFalse);

		}

		else if(aURI.Find(KNSmlDdfEnabled)!= KErrNotFound) 

		{

			 _DBG_FILE( "CDcmoDMAdapter::FetchLeafObjectL - In Enabled"  );

			err = idcmoClient->GetDCMOIntAttributeValue(iName, EEnabled, value); 

			if(value)

				lObject->InsertL(lObject->Size(),KNSmlTrue);

			else

				lObject->InsertL(lObject->Size(),KNSmlFalse);			

		}

		else if(aURI.Find(KNSmlDdfDenyUserEnable)!= KErrNotFound)

		{

			 _DBG_FILE( "CDcmoDMAdapter::FetchLeafObjectL - In DenyUserEnable"  );

			err = idcmoClient->GetDCMOIntAttributeValue(iName, EDenyUserEnable, value); 

			if(value)

				lObject->InsertL(lObject->Size(),KNSmlTrue);

			else

				lObject->InsertL(lObject->Size(),KNSmlFalse);

		}

		else if(aURI.Find(KNSmlDdfNotifyUser)!= KErrNotFound)

		{

			 _DBG_FILE( "CDcmoDMAdapter::FetchLeafObjectL - In NotifyUser"  );

			err = idcmoClient->GetDCMOIntAttributeValue(iName, ENotifyUser, value); 

			if(value)

				lObject->InsertL(lObject->Size(),KNSmlTrue);

			else

				lObject->InsertL(lObject->Size(),KNSmlFalse);

		}

		else if(aURI.Find(KNSmlDdfExt)!= KErrNotFound)

		{

			_DBG_FILE( "CDcmoDMAdapter::FetchLeafObjectL - In Ext"  );

			lObject->Reset();

			lObject->InsertL(lObject->Size(), KNullDesC8);

			err = EDcmoSuccess;

		}

		else

			retValue = CSmlDmAdapter::ENotFound;

		if(retValue == CSmlDmAdapter::EOk)

    {

			switch(err)

			{

				case EDcmoSuccess 		:	Callback().SetResultsL( aResultsRef, *lObject, aType );

											break;

				case EDcmoNotSupported	:	retValue = CSmlDmAdapter::EError;

											break;

				case EDcmoAccessDenied	:	retValue = CSmlDmAdapter::ENotAllowed;

											break;

				default :

											retValue = CSmlDmAdapter::EError;						

			}

  	}

    CleanupStack::PopAndDestroy(); //lObject	

    // Respond

  Callback().SetStatusL( aStatusRef, retValue );

   _DBG_FILE( "CDcmoDMAdapter::FetchLeafObjectL - end"  );

    }    

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

// CDcmoDMAdapter::FetchLeafObjectSizeL

// Calculate leaf object size

// (may leave)

// Status : Draft

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

//

void CDcmoDMAdapter::FetchLeafObjectSizeL( const TDesC8& /* aURI */, 

                                            const TDesC8& /* aLUID */,

									        const TDesC8& /* aType */, 

									        TInt /* aResultsRef */,

									        TInt aStatusRef )

    {

    _DBG_FILE( "CDcmoDMAdapter::FetchLeafObjectSizeL"  );

    MSmlDmAdapter::TError retValue = CSmlDmAdapter::EOk;

    // Respond

    Callback().SetStatusL( aStatusRef, retValue );

    }    

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

// CDcmoDMAdapter::ChildURIListL

// Create child URI list

// (may leave)

// Status : Draft

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

//

void CDcmoDMAdapter::ChildURIListL( const TDesC8& aURI, 

                                     const TDesC8& /* aLUID */,

					                 const CArrayFix<TSmlDmMappingInfo>& /* aPreviousURISegmentList */,

            					     TInt aResultsRef, 

            					     TInt aStatusRef )

    {

    _DBG_FILE( "CDcmoDMAdapter::ChildURIListL - begin"  );

    MSmlDmAdapter::TError retValue = CSmlDmAdapter::EOk;

    CBufBase *currentURISegmentList = CBufFlat::NewL( 128 );

		CleanupStack::PushL( currentURISegmentList );	

 		if(( aURI.Match( KDcmoMatch2 ) != KErrNotFound ) &&

		 (aURI.Match( KDcmoMatch3 ) == KErrNotFound ))

		{	

            currentURISegmentList->InsertL( currentURISegmentList->Size(), KSegmDcmo );

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

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

            CleanupStack::PopAndDestroy(  ); // currentURISegmentList

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

			return;

		}

    else if(( aURI.Match( KDcmoMatch ) != KErrNotFound ) &&

              (aURI.Match( KDcmoMatch2 ) == KErrNotFound ))

        {

        //    

        }

    // DCMOConfig subtree

    else if( ( aURI.Match( KDcmoConfigMatch ) != KErrNotFound ))

        {

          currentURISegmentList->InsertL( currentURISegmentList->Size(), KSegmDcmoConfig );

        }

    // Operations    

    else if(( aURI.Match( KDcmoOperationsMatch ) != KErrNotFound ))

        {

          currentURISegmentList->InsertL( currentURISegmentList->Size(), KSegmDcmoOperations );

        } 

    // Ext    

    else if(( aURI.Match(KNSmlBluetooth) != KErrNotFound) && ( aURI.Match(KDcmoOperationsExtMatch)!= KErrNotFound ))

        {

          currentURISegmentList->InsertL( currentURISegmentList->Size(), KNSmlDdfOpExtSemiEnable );

        }        

    else

        {

        retValue = CSmlDmAdapter::ENotFound;

        }

    // Respond

    Callback().SetStatusL( aStatusRef, retValue );

    CleanupStack::PopAndDestroy(); // currentURISegmentList

    _DBG_FILE( "CDcmoDMAdapter::ChildURIListL - end"  );

    }    

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

// CDcmoDMAdapter::AddNodeObjectL

// Add node

// (may leave)

// Status : Draft

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

//

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

                                     const TDesC8& /* aParentLUID */,

								     TInt aStatusRef )

    {

    // Not supported

    _DBG_FILE( "CDcmoDMAdapter::AddNodeObjectL - begin"  );

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

    _DBG_FILE( "CDcmoDMAdapter::AddNodeObjectL - end"  );

    }    

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

// CDcmoDMAdapter::ExecuteCommandL

// Execute command

// (may leave)

// Status : Draft

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

//

void CDcmoDMAdapter::ExecuteCommandL( const TDesC8&  aURI , 

                                      const TDesC8& /* aLUID */,

							          const TDesC8& /* aArgument */, 

							          const TDesC8& /* aType */,

								      TInt aStatusRef )

    {

    _DBG_FILE( "CDcmoDMAdapter::ExecuteCommandL - begin"  );

   	MSmlDmAdapter::TError status = CSmlDmAdapter::EOk;

    TInt err (EDcmoFail);

    TBool dcmoEnforce=EFalse;

	  TRAPD(eError, dcmoEnforce =CheckEnforcementL())