/*

* 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 <centralrepository.h>

#include <e32base.h>

#include <ecom.h>

#include <utf.h>

#include <lawmoadaptercrkeys.h>

#include <DevManInternalCRKeys.h>

#include <SyncMLClientDM.h>  // syncmlclientapi.lib

#include <NSmlPrivateAPI.h> // Generic alert

#include <nsmlconstants.h>

#include <TerminalControl3rdPartyAPI.h>

#include <coreapplicationuisdomainpskeys.h>

#include <lawmointerface.h>

//User Include

#include "lawmodmadapter.h"

#include "nsmldebug.h"

#include "nsmldmuri.h"

#include "TPtrC8I.h"

#include "lawmodebug.h"

// CONSTANTS

#define MAXBUFLEN 255

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

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

// CLawmoDMAdapter::NewL

// Symbian 1st phase contructor

// (static, may leave)

// Status : Draft

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

//

CLawmoDMAdapter* CLawmoDMAdapter::NewL( MSmlDmCallback* aCallback )

    {

    RDEBUG( "CLawmoDMAdapter NewL: begin"  );

    CLawmoDMAdapter* self = NewLC( aCallback );

    CleanupStack::Pop( self );

    return self;

    }

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

// CLawmoDMAdapter::NewLC

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

// (static, may leave)

// Status : Draft

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

//

CLawmoDMAdapter* CLawmoDMAdapter::NewLC( MSmlDmCallback* aCallback )

    {

    	RDEBUG( "CLawmoDMAdapter NewLC : begin"  );

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

    	CleanupStack::PushL( self );

    	self->ConstructL();

    	RDEBUG( "CLawmoDMAdapter NewLC : end"  );

    	return self;

    }

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

// CLawmoDMAdapter::CLawmoDMAdapter()

// C++ Constructor

// Status : Draft

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

CLawmoDMAdapter::CLawmoDMAdapter( TAny* aEcomArguments )

    : CSmlDmAdapter::CSmlDmAdapter( aEcomArguments )

    {

    	RDEBUG( "CLawmoDMAdapter default constructor"  );

    }

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

// CLawmoDMAdapter::ConstructL

// 2nd phase contructor

// (may leave)

// Status : Draft

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

//

void CLawmoDMAdapter::ConstructL()

    {

    	RDEBUG( "CLawmoDMAdapter::ConstructL"  );

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

        RDEBUG( "CLawmoDMAdapter::session connected"  );

        iRootNode.Zero();

        TBuf<MAXBUFLEN> temp; 

        CRepository *repository=CRepository::NewLC ( KCRUidLawmoAdapter );

        repository->Get(KLawmoRootNode,temp);

        iRootNode.Copy(temp);

        CleanupStack::PopAndDestroy();

    }

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

// CLawmoDMAdapter::~CLawmoDMAdapter()

// C++ Destructor

// Status : Draft

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

//

CLawmoDMAdapter::~CLawmoDMAdapter()

    {

    	RDEBUG( "CLawmoDMAdapter Destructor"  );

    	ilawmoSession.Close();

    }

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

// CLawmoDMAdapter::DDFVersionL

// Return DM plug-in version

// (may leave)

// Status : Draft

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

//

void CLawmoDMAdapter::DDFVersionL( CBufBase& aDDFVersion )

    {

    // Insert version information

    RDEBUG( "CLawmoDMAdapter::DDFVersionL" );

    aDDFVersion.InsertL( 0, KLAWMODMAdapterVersion );

    }

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

// CLawmoDMAdapter::DDFStructureL

// Return DM plug-in structure

// (may leave)

// Status : Draft

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

//

void CLawmoDMAdapter::DDFStructureL( MSmlDmDDFObject& aDDF )

    {

    // Declare accesses

    RDEBUG( "CLawmoDMAdapter::DDFStructureL begin" );

    TSmlDmAccessTypes accessTypes;

    accessTypes.SetGet();    

    // Create root node 

    MSmlDmDDFObject& root = aDDF.AddChildObjectL( iRootNode );

    FillNodeInfoL( root,

                   accessTypes,

                   MSmlDmDDFObject::EPermanent,

                   MSmlDmDDFObject::ENode,

                   MSmlDmDDFObject::EOne,

                   KNullDesC8(),

                   KMimeType );

   	root.SetDFTitleL( KNSmlLAWMOAdapterTitle );

   	FillLAWMODDFL(root);

   	RDEBUG( "CLawmoDMAdapter::DDFStructureL end" );

    }

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

// CLawmoDMAdapter::StreamingSupport

// Return streaming support status, set supported item size

// Status : Draft

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

//

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

    {

    // Not supported

    RDEBUG( "CLawmoDMAdapter::StreamingSupport"  );

    return EFalse;

    }

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

// CLawmoDMAdapter::StreamCommittedL

// Commit stream buffer

// (may leave)

// Status : Draft

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

//

void CLawmoDMAdapter::StreamCommittedL()

    {        

    RDEBUG("CLawmoDMAdapter::StreamCommitted"  );

    // Intentionally left empty 

    }

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

// CLawmoDMAdapter::CompleteOutstandingCmdsL

// Complete outstanding commands

// (may leave)

// Status : Draft

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

//

void CLawmoDMAdapter::CompleteOutstandingCmdsL()

    {

    RDEBUG( "CLawmoDMAdapter::CompleteOutstandingCmdsL"  );

    }

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

// CLawmoDMAdapter::FillNodeInfoL

// Fill node info

// (may leave)

// Status : Draft

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

//

void CLawmoDMAdapter::FillNodeInfoL( MSmlDmDDFObject& aDDFObject, 

                                     TSmlDmAccessTypes& aAccessTypes, 

                                     MSmlDmDDFObject::TScope aScope,

                                     MSmlDmDDFObject::TDFFormat aFormat, 

                                     MSmlDmDDFObject::TOccurence aOccurence,

                                     const TDesC8& aDescription,

                                     const TDesC8& aMIMEType )

    {

    RDEBUG( "CLawmoDMAdapter::FillNodeInfoL - begin"  );

    aDDFObject.SetAccessTypesL( aAccessTypes );

    aDDFObject.SetScopeL( aScope );

    aDDFObject.SetOccurenceL( aOccurence );

    aDDFObject.SetDFFormatL( aFormat );

    aDDFObject.SetDescriptionL( aDescription );

    if ( aFormat != MSmlDmDDFObject::ENode )

        {

        aDDFObject.AddDFTypeMimeTypeL( aMIMEType );

        }

    RDEBUG( "CLawmoDMAdapter::FillNodeInfoL - end"  );    

    }

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

// CLawmoDMAdapter::CopyCommandL

// Copy object

// (may leave)

// Status : Draft

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

//

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

                                    const TDesC8& /*aTargetLUID*/,

                                    const TDesC8& /*aSourceURI*/, 

                                    const TDesC8& /*aSourceLUID*/,

                                    const TDesC8& /*aType*/, 

                                    TInt aStatusRef )

    {

    // Not supported

    RDEBUG( "CLawmoDMAdapter::CopyCommandL"  );

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

    }

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

// DeleteObjectL

// Delete object

// (may leave)

// Status : Draft

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

//

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

                                     const TDesC8& /* aLUID */,

                                     TInt aStatusRef )

    {

    // Not supported

    RDEBUG( "CLawmoDMAdapter::DeleteObjectL"  );

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

    }

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

// CLawmoDMAdapter::FetchLeafObjectL

// Fetch leaf

// (may leave)

// Status : Draft

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

//

void CLawmoDMAdapter::FetchLeafObjectL( const TDesC8& aURI, 

                                        const TDesC8& aLUID,

								        const TDesC8& aType, 

								        TInt aResultsRef,

								        TInt aStatusRef )

    {

    RDEBUG("CLawmoDMAdapter::FetchLeafObjectL() Begin");

    TPtrC8 uriPtrc = NSmlDmURI::RemoveDotSlash( aURI );

    CBufFlat *lObject = CBufFlat::NewL( MAXBUFLEN );

    CleanupStack::PushL( lObject );

    lObject->Reset();

    TInt err = InternalFetchObjectL( uriPtrc, aLUID, aType, lObject, aStatusRef );

    if((err == ELawMoSuccess)||(err == ELawMoOk))

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

    CSmlDmAdapter::TError status =  MapErrorToStatus( err );

    Callback().SetStatusL( aStatusRef, status );

    CleanupStack::PopAndDestroy( lObject );

    RDEBUG("CLawmoDMAdapter::FetchLeafObjectL() End");

    }

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

//InternalFetchObjectL

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

TInt CLawmoDMAdapter::InternalFetchObjectL( const TDesC8& aURI, 

                                              const TDesC8& /*aLUID*/,

                                              const TDesC8& /*aType*/, 

                                              CBufFlat* aObject,

                                              TInt aStatusRef )

    {    

    RDEBUG("CLawmoDMAdapter::InternalFetchObjectL() Begin");

    CLawmoDMAdapter::TNodeIdentifier identifier = GetNodeIdentifier(aURI);

    TInt numOfSegs = NSmlDmURI::NumOfURISegs( aURI ) ;

    TInt err (ELawMoInvalid);

    switch(identifier)

       {

       case CLawmoDMAdapter::ENodeState:

            {

            RDEBUG("CLawmoDMAdapter::InternalFetchObjectL ENodeState");

            TInt state;

            err = GetStateL(state);

            TBuf8<MAXBUFLEN> tmp;

            tmp.Num(state);

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

            }

       break;

       case CLawmoDMAdapter::ENodeItemName:

           {

           RDEBUG("CLawmoDMAdapter::InternalFetchObjectL ENodeItemName");

           TBuf<MAXBUFLEN> val;

           TBuf<MAXBUFLEN> property;

           TPtrC8 seg = NSmlDmURI::URISeg(aURI, numOfSegs-2);

		   property.Copy(seg);

           err = ilawmoSession.GetListItemName(property, val);

           TBuf8<MAXBUFLEN> tmp;

           tmp.Copy(val);

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

           }

       break;

       case CLawmoDMAdapter::ENodeToBeWiped:

           {

           RDEBUG("CLawmoDMAdapter::InternalFetchObjectL ENodeToBeWiped");

           TBool val;

           TBuf<MAXBUFLEN> property;

           TPtrC8 seg = NSmlDmURI::URISeg(aURI, numOfSegs-2);

		   property.Copy(seg);

           err = ilawmoSession.GetToBeWipedValue(property, val);

           TBuf8<MAXBUFLEN> tmp;           

           if(val)

               tmp.Copy(KNSmlTrue);

           else

               tmp.Copy(KNSmlFalse);

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

           }

       break;

       case CLawmoDMAdapter::ENodeWipe:

           {

           RDEBUG("CLawmoDMAdapter::InternalFetchObjectL ENodeWipe");

           err = ELawMoSuccess;

           TBuf8<MAXBUFLEN> tmp;

           tmp.Zero();

           RDEBUG("CLawmoDMAdapter::InternalFetchObjectL Null value return");

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

           }

           break;

       default:

           err = ELawMoUnknown;

       break;

       }

     RDEBUG("CLawmoDMAdapter::InternalFetchObjectL() End");

     return err;     

    }

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

// CLawmoDMAdapter::FetchLeafObjectSizeL

// Calculate leaf object size

// (may leave)

// Status : Draft

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

//

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

                                            const TDesC8& /* aLUID */,

									        const TDesC8& /* aType */, 

									        TInt /* aResultsRef */,

									        TInt aStatusRef )

    {

    RDEBUG( "CLawmoDMAdapter::FetchLeafObjectSizeL"  );

    MSmlDmAdapter::TError retValue = CSmlDmAdapter::EOk;

    // Respond

    Callback().SetStatusL( aStatusRef, retValue );

    }    

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

// CLawmoDMAdapter::ChildURIListL

// Create child URI list

// (may leave)

// Status : Draft

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

//

void CLawmoDMAdapter::ChildURIListL( const TDesC8& aURI, 

                                     const TDesC8& /* aLUID */,

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

            					     TInt aResultsRef, 

            					     TInt aStatusRef )

    {

    RDEBUG( "CLawmoDMAdapter::ChildURIListL - begin"  );

    MSmlDmAdapter::TError retValue = CSmlDmAdapter::EOk;

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

	CleanupStack::PushL( currentURISegmentList );

	// Bcoz root node is configurable, remove the node for this operation.

    TPtrC8 uriPtrc = NSmlDmURI::RemoveFirstSeg(aURI);

    if( uriPtrc == KNullDesC8)

    {	

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

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

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

        CleanupStack::PopAndDestroy(  ); // currentURISegmentList

        RDEBUG( "CLawmoDMAdapter::ChildURIListL(): end" );

        return;

    }

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

            (aURI.Match( KLawmoAvWipe2 ) == KErrNotFound ))

        {

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

        }

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

        {

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

        }

    // Operations    

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

        {

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

        } 

    // Ext    

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

        {

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

        }        

    else

        {

        retValue = CSmlDmAdapter::ENotFound;

        }

    Callback().SetStatusL( aStatusRef, retValue );

    CleanupStack::PopAndDestroy(); // currentURISegmentList

    RDEBUG( "CLawmoDMAdapter::ChildURIListL - end"  );

    }    

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

// CLawmoDMAdapter::AddNodeObjectL

// Add node

// (may leave)

// Status : Draft

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

//

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

                                     const TDesC8& /* aParentLUID */,

								     TInt aStatusRef )

    {

    // Not supported

    RDEBUG( "CLawmoDMAdapter::AddNodeObjectL - begin"  );

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

    RDEBUG( "CLawmoDMAdapter::AddNodeObjectL - end"  );

    }    

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

// CLawmoDMAdapter::ExecuteCommandL

// Execute command

// (may leave)

// Status : Draft

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

//

void CLawmoDMAdapter::ExecuteCommandL( const TDesC8&  aURI , 

                                      const TDesC8& /* aLUID */,

							          const TDesC8&  aArgument, 

							          const TDesC8& /* aType */,

								      TInt aStatusRef )

    {

    RDEBUG("CLawmoDMAdapter::ExecuteCommandL() Begin");

    CSmlDmAdapter::TError status;

    if(IsFactoryProfileL())

        {

        RDEBUG("CLawmoDMAdapter::ExecuteCommandL() its factory prof");

        SetCurrentServerIdL();

        TPtrC8 uriPtrc = NSmlDmURI::RemoveDotSlash( aURI );

        CLawmoDMAdapter::TNodeIdentifier identifier = GetNodeIdentifier(uriPtrc);

        TLawMoStatus err(ELawMoSuccess);

        RDEBUG_2("ExecuteCommandL executing %d", identifier);

        switch(identifier)

            {

            case ENodePartLock:

            err = LockDeviceL();

            break;

            case ENodeUnlock:

            err = UnLockDeviceL();

            break;

            case ENodeWipe:

            {

            //Write correlator id into the cenrep            

            /********* disable this comment after correlator is added

            CRepository* crep = NULL;

            crep = CRepository::NewLC( KCRUidLawmoAdapter );

            RDEBUG("CLawmoDMAdapter::SetCurrentServerId() cenrep1");

            TInt reterr = crep->Set( KLawmoCorrelator, aArgument );

            CleanupStack::PopAndDestroy(crep);*/            

            err = ilawmoSession.DeviceWipe();

            }

            break;

            case ENodeWipeAll:

            err = ilawmoSession.DeviceWipeAll();

            break;  

            default:

            err = ELawMoUnknown;

            break;           

            }