/*

* Copyright (c) 2005 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:  Attribute list transaction manager

*

*/

// INCLUDE FILES

#include "CPEngAttributeListTransactionManager.h"

#include "PEngListLibraryFactory.h"

#include "MPEngListLibFactory.h"

#include "PEngPresenceEngineConsts2.h"

#include "CPEngContactListTransactionManager.h"

#include "CPEngContactListSettings.h"

#include "CPEngAttributeListItem.h"

#include "CPEngAttributeListTransCreateAttrList.h"

#include "CPEngAttributeListTransDeleteAttrList.h"

#include "MPEngStorageManager.h"

#include "PEngAttrLibFactory.h"

#include "MPEngPresenceAttrManager.h"

#include "PEngMessagePacker.h"

#include "PresenceDebugPrint.h"

#include <e32std.h>

// MACROS

#define CONTINUE_IF( a )\

    if ( a )\

        {\

        continue;\

        }

//Default granurality for ID lists

const TInt KAttributeListIdGranurality = 3;

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

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

// CPEngAttributeListTransactionManager::CPEngAttributeListTransactionManager()

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

//

CPEngAttributeListTransactionManager::CPEngAttributeListTransactionManager(

    MPEngListLibFactory& aFactory,

    TPEngWVCspVersion& aCSPVersion )

        : CPEngAttributeListManager( aFactory ),

        iCSPVersion( aCSPVersion )

    {

    }

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

// CPEngAttributeListTransactionManager::ConstructL()

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

//

void CPEngAttributeListTransactionManager::ConstructL(

    const CPEngSessionSlotId& aSessionSlot )

    {

    CPEngAttributeListManager::ConstructL( aSessionSlot );

    iContactListTransManager = static_cast <CPEngContactListTransactionManager*>

                               ( PEngListLibraryFactory::ContactListTransactionManagerLC( aSessionSlot ) );

    CleanupStack::Pop();

    }

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

// CPEngAttributeListTransactionManager::NewL()

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

//

CPEngAttributeListTransactionManager* CPEngAttributeListTransactionManager::NewL(

    MPEngListLibFactory& aFactory,

    const CPEngSessionSlotId& aSessionSlot,

    TPEngWVCspVersion& aCSPVersion )

    {

    CPEngAttributeListTransactionManager* self = NewLC( aFactory,

                                                        aSessionSlot,

                                                        aCSPVersion );

    CleanupStack::Pop();

    return self;

    }

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

// CPEngAttributeListTransactionManager::NewLC()

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

//

CPEngAttributeListTransactionManager* CPEngAttributeListTransactionManager::NewLC(

    MPEngListLibFactory& aFactory,

    const CPEngSessionSlotId& aSessionSlot,

    TPEngWVCspVersion& aCSPVersion )

    {

    CPEngAttributeListTransactionManager* self =

        new( ELeave ) CPEngAttributeListTransactionManager( aFactory,

                                                            aCSPVersion );

    CleanupClosePushL( *self );

    self->ConstructL( aSessionSlot );

    return self;

    }

//   Destructor

CPEngAttributeListTransactionManager::~CPEngAttributeListTransactionManager()

    {

    if ( iContactListTransManager )

        {

        iContactListTransManager->Close();

        }

    }

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

// CPEngAttributeListTransactionManager::Close()

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

//

void CPEngAttributeListTransactionManager::Close()

    {

    iAccessCount--;

    if ( iAccessCount == 0 )

        {

        iFactory.RemoveAttrListTransManager( this );

        delete this;

        }

    }

// =============================================================================

// ============ Functions of the MPEngTransactionFactory class ===============

// =============================================================================

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

// CPEngAttributeListTransactionManager::IncomingTransactionHandlerL()

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

//

MPEngIncomingTransactionHandler*

CPEngAttributeListTransactionManager::IncomingTransactionHandlerL(

    const TDesC8& /* aIncomingRequest */ )

    {

    return NULL;

    }

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

// CPEngAttributeListTransactionManager::OutgoingTransactionHandlerL()

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

//

void CPEngAttributeListTransactionManager::OutgoingTransactionHandlerL(

    TInt aOperation,

    const TDesC& /*aData*/,

    RPointerArray<MPEngOutgoingTransactionHandler>& aHandlers )

    {

    PENG_DP( D_PENG_LIT( "CPEngAttributeListTransactionManager::OutgoingTransactionHandlerL()" ) );

    switch ( aOperation )

        {

        case EPEngTransOpAttrListPublish:

            {

            // Make sure that we are handling most up-to-date data

            iStorageManager->RetrieveL( *this );

            if ( !iSynchronized )

                {

                GetSyncHandlersL( aHandlers, aOperation );

                }

            else

                {

                GetAttributeListsUpdateHandlersL( aHandlers, aOperation );

                }

            break;

            }

        default:

            {

            }

        }

    }

// =============================================================================

// ============ From MPEngAttributeListTransactionManager ======================

// =============================================================================

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

// CPEngAttributeListTransactionManager::AttributeListCreated()

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

//

void CPEngAttributeListTransactionManager::AttributeListCreated(

    const RArray<TUint32>& aAttrList )

    {

    TInt index ( FindAttributeList( aAttrList ) );

    if ( index != KErrNotFound )

        {

        iAttributeLists[ index ]->SetSynchronization( ETrue );

        }

    }

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

// CPEngAttributeListTransactionManager::AttributeEngineSynchronizedL()

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

//

void CPEngAttributeListTransactionManager::AttributeEngineSynchronizedL()

    {

    iSyncHandlerCount--;

    if ( !iSyncHandlerCount )

        {

        iSynchronized = ETrue;

        StoreChangesL();

        }

    }

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

// CPEngAttributeListTransactionManager::CommitContactL()

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

//

void CPEngAttributeListTransactionManager::CommitContactListL(

    const TDesC& aContactList )

    {

    CommitContactL( aContactList,

                    &CPEngAttributeListItem::CommitContactListL,

                    iDeleteAttrListContactLists );

    }

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

// CPEngAttributeListTransactionManager::CommitContactIdL()

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

//

void CPEngAttributeListTransactionManager::CommitContactIdL(

    const TDesC& aContactId )

    {

    CommitContactL( aContactId,

                    &CPEngAttributeListItem::CommitContactIdL,

                    iDeleteAttrListContactIDs );

    }

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

// CPEngAttributeListTransactionManager::RollBackContactListL()

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

//

void CPEngAttributeListTransactionManager::RollBackContactListL(

    const TDesC& aContactList )

    {

    RollBackOneContactL( aContactList,

                         CPEngAttributeListItem::ENewContactLists,

                         iDeleteAttrListContactLists );

    }

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

// CPEngAttributeListTransactionManager::RollBackContactIdL()

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

//

void CPEngAttributeListTransactionManager::RollBackContactIdL(

    const TDesC& aContactId )

    {

    RollBackOneContactL( aContactId,

                         CPEngAttributeListItem::ENewContactIDs,

                         iDeleteAttrListContactIDs );

    }

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

// CPEngAttributeListTransactionManager::CommitDefaultL()

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

//

void CPEngAttributeListTransactionManager::CommitDefaultL()

    {

    // go through all Attribute lists and commit Default flag

    // if attribute list is without any contact after commiting

    // and it isn't default or to be new default,

    // this attribute list will be deleted in CompressAtrrListArray function

    for ( TInt x ( iAttributeLists.Count() - 1 ) ;  x >= 0 ; x-- )

        {

        // commit default to each

        iAttributeLists[x]->CommitDefault();

        }

    iDeleteDefaultAttrList = EFalse;

    // now compress array

    CompressArrListArray();

    }

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

// CPEngAttributeListTransactionManager::RollBackDefaultL()

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

//

void CPEngAttributeListTransactionManager::RollBackDefaultL()

    {

    // go through all Attribute lists and commit Default flag

    // if attribute list is without any contact after commiting and it is not default

    // or to be new default, this attribute list will be deleted in CompressAtrrListArray function

    for ( TInt x ( iAttributeLists.Count() - 1 ) ;  x >= 0 ; x-- )

        {

        // commit default to each

        iAttributeLists[x]->SetNewDefault( EFalse );

        }

    iDeleteDefaultAttrList = EFalse;

    // now compress array

    CompressArrListArray();

    }

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

// CPEngAttributeListTransactionManager::CommitDefinedAttributeList()

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

//

void CPEngAttributeListTransactionManager::CommitDefinedContactsL(

    const CDesCArray* aContactLists,

    const CDesCArray* aContactIds )

    {

    // commit all contacts IDs and contact lists

    if ( aContactLists )

        {

        TInt count ( aContactLists->Count() );

        for ( TInt ii( 0 ) ; ii < count ; ii++ )

            {

            CommitContactListL( aContactLists->MdcaPoint( ii ) );

            }

        }

    if ( aContactIds )

        {

        TInt count ( aContactIds->Count() );

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

            {

            CommitContactIdL( aContactIds->MdcaPoint( i ) );

            }

        }

    }

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

// CPEngAttributeListTransactionManager::RollBackDefinedContactsL()

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

//

void CPEngAttributeListTransactionManager::RollBackDefinedContactsL(

    const CDesCArray* aContactLists,

    const CDesCArray* aContactIds )

    {

    // RollBack all contacts IDs and contact lists

    if ( aContactLists )

        {

        TInt count ( aContactLists->Count() );

        for ( TInt ii( 0 ) ; ii < count ; ii++ )

            {

            RollBackContactListL( aContactLists->MdcaPoint( ii ) );

            }

        }

    if ( aContactIds )

        {

        TInt count ( aContactIds->Count() );

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

            {

            RollBackContactIdL( aContactIds->MdcaPoint( i ) );

            }

        }

    }

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

// CPEngAttributeListTransactionManager::StoreChangesToStoreL()

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

//

void CPEngAttributeListTransactionManager::StoreChangesToStoreL()

    {

    User::LeaveIfError( StoreChangesL() );

    }

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

// CPEngAttributeListTransactionManager::GetSyncHandlersL()

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

//

void CPEngAttributeListTransactionManager::GetSyncHandlersL(

    RPointerArray<MPEngOutgoingTransactionHandler>& aTransactionHandlers,

    TInt aOperationId )

    {

    // Commit all items in the lists before they are synchronized,

    // so desired changes are synchronized right a way

    CommitAllAttributeListL();

    StoreChangesL();

    // now create SyncAttributes list handlers

    iSyncHandlerCount = 0;

    TInt count ( iAttributeLists.Count() );

    for ( TInt y( 0 ) ;  y < count ; y++ )

        {

        // create attribute list only if it needed

        if ( CheckAttributeListServerValidityCurrent( *( iAttributeLists[y] ) ) )

            {

            // ETrue => this is sync handler

            CPEngAttributeListTransCreateAttrList* newHandler =

                CPEngAttributeListTransCreateAttrList::NewLC(

                    *( iAttributeLists[y] ),

                    *this,

                    *iContactListTransManager,

                    *iAttributeManager,

                    iCSPVersion,

                    aOperationId,

                    ETrue );

            aTransactionHandlers.AppendL( newHandler );

            CleanupStack::Pop(); // newHandler

            iSyncHandlerCount++;

            }

        }

    // now check if there are some attribute lists to be deleted

    // GetDeleteAttributeListsHandlersL( aTransactionHandlers, aOperationId );

    }

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

// CPEngAttributeListTransactionManager::GetAttributeListsUpdateHandlersL()

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

//

void CPEngAttributeListTransactionManager::GetAttributeListsUpdateHandlersL(

    RPointerArray<MPEngOutgoingTransactionHandler>& aTransactionHandlers,

    TInt aOperationId )

    {

    // go through all attributes and create all handlers which are necessary

    TInt count ( iAttributeLists.Count() );

    for ( TInt x( 0 ) ; x < count ; x++ )

        {

        if ( CheckAttributeListCreateNewValidity( *( iAttributeLists[x] ) ) )

            {

            // there is something to update, create handler

            CPEngAttributeListTransCreateAttrList* newHandler =

                CPEngAttributeListTransCreateAttrList::NewLC(

                    *( iAttributeLists[ x ] ),

                    *this,

                    *iContactListTransManager,

                    *iAttributeManager,

                    iCSPVersion,

                    aOperationId );

            aTransactionHandlers.AppendL( newHandler );

            CleanupStack::Pop(); // newHandler

            }

        else

            {

            // Commit attribute list

            CommitAttributeListL( *( iAttributeLists[x]  ) );

            }

        }

    // now check if there are some attribute lists to be deleted

    GetDeleteAttributeListsHandlersL( aTransactionHandlers, aOperationId );

    StoreChangesL();

    }

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

// CPEngAttributeListTransactionManager::CompressArrListArray()

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

//

void CPEngAttributeListTransactionManager::GetDeleteAttributeListsHandlersL(

    RPointerArray<MPEngOutgoingTransactionHandler>& aTransactionHandlers,

    TInt aOperationId )

    {

    if ( CheckAttributeListDeleteValidity() )

        {

        // there is something to delete from server, create handler

        CPEngAttributeListTransDeleteAttrList* newHandler;

        newHandler = CPEngAttributeListTransDeleteAttrList::NewLC(

                         *this,

                         *iContactListTransManager,

                         iDeleteAttrListContactLists,

                         iDeleteAttrListContactIDs,

                         iDeleteDefaultAttrList,

                         iCSPVersion,

                         aOperationId );

        aTransactionHandlers.AppendL( newHandler );

        CleanupStack::Pop(); // newHandler

        }

    else

        {

        CommitDeleteAttributeListL();

        }

    }

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

// CPEngAttributeListTransactionManager::CompressArrListArray()

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

//

void CPEngAttributeListTransactionManager::CompressArrListArray()

    {

    // go through array from the end and delete all attribute lists

    // which does not hold any contact

    for ( TInt x ( iAttributeLists.Count() - 1 ) ; x >= 0 ; x-- )

        {

        if ( 0 == iAttributeLists[ x ]->ContactsCount() )

            {

            // no more contacts, delete attribute list

            delete iAttributeLists[ x ];

            iAttributeLists.Remove( x );

            }

        }

    }