/*

* 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:    DM OMA XDM Settings Adapter

 *

*/

#include <implementationproxy.h>

#include <utf.h>

#include <nsmldmuri.h>

#include <XdmSettingsApi.h>

#include <XdmSettingsCollection.h>

#include <XdmSettingsProperty.h>

#include "xdmdmadapter.h"

#ifdef _DEBUG

    #include <flogger.h>

#endif

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

// CXdmDMAdapter::NewL( )

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

//

CXdmDMAdapter* CXdmDMAdapter::NewL( MSmlDmCallback* aDmCallback )

    {

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

#ifdef _DEBUG

    WriteToLog(_L8("CXdmDMAdapter::NewL(): end") );

#endif

    return self;

    }

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

// CXdmDMAdapter::CXdmDMAdapter()

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

//

CXdmDMAdapter::CXdmDMAdapter( MSmlDmCallback* aDmCallback ) : 

CSmlDmAdapter( aDmCallback )

    {

#ifdef _DEBUG

    WriteToLog(_L8("CXdmDMAdapter::CXdmDMAdapter()") );

#endif

    }

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

// CXdmDMAdapter::~CXdmDMAdapter()

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

//

CXdmDMAdapter::~CXdmDMAdapter()

    {

#ifdef _DEBUG

    WriteToLog(_L8("CXdmDMAdapter::~CXdmDMAdapter()") );

#endif

    }

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

//  CXdmDMAdapter::DDFVersionL

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

//

void CXdmDMAdapter::DDFVersionL( CBufBase& aDDFVersion )

    {   

    aDDFVersion.InsertL( 0, KXdmDDFVersion );

#ifdef _DEBUG

    WriteToLog(_L8("CXdmDMAdapter::DDFVersionL(TDes& aDDFVersion)") );

#endif

    }

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

//  CXdmDMAdapter::DDFStructureL

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

//

void CXdmDMAdapter::DDFStructureL( MSmlDmDDFObject& aDDF )

    {

#ifdef _DEBUG

    WriteToLog(_L8("CXdmDMAdapter::DDFStructureL(): begin") );

#endif    

    // For OMA_XDM 

    TSmlDmAccessTypes accTypeGet;

    accTypeGet.SetGet();

    // For OMA_XDM/<X> 

    TSmlDmAccessTypes accTypeAll;

    accTypeAll.SetAdd();

    accTypeAll.SetGet();

    accTypeAll.SetReplace();

    accTypeAll.SetDelete();

    // For leaf nodes

    TSmlDmAccessTypes accTypeNoDelete;

    accTypeNoDelete.SetAdd();

    accTypeNoDelete.SetGet();

    accTypeNoDelete.SetReplace();

    // ./OMA_XDM

    MSmlDmDDFObject& omaXdmNode = aDDF.AddChildObjectL( KXdmDmNodeName );

    FillNodeInfoL( omaXdmNode, accTypeGet, MSmlDmDDFObject::EOne,

                  MSmlDmDDFObject::EPermanent, MSmlDmDDFObject::ENode,

                  KXdmDmNodeNameDescription );

    // ./OMA_XDM/<X> 

    MSmlDmDDFObject& rtNode = omaXdmNode.AddChildObjectGroupL();

    FillNodeInfoL( rtNode, accTypeAll, MSmlDmDDFObject::EOneOrMore,

                  MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::ENode,

                  KXdmDmDynamicDescription );

    // ./OMA_XDM/<X>/APPID            

    MSmlDmDDFObject& appIdNode = rtNode.AddChildObjectL( KXdmDmAppId );

    FillNodeInfoL( appIdNode, accTypeNoDelete, MSmlDmDDFObject::EZeroOrOne,

                  MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::EChr,

                  KXdmDmAppIdDescription );

    // ./OMA_XDM/<X>/NAME            

    MSmlDmDDFObject& nameNode = rtNode.AddChildObjectL( KXdmDmName );

    FillNodeInfoL( nameNode, accTypeNoDelete, MSmlDmDDFObject::EZeroOrOne,

                  MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::EChr,

                  KXdmDmNameDescription );

    // ./OMA_XDM/<X>/PROVIDER-ID           

    MSmlDmDDFObject& provIdNode = rtNode.AddChildObjectL( KXdmDmProviderId );

    FillNodeInfoL( provIdNode, accTypeNoDelete,MSmlDmDDFObject::EZeroOrOne,

                  MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::EChr,

                  KXdmDmProviderIdDescription );    

    // ./OMA_XDM/<X>/ToConRef

    MSmlDmDDFObject& toConRefNode = rtNode.AddChildObjectL( KXdmDmToConRef );

    FillNodeInfoL( toConRefNode, accTypeNoDelete, MSmlDmDDFObject::EZeroOrOne,

                  MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::ENode,

                  KXdmDmToConRefDescription);

    // ./OMA_XDM/<X>/ToConRef/<X> (TO-NAPID)          

    MSmlDmDDFObject& napIdNode = toConRefNode.AddChildObjectL( KXdmDmToNapId );

    FillNodeInfoL( napIdNode, accTypeNoDelete, MSmlDmDDFObject::EZeroOrOne, 

                  MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::ENode,

                  KXdmDmToNapIdDescription );                 

    // ./OMA_XDM/<X>/ToConRef/TO-NAPID/ConRef                                             

    MSmlDmDDFObject& napIdRefNode = napIdNode.AddChildObjectL( KXdmDmConRef );

    FillNodeInfoL( napIdRefNode, accTypeNoDelete, MSmlDmDDFObject::EZeroOrOne, 

                  MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::EChr,

                  KXdmDmConRefDescription );

    // ./OMA_XDM/<X>/ToConRef/<X> (SIP)          

    MSmlDmDDFObject& sipNode = toConRefNode.AddChildObjectL( KXdmDmSip );

    FillNodeInfoL( sipNode, accTypeNoDelete, MSmlDmDDFObject::EZeroOrOne, 

                  MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::ENode,

                  KXdmDmSipDescription );                 

    // ./OMA_XDM/<X>/ToConRef/SIP/ConRef                                             

    MSmlDmDDFObject& sipRefNode = sipNode.AddChildObjectL( KXdmDmConRef );

    FillNodeInfoL( sipRefNode, accTypeNoDelete, MSmlDmDDFObject::EZeroOrOne, 

                  MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::EChr,

                  KXdmDmConRefDescription );

    // ./OMA_XDM/<X>/URI          

    MSmlDmDDFObject& uriNode = rtNode.AddChildObjectL( KXdmDmUri );

    FillNodeInfoL( uriNode, accTypeNoDelete, MSmlDmDDFObject::EOne,

                  MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::EChr,

                  KXdmDmUriDescription );  

    // ./OMA_XDM/<X>/AAUTHNAME         

    MSmlDmDDFObject& userIdNode = rtNode.AddChildObjectL( KXdmDmAAuthName );

    FillNodeInfoL( userIdNode, accTypeNoDelete, MSmlDmDDFObject::EZeroOrOne,

                  MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::EChr,

                  KXdmDmAAuthNameDescription );     

    // ./OMA_XDM/<X>/AAUTHSECRET         

    MSmlDmDDFObject& pwdNode = rtNode.AddChildObjectL( KXdmDmAAuthSecret );

    FillNodeInfoL( pwdNode, accTypeNoDelete, MSmlDmDDFObject::EZeroOrOne,

                  MSmlDmDDFObject::EDynamic,MSmlDmDDFObject::EChr,

                  KXdmDmAAuthSecretDescription ); 

    // ./OMA_XDM/<X>/AAUTHTYPE         

    MSmlDmDDFObject& authTypeNode = rtNode.AddChildObjectL( KXdmDmAAuthType );

    FillNodeInfoL( authTypeNode, accTypeNoDelete, MSmlDmDDFObject::EZeroOrOne,

                  MSmlDmDDFObject::EDynamic,MSmlDmDDFObject::EChr,

                  KXdmDmAAuthTypeDescription );

#ifdef _DEBUG

    WriteToLog(_L8("CXdmDMAdapter::DDFStructureL(): end") );

#endif 

    }

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

// CXdmDMAdapter::ChildURIListL

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

//

void CXdmDMAdapter::ChildURIListL( const TDesC8& aUri, 

                                   const TDesC8& /*aLUID*/, 

                                   const CArrayFix<TSmlDmMappingInfo>& 

                                       /*aPreviousURISegmentList*/, 

                                   const TInt aResultsRef, 

                                   const TInt aStatusRef )

    {

#ifdef _DEBUG

    WriteToLog(_L8("CXdmDMAdapter::ChildURIListL(): begin") );

#endif    

    CSmlDmAdapter::TError retValue = CSmlDmAdapter::EOk;

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

    CleanupStack::PushL( currentList ); // << currentList

    const TPtrC8 lastUriSeg = NSmlDmURI::LastURISeg( aUri );

    TBuf8<KSmlMaxURISegLen> segmentName;

    // ./OMA_XDM

    if( Match( lastUriSeg, KXdmDmNodeName ) ) 

        {

        RArray<TInt> settingIds;

        CleanupClosePushL( settingIds );    // << settingIds

        CDesCArray* names = TXdmSettingsApi::CollectionNamesLC( settingIds ); // << names

        TInt idCount = settingIds.Count();

        for( TInt i(0); i < idCount; i++ )

            {

            segmentName.Copy( KNullDesC8 ); 

            segmentName.AppendNum( settingIds[i] );

            currentList->InsertL( currentList->Size(), segmentName );

            currentList->InsertL( currentList->Size(), KXdmDmSeparator );

            }

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

        Callback().SetStatusL( aStatusRef, retValue );

        return;

        }   

    // ./OMA_XDM/X   

    if( NSmlDmURI::NumOfURISegs( aUri ) == KXdmDmLevel )   

        {

        segmentName.Copy( KXdmDmAppId );

        currentList->InsertL( currentList->Size(), segmentName );

        currentList->InsertL( currentList->Size(), KXdmDmSeparator );

        segmentName.Copy( KXdmDmName );

        currentList->InsertL( currentList->Size(), segmentName );

        currentList->InsertL( currentList->Size(), KXdmDmSeparator );

        segmentName.Copy( KXdmDmProviderId );

        currentList->InsertL( currentList->Size(), segmentName );

        currentList->InsertL( currentList->Size(), KXdmDmSeparator );

        segmentName.Copy( KXdmDmToConRef );

        currentList->InsertL( currentList->Size(), segmentName );

        currentList->InsertL( currentList->Size(), KXdmDmSeparator );

        segmentName.Copy( KXdmDmUri );

        currentList->InsertL( currentList->Size(), segmentName );

        currentList->InsertL( currentList->Size(), KXdmDmSeparator );

        segmentName.Copy( KXdmDmAAuthName );

        currentList->InsertL( currentList->Size(), segmentName );

        currentList->InsertL( currentList->Size(), KXdmDmSeparator );

        segmentName.Copy( KXdmDmAAuthSecret );

        currentList->InsertL( currentList->Size(), segmentName );

        currentList->InsertL( currentList->Size(), KXdmDmSeparator );

        segmentName.Copy( KXdmDmAAuthType );

        currentList->InsertL( currentList->Size(), segmentName );

        currentList->InsertL( currentList->Size(), KXdmDmSeparator );

        }

    // ./OMA_XDM/X/ToConRef   

    else if ( Match( lastUriSeg, KXdmDmToConRef ) ) 

        {

        segmentName.Copy( KXdmDmSip );

        currentList->InsertL( currentList->Size(), segmentName );

        currentList->InsertL( currentList->Size(), KXdmDmSeparator );

        segmentName.Copy( KXdmDmToNapId );

        currentList->InsertL( currentList->Size(), segmentName );

        currentList->InsertL( currentList->Size(), KXdmDmSeparator );

        }

    // ./OMA_XDM/X/ToConRef/SIP

    else if( Match( lastUriSeg, KXdmDmSip ) ) 

        {

        segmentName.Copy( KXdmDmConRef );

        currentList->InsertL( currentList->Size(), segmentName );

        currentList->InsertL( currentList->Size(), KXdmDmSeparator );

        }

    // ./OMA_XDM/X/ToConRef/TO-NAPID

    else if( Match ( lastUriSeg, KXdmDmToNapId ) ) 

        {

        segmentName.Copy( KXdmDmConRef );

        currentList->InsertL( currentList->Size(), segmentName );

        currentList->InsertL( currentList->Size(), KXdmDmSeparator );

        }

    else

        {

        // if none of asked nodes found return error.

        retValue = CSmlDmAdapter::ENotFound;

        }

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

    Callback().SetStatusL( aStatusRef, retValue );

    CleanupStack::PopAndDestroy( currentList ); // >>> currentList  

#ifdef _DEBUG

    WriteToLog(_L8("CXdmDMAdapter::ChildURIListL(): end") );

#endif

    }    

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

//  CXdmDMAdapter::FetchLeafObjectL

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

//

void CXdmDMAdapter::FetchLeafObjectL( const TDesC8& aUri, 

                                      const TDesC8& aLUID, 

                                      const TDesC8& aType, 

                                      const TInt aResultsRef, 

                                      const TInt aStatusRef )

    {

#ifdef _DEBUG

    WriteToLog(_L8("CXdmDMAdapter::FetchLeafObjectL(): begin") );

#endif  

    TInt settingsId = FindSettingsIdL( aLUID, aUri );

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

    CleanupStack::PushL( result );    // << result

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

    if( status == CSmlDmAdapter::EOk )

        {

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

        }

    Callback().SetStatusL( aStatusRef, status );

    CleanupStack::PopAndDestroy( result );  // >>> result

#ifdef _DEBUG

    WriteToLog(_L8("CXdmDMAdapter::FetchLeafObjectL(): end") );

#endif

    }

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

// CSmlDmAdapter::TError FetchObjectL

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

//

CSmlDmAdapter::TError CXdmDMAdapter::FetchObjectL( const TDesC8& aUri, 

                                                   CBufBase& aObject,

                                                   TInt aSettingsId )

    {

#ifdef _DEBUG

    WriteToLog(_L8("CXdmDMAdapter::FetchObjectL(): begin") );

#endif    

    CSmlDmAdapter::TError status = CSmlDmAdapter::EOk;

    TXdmSettingsProperty property ( EXdmPropNotFound );

    TPtrC8 lastUriSeg = NSmlDmURI::LastURISeg( aUri );

    // APPID

    if( Match( lastUriSeg, KXdmDmAppId ) )

        {

        property = EXdmPropAppId;                          

        }

    // NAME

    else if( Match( lastUriSeg, KXdmDmName ) )

        {

        property = EXdmPropName;  

        }   

    // PROVIDER-ID  

    else if( Match( lastUriSeg, KXdmDmProviderId ) )

        {

        property = EXdmPropProvId;  

        }

    // URI

    else if( Match( lastUriSeg, KXdmDmUri) )

        {

        property = EXdmPropUri;  

        }

    // AAUTHNAME

    else if( Match( lastUriSeg, KXdmDmAAuthName) )

        {

        property = EXdmPropAuthName;  

        }

    // AAUTHSECRET

    else if( Match( lastUriSeg, KXdmDmAAuthSecret) )

        {

        property = EXdmPropAuthSecret;  

        }

    // AAUTHTYPE

    else if( Match( lastUriSeg, KXdmDmAAuthType ) )

        {

        property = EXdmPropAuthType;  

        }       

    // ToConRef/SIP/ConRef

    // ToConRef/TO-NAPID/ConRef     

    else if( Match( lastUriSeg, KXdmDmConRef) )

        {

        TPtrC8 conRefUri = NSmlDmURI::RemoveLastSeg( aUri );

        TPtrC8 lastConRefSeg = NSmlDmURI::LastURISeg( conRefUri );

        if( Match( lastConRefSeg, KXdmDmSip ) )

            {

            return FetchSipConRefL( aSettingsId, aObject );

            }  

        else if( Match( lastConRefSeg, KXdmDmToNapId ) )

            {

            HBufC* value = NULL;

            TInt error( KErrNone );

            TRAP( error, ( value = TXdmSettingsApi::PropertyL( aSettingsId, EXdmPropToNapId ) ) );

            if ( error == KErrNone )

                {

                CleanupStack::PushL( value );   // << value

                TInt iapId = DesToInt( *value ); 

                CleanupStack::PopAndDestroy( value );   // >>> value

                HBufC8* uri = URIFromIapIdL( iapId );

                if( uri )

                    {

                    CleanupStack::PushL( uri ); // << uri

                    aObject.InsertL( 0, uri->Des() );

                    status = CSmlDmAdapter::EOk;

                    CleanupStack::PopAndDestroy( uri ); // uri

                    }

                else

                    {

                    status = CSmlDmAdapter::ENotFound;

                    }

                return status;

                }

            }

        }

    else

        {

        status = CSmlDmAdapter::ENotFound;

        }

    // known property

    if ( status == CSmlDmAdapter::EOk )

        {

        status = GetPropertyL( aSettingsId, property, aObject ); 

        }

#ifdef _DEBUG

    WriteToLog(_L8("CXdmDMAdapter::FetchObjectL(): end") );

#endif    

    return status;

    }  

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

// CXdmDMAdapter::FetchLeafObjectSizeL

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

//

void CXdmDMAdapter::FetchLeafObjectSizeL( const TDesC8& aUri, 

                                          const TDesC8& aLUID, 

                                          const TDesC8& aType, 

                                          const TInt aResultsRef, 

                                          const TInt aStatusRef )

    {

#ifdef _DEBUG

    WriteToLog(_L8("CXdmDMAdapter::FetchLeafObjectSizeL(): begin") );

#endif

    TInt settingsId = FindSettingsIdL( aLUID, aUri );

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

    CleanupStack::PushL( result );

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

    if( status == CSmlDmAdapter::EOk )

        {

        TInt objSizeInBytes = result->Size();

        TBuf8<KXdmDmObjectSizeWidth> stringObjSizeInBytes;

        stringObjSizeInBytes.Num( objSizeInBytes );

        result->Reset();

        result->InsertL( 0, stringObjSizeInBytes );

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

        }   

    Callback().SetStatusL( aStatusRef, status );

    CleanupStack::PopAndDestroy( result );  // >>> result

#ifdef _DEBUG

    WriteToLog(_L8("CXdmDMAdapter::FetchLeafObjectSizeL(): end") );

 #endif

    }

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

// CXdmDMAdapter::UpdateLeafObjectL()

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

//

void CXdmDMAdapter::UpdateLeafObjectL( const TDesC8& aUri, 

                                       const TDesC8& aLUID, 

                                       const TDesC8& aObject, 

                                       const TDesC8& /*aType*/, 

                                       const TInt aStatusRef )

    {

#ifdef _DEBUG

    WriteToLog(_L8("CXdmDMAdapter::UpdateLeafObjectL(): begin") );

#endif   

    CSmlDmAdapter::TError status = CSmlDmAdapter::EOk;