/*

* 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:    OMA Presence Settings Device Management Adapter's source file 

*

*/

#include <implementationproxy.h>

#include <nsmldmuri.h>

#include <utf.h>

#include <badesca.h>

#include <StringLoader.h>

#include "presencedmadapter.h"

#include "presencedmlogger.h"

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

// CPresenceDMAdapter::NewL()

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

//

CPresenceDMAdapter* CPresenceDMAdapter::NewL(MSmlDmCallback* aDmCallback )

    {

    PRES_DM_LOG(LOG_LIT("NewL start"));    

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

    PRES_DM_LOG(LOG_LIT(" NewL end"));    

    return self;

    }

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

// CPresenceDMAdapter::CPresenceDMAdapter()

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

//

CPresenceDMAdapter::CPresenceDMAdapter(MSmlDmCallback* aDmCallback) : 

    CSmlDmAdapter( aDmCallback ), iGetSetID(KErrNotFound)

    {

    PRES_DM_LOG(LOG_LIT("CPresenceDMAdapter")); 

    }

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

// CPresenceDMAdapter::~CPresenceDMAdapter()

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

//

CPresenceDMAdapter::~CPresenceDMAdapter()

    {

    PRES_DM_LOG(LOG_LIT("~CPresenceDMAdapter")); 

    }

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

//  CPresenceDMAdapter::DDFVersionL

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

//

void CPresenceDMAdapter::DDFVersionL(CBufBase& aDDFVersion)

    {

    PRES_DM_LOG(LOG_LIT("DDFVersionL"));   

    aDDFVersion.InsertL( 0, KPresDMDDFVersion );    

    }

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

//  CPresenceDMAdapter::DDFStructureL

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

//

void CPresenceDMAdapter::DDFStructureL( MSmlDmDDFObject& aDDF )

    {

    PRES_DM_LOG(LOG_LIT("DDFStructureL"));    

    // For OMA_PRESENCE 

    TSmlDmAccessTypes accessTypeGet;

    accessTypeGet.SetGet();

    // For OMA_PRESENCE/<X> 

    TSmlDmAccessTypes accessTypeAll;

    accessTypeAll.SetAdd();

    accessTypeAll.SetGet();

    accessTypeAll.SetReplace();

    accessTypeAll.SetDelete();

    // For leaf nodes

    TSmlDmAccessTypes accessTypeNoDelete;

    accessTypeNoDelete.SetAdd();

    accessTypeNoDelete.SetGet();

    accessTypeNoDelete.SetReplace();

    // ./OMA_PRESENCE

    MSmlDmDDFObject& omaPresNode = aDDF.AddChildObjectL( KPresDMNodeName );

    FillNodeInfoL( omaPresNode, accessTypeGet, MSmlDmDDFObject::EOne,

                  MSmlDmDDFObject::EPermanent, MSmlDmDDFObject::ENode,

                  KPresDMNodeNameDescription );

    // ./OMA_PRESENCE/<X> 

    MSmlDmDDFObject& runTimeNode = omaPresNode.AddChildObjectGroupL();

    FillNodeInfoL( runTimeNode, accessTypeAll, MSmlDmDDFObject::EZeroOrMore,

                  MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::ENode,

                  KPresDmDynamicDescription );

    // ./OMA_PRESENCE/<X>/NAME            

    MSmlDmDDFObject& nameNode = runTimeNode.AddChildObjectL( KPresDMName );

    FillNodeInfoL( nameNode, accessTypeNoDelete, MSmlDmDDFObject::EZeroOrOne,

                  MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::EChr,

                  KPresDMNameDescription );

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

    MSmlDmDDFObject& providerIdNode = runTimeNode.AddChildObjectL( KPresDMProviderId );

    FillNodeInfoL( providerIdNode, accessTypeNoDelete,MSmlDmDDFObject::EZeroOrOne,

                  MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::EChr,

                  KPresDMProviderIdDescription );    

    // ./OMA_PRESENCE/<X>/ToConRef

    MSmlDmDDFObject& toConRefNode = runTimeNode.AddChildObjectL( KPresDMToConRef );

    FillNodeInfoL( toConRefNode, accessTypeNoDelete, MSmlDmDDFObject::EZeroOrOne,

                  MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::ENode,

                  KPresDMToConRefDescription);

        // ./OMA_PRESENCE/<X>/ToConRef/SIP-PROFILE (Towards SIP ID)                                         

        MSmlDmDDFObject& napIdSIPNode = toConRefNode.AddChildObjectL( KPresDMSIPProfile );

        FillNodeInfoL( napIdSIPNode, accessTypeNoDelete, MSmlDmDDFObject::EZeroOrOne, 

                      MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::ENode,

                      KPresDMSIPProfileDescription );

            // ./OMA_PRESENCE/<X>/ToConRef/SIP-PROFILE/ConRef (The actual SIP ID)                                    

            MSmlDmDDFObject& conRefSipNode = napIdSIPNode.AddChildObjectL( KPresDMConRef );

            FillNodeInfoL( conRefSipNode, accessTypeNoDelete, MSmlDmDDFObject::EZeroOrOne, 

                          MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::EChr,

                          KPresDMConRefDescription );

        // ./OMA_PRESENCE/<X>/ToConRef/XDM-SET (To XDM-ID) (Towards XDM ID)                                         

        MSmlDmDDFObject& napIdToXDMNode = toConRefNode.AddChildObjectL( KPresDMXDMSet );

        FillNodeInfoL( napIdToXDMNode, accessTypeNoDelete, MSmlDmDDFObject::EZeroOrOne, 

                      MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::ENode,

                      KPresDMXDMSetDescription );

            // ./OMA_PRESENCE/<X>/ToConRef/XDM-SET/ConRef (actual XDM node)       

            MSmlDmDDFObject& conRefXDMNode = napIdToXDMNode.AddChildObjectL( KPresDMConRef );

            FillNodeInfoL( conRefXDMNode, accessTypeNoDelete, MSmlDmDDFObject::EZeroOrOne, 

                          MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::EChr,

                          KPresDMConRefDescription );                 

    // ./OMA_PRESENCE/<X>/CLIENT-DATA-OBJ-LIMIT          

    MSmlDmDDFObject& dataObjNode = runTimeNode.AddChildObjectL( KPresDMClientObjDataLim );

    FillNodeInfoL( dataObjNode, accessTypeNoDelete, MSmlDmDDFObject::EOne,

                  MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::EInt,

                  KPresDMClientObjDataLimDescription );

    // ./OMA_PRESENCE/<X>/CONTENT-SERVER-URI

    MSmlDmDDFObject& ContentSrvNode = runTimeNode.AddChildObjectL( KPresDMContentSrvUri );

    FillNodeInfoL( ContentSrvNode, accessTypeNoDelete, MSmlDmDDFObject::EZeroOrOne,

                  MSmlDmDDFObject::EDynamic,MSmlDmDDFObject::EChr,

                  KPresDMContentSrvUriDescription );            

    // ./OMA_PRESENCE/<X>/SOURCE-THROTTLE-PUBLISH   

    MSmlDmDDFObject& srcThrotNode = runTimeNode.AddChildObjectL( KPresDMSrcThPublish );

    FillNodeInfoL( srcThrotNode, accessTypeNoDelete, MSmlDmDDFObject::EZeroOrOne,

                  MSmlDmDDFObject::EDynamic, MSmlDmDDFObject::EInt,

                  KPresDMSrcThPublishDescription );     

        // ./OMA_PRESENCE/<X>/MAX-NUMBER-OF-PRESENCE-SUBSCRIPTIONS  

    MSmlDmDDFObject& maxSubsNode = runTimeNode.AddChildObjectL( KPresDMMaxPresSubs );

    FillNodeInfoL( maxSubsNode, accessTypeNoDelete, MSmlDmDDFObject::EZeroOrOne,

                  MSmlDmDDFObject::EDynamic,MSmlDmDDFObject::EInt,

                  KPresDMMaxPresSubsDescription ); 

    // ./OMA_PRESENCE/<X>/MAX-NUMBER-OF-SUBSCRIPTIONS-IN-PRESENCE-LIST   

    MSmlDmDDFObject& maxSubsListNode = runTimeNode.AddChildObjectL( KPresDMMaxPresSubsInLists );

    FillNodeInfoL( maxSubsListNode, accessTypeNoDelete, MSmlDmDDFObject::EZeroOrOne,

                  MSmlDmDDFObject::EDynamic,MSmlDmDDFObject::EInt,

                  KPresDMMaxPresSubsInListsDescription );

    // ./OMA_PRESENCE/<X>/SERVICE-URI-TEMPLATE

    MSmlDmDDFObject& serUriTempNode = runTimeNode.AddChildObjectL( KPresDMServiceUriTemp );

    FillNodeInfoL( serUriTempNode, accessTypeNoDelete, MSmlDmDDFObject::EOne,

                  MSmlDmDDFObject::EDynamic,MSmlDmDDFObject::EChr,

                  KPresDMServiceUriTempDescription );

    PRES_DM_LOG(LOG_LIT(" DDFStructureL end"));  

    }

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

// CPresenceDMAdapter::ChildURIListL

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

//

void CPresenceDMAdapter::ChildURIListL( const TDesC8& aUri, 

                                       const TDesC8& /*aLUID*/, 

                                       const CArrayFix<TSmlDmMappingInfo>& 

                                       /*aPreviousURISegmentList*/, 

                                       const TInt aResultsRef, 

                                       const TInt aStatusRef )

    {

    PRES_DM_LOG(LOG_LIT8("ChildURIListL(%S): begin"), &aUri);

    const TInt KPresDMSegmentNameLen = 50;

    CSmlDmAdapter::TError retValue = CSmlDmAdapter::EOk;

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

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

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

    TBuf8<KPresDMSegmentNameLen> segmentName;

    // ./OMA_PRESENCE

    if( !lastUriSeg.Compare( KPresDMNodeName ) ) 

        {

        PRES_DM_LOG(LOG_LIT8("  ./OMA_PRESENCE"));

        RArray<TInt> settingIds;

        CleanupClosePushL( settingIds );    // << settingIds

        CDesCArray* names = PresSettingsApi::GetAllSetsNamesLC(settingIds);

        TInt IdCount = settingIds.Count();

        PRES_DM_LOG(LOG_LIT("   IdCount = %d"), IdCount);

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

            {

            TInt id = settingIds[i];

            segmentName.Copy( KNullDesC8 );

            segmentName.AppendNum( id );

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

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

            }

        CleanupStack::PopAndDestroy(names);

        CleanupStack::PopAndDestroy(1); // settingIds, 

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

        Callback().SetStatusL( aStatusRef, retValue );

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

        currentList = NULL;

        return;

        }   

    // ./OMA_PRESENCE/X

    if( NSmlDmURI::NumOfURISegs( aUri ) == KPresDMLevel ) // if Uri segments are 2

                                               // we are certainly at x

                                               // level   

        {

        PRES_DM_LOG(LOG_LIT8("  ./OMA_PRESENCE/X"));

        segmentName.Copy( KPresDMName );

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

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

        segmentName.Copy( KPresDMProviderId );

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

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

        segmentName.Copy( KPresDMToConRef );

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

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

        segmentName.Copy( KPresDMClientObjDataLim );

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

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

        segmentName.Copy( KPresDMContentSrvUri );

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

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

        segmentName.Copy( KPresDMSrcThPublish );

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

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

        segmentName.Copy( KPresDMMaxPresSubs );

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

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

        segmentName.Copy( KPresDMMaxPresSubsInLists );

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

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

        segmentName.Copy( KPresDMServiceUriTemp );

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

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

        }

    // ./OMA_PRESENCE/X/ToConRef   

    else if ( !lastUriSeg.Compare( KPresDMToConRef ) ) 

        {

        PRES_DM_LOG(LOG_LIT8("  ./OMA_PRESENCE/X/ToConRef"));

        segmentName.Copy( KPresDMSIPProfile );

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

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

        segmentName.Copy( KPresDMXDMSet );

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

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

        }

    // ./OMA_PRESENCE/X/ToConRef/SIP-ID    

    else if ( !lastUriSeg.Compare( KPresDMSIPProfile ) ) 

        {

        PRES_DM_LOG(LOG_LIT8("  ./OMA_PRESENCE/X/ToConRef/SIP-ID"));

        segmentName.Copy( KPresDMConRef );

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

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

        }

    // ./OMA_PRESENCE/X/ToConRef/XDM-ID      

    else if ( !lastUriSeg.Compare( KPresDMXDMSet ) )

        {

        PRES_DM_LOG(LOG_LIT8("  ./OMA_PRESENCE/X/ToConRef/XDM-ID"));

        segmentName.Copy( KPresDMConRef );

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

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

        }

    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  

    PRES_DM_LOG(LOG_LIT(" ChildURIListL(): end") );

    }    

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

//  CPresenceDMAdapter::FetchLeafObjectL

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

//

void CPresenceDMAdapter::FetchLeafObjectL( const TDesC8& aUri, 

                                      const TDesC8& /*aLUID*/, 

                                      const TDesC8& aType, 

                                      const TInt aResultsRef, 

                                      const TInt aStatusRef )

    {

    PRES_DM_LOG(LOG_LIT8("FetchLeafObjectL(%S): start"), &aUri );

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

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

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

    if( status == CSmlDmAdapter::EOk )

        {

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

        }

    Callback().SetStatusL(aStatusRef, status);

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

    PRES_DM_LOG(LOG_LIT(" FetchLeafObjectL(): end") );

    }

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

// CSmlDmAdapter::TError FetchObjectL

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

//

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

                                                   CBufBase& aObject)

    {

    PRES_DM_LOG(LOG_LIT8("FetchObjectL(%S): start"), &aUri);

    CSmlDmAdapter::TError status = CSmlDmAdapter::EOk;

    TPresSettingsSet tempSet;

    TPresSettingsProperty property;

    HBufC8* luid = Callback().GetLuidAllocL( aUri );

    TInt settingsId = DesToInt( *luid );

    PRES_DM_LOG(LOG_LIT("   settingsId after callback:%d"), settingsId);

    // check whether above found id is valid or not

    if (!IsPresIDValidL(settingsId))

        {

        //try to find it another way

        }

    // if previous settings id processing was ok

    if (status == CSmlDmAdapter::EOk)

        {

        TPtrC8 lastUriSeg = NSmlDmURI::LastURISeg( aUri );

        // NAME

        if( Match(lastUriSeg, KPresDMName ) )

            {

            property = EPresPropSetName;  

            }

        // PROVIDER-ID  

        else if( Match(lastUriSeg, KPresDMProviderId ) )

            {

            property = EPresPropProviderID;

            }

        // Client object data limit 

        else if( Match(lastUriSeg, KPresDMClientObjDataLim) )

            {

            property = EPresPropObjectSize;  

            }

        // content server Uri

        else if( Match(lastUriSeg, KPresDMContentSrvUri) )

            {

            property = EPresPropContSrvAdd;  

            }

        // Source throttle publish

        else if( Match(lastUriSeg, KPresDMSrcThPublish) )

            {

            property = EPresPropPubInterval;  

            }

        // Max pres subs

        else if( Match(lastUriSeg, KPresDMMaxPresSubs ) )

            {

            property = EPresPropMaxSubs;  

            }

        // max subs in lists    

        else if( Match(lastUriSeg, KPresDMMaxPresSubsInLists ) )

            {

            property = EPresPropMaxCntInList;  

            }

        // service uri template     

        else if( Match(lastUriSeg, KPresDMServiceUriTemp ) )

            {

            property = EPresPropDomainSyntax;  

            }       

        // ConRef/TO-SIP

        // ConRef/TO-XDM        

        else if( Match( lastUriSeg, KPresDMConRef) )

            {

            TPtrC8 conRefUri = NSmlDmURI::RemoveLastSeg( aUri );

            TPtrC8 lastConRefSeg = NSmlDmURI::LastURISeg( conRefUri );

            if( Match( lastConRefSeg, KPresDMSIPProfile ) )

                {

                property = EPresPropSIPProfile;

                }  

            else if( Match( lastConRefSeg, KPresDMXDMSet ) )

                {

                property = EPresPropXDMSet;

                }  

            else

                {

                status = CSmlDmAdapter::ENotFound;

                }

            }

        else

            {

            status = CSmlDmAdapter::ENotFound;

            }

        }

    // known property

    if ( status == CSmlDmAdapter::EOk )

        {

        status = GetPropertyL( settingsId, property, aObject ) ;

        PRES_DM_LOG(LOG_LIT("   GetPropertyL status: %d"), status); 

        }

    PRES_DM_LOG(LOG_LIT(" FetchObjectL: ends"));    

    return status;

    }  

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

// CPresenceDMAdapter::FetchLeafObjectSizeL

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

//

void CPresenceDMAdapter::FetchLeafObjectSizeL( const TDesC8& aUri, 

                                              const TDesC8& /*aLUID*/, 

                                              const TDesC8& aType, 

                                              const TInt aResultsRef, 

                                              const TInt aStatusRef )

    {

    PRES_DM_LOG(LOG_LIT8("FetchLeafObjectSizeL(%S): begins"), &aUri); 

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

    CleanupStack::PushL( result );

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

    PRES_DM_LOG(LOG_LIT("   FetchObjectL: status = %d"), status); 

    if( status == CSmlDmAdapter::EOk )

        {

        TInt objSizeInBytes = result->Size();

        PRES_DM_LOG(LOG_LIT("   objSizeInBytes = %d"), objSizeInBytes); 

        TBuf8<KPresDMObjectSizeWidth> stringObjSizeInBytes;

        stringObjSizeInBytes.Num( objSizeInBytes );

        result->Reset();

        result->InsertL( 0, stringObjSizeInBytes );

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

        }   

    Callback().SetStatusL( aStatusRef, status) ;

    CleanupStack::PopAndDestroy(result);    

    PRES_DM_LOG(LOG_LIT(" FetchLeafObjectSizeL: ends")); 

    }

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

// CPresenceDMAdapter::UpdateLeafObjectL()

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

//

void CPresenceDMAdapter::UpdateLeafObjectL(const TDesC8& aUri, 

                                         const TDesC8& /*aLUID*/, 

                                         const TDesC8& aObject, 

                                         const TDesC8& /*aType*/, 

                                         const TInt aStatusRef)

    {

    PRES_DM_LOG(LOG_LIT8("UpdateLeafObjectL(%S): starts"), &aUri); 

    CSmlDmAdapter::TError status = CSmlDmAdapter::EOk;

    TPresSettingsSet tempSet;

    TPresSettingsProperty property;

    HBufC8* luid = Callback().GetLuidAllocL( aUri );

    TInt settingsId = DesToInt( *luid );

    PRES_DM_LOG(LOG_LIT("   settingsId after callback:%d"), settingsId);

    // check whether above found id is valid or not

    if (!IsPresIDValidL(settingsId))

        {

        //try to find it another way