/*

* 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 manager

*

*/

// INCLUDE FILES

#include    <e32std.h>

#include "CPEngAttributeListManager.h"

#include "CPEngAttributeListItem.h"

#include "CPEngAttributeListModel.h"

#include "PEngListLibTools.h"

#include "MPEngStorageManager.h"

#include "PEngStorageGlobals.h"

#include "PEngStorageManager.h"

#include "MPEngListLibFactory.h"

#include "CPEngSessionSlotId.h"

#include "PEngAttrLibFactory.h"

#include "MPEngPresenceAttrManager.h"

// CONSTANTS

// flag of the default attribute list + 3 counts, of 3 arrays

const TInt KIntEntrySize( 16 );

// storage ID of the attribute lists

_LIT( KAttributeListsStoreID, "AttributeListsStore" );

//Default granurality for ID lists

const TInt KAttributeListIdGranurality = 3;

const TInt KWVIDMaxSize = 50;

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

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

// CPEngAttributeListManager::CPEngAttributeListManager()

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

//

CPEngAttributeListManager::CPEngAttributeListManager(

    MPEngListLibFactory& aFactory )

        : CPEngStoreEntry( EPEngMixedPermanentVersionCon ),

        iAccessCount( 1 ), // init count to 1

        iFactory( aFactory ),

        iAttributeLists( KAttributeListIdGranurality ),

        iDeleteAttrListContactIDs( KAttributeListIdGranurality ),

        iDeleteAttrListContactLists( KAttributeListIdGranurality ),

        iDeleteDefaultAttrList( EFalse )

    {

    iSize = KIntEntrySize;

    }

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

// CPEngAttributeListManager::ConstructL()

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

//

void CPEngAttributeListManager::ConstructL(

    const CPEngSessionSlotId& aSessionSlot )

    {

    iSessionId = aSessionSlot.CloneL();

    MPEngStorageManager* storageManager =

        PEngStorageManager::GetStorageManagerL( *iSessionId );

    CleanupClosePushL( *storageManager );

    CPEngStoreEntry::BaseConstructL( *storageManager );

    CleanupStack::PopAndDestroy();

    iAttributeManager = PEngAttrLibFactory::AttributeManagerInstanceL(

                            *iSessionId );

    iStorageManager->RetrieveL( *this );

    }

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

// CPEngAttributeListManager::NewL()

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

//

CPEngAttributeListManager* CPEngAttributeListManager::NewL(

    MPEngListLibFactory& aFactory,

    const CPEngSessionSlotId& aSessionSlot )

    {

    CPEngAttributeListManager* self = NewLC( aFactory, aSessionSlot );

    CleanupStack::Pop();

    return self;

    }

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

// CPEngAttributeListManager::NewLC()

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

//

CPEngAttributeListManager* CPEngAttributeListManager::NewLC(

    MPEngListLibFactory& aFactory,

    const CPEngSessionSlotId& aSessionSlot )

    {

    CPEngAttributeListManager* self =

        new( ELeave ) CPEngAttributeListManager( aFactory );

    CleanupClosePushL( *self );

    self->ConstructL( aSessionSlot );

    return self;

    }

//   Destructor

CPEngAttributeListManager::~CPEngAttributeListManager()

    {

    delete iSessionId;

    if ( iAttributeManager )

        {

        iAttributeManager->Close();

        }

    iAttributeLists.ResetAndDestroy();

    iDeleteAttrListContactIDs.Reset();

    iDeleteAttrListContactLists.Reset();

    }

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

// =============== From MPEngAttributeListManager ==============================

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

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

// CPEngAttributeListManager::SessionId()

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

//

const CPEngSessionSlotId& CPEngAttributeListManager::SessionId() const

    {

    return *iSessionId;

    }

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

// CPEngAttributeListManager::Open()

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

//

void CPEngAttributeListManager::Open()

    {

    iAccessCount++;

    }

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

// CPEngAttributeListManager::Close()

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

//

void CPEngAttributeListManager::Close()

    {

    iAccessCount--;

    if ( iAccessCount == 0 )

        {

        iFactory.RemoveAttrListManager( this );

        delete this;

        }

    }

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

// CPEngAttributeListManager::CreateEmptyAttributeListL()

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

//

MPEngAttributeList2* CPEngAttributeListManager::CreateEmptyAttributeListL()

    {

    return CPEngAttributeListModel::NewL( iAttributeManager );

    }

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

// CPEngAttributeListManager::GetDefaultAttributeListL()

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

//

MPEngAttributeList2* CPEngAttributeListManager::GetDefaultAttributeListL(

    TPEngAttributeListsSet2 aAttrListsSet )

    {

    switch ( aAttrListsSet )

        {

        case EPEngNetworkAttributeLists:

            {

            TInt index ( FindCurrentDefaultAttributeList() );

            if ( index == KErrNotFound )

                {

                User::Leave( KErrNotFound );

                }

            // get list of attributes and create model with it

            return CPEngAttributeListModel::NewL( iAttributeManager,

                                                  iAttributeLists[index]->PresenceAttributes() );

            }

        case EPEngLocalAttributeLists:

            {

            TInt index ( FindNewDefaultAttributeList() );

            if ( index == KErrNotFound )

                {

                index = FindCurrentDefaultAttributeList();

                if ( index == KErrNotFound )

                    {

                    User::Leave( KErrNotFound );

                    }

                }

            // get list of attributes and create model with it

            return CPEngAttributeListModel::NewL( iAttributeManager,

                                                  iAttributeLists[index]->PresenceAttributes() );

            }

        default:

            {

            User::Leave( KErrNotSupported );

            break;

            }

        }

    // just for compiler

    return NULL;

    }

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

// CPEngAttributeListManager::SetAsDefaultAttributeListL()

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

//

void CPEngAttributeListManager::SetAsDefaultAttributeListL(

    MPEngAttributeList2& aAttrList )

    {

    // set delete default attribute list to EFalse

    iDeleteDefaultAttrList = EFalse;

    CPEngAttributeListModel* model =

        static_cast< CPEngAttributeListModel* >( &aAttrList );

    // first check if there is not any new default flag already and remove it

    TInt index ( FindNewDefaultAttributeList() );

    if ( index != KErrNotFound )

        {

        // set new default to zero and if attribute lists is no more needed

        // delete it (0 == zero contacts in attr list)

        if ( 0 == iAttributeLists[ index ]->SetNewDefault( EFalse ) )

            {

            // attr. list empty delete it

            iSize -= iAttributeLists[ index ]->SizeOfEntry();

            delete iAttributeLists[ index ];

            iAttributeLists.Remove( index );

            }

        }

    // now find new one and set it, if it does not exist, create it

    index = FindAttributeList( model->PresenceAttributes() );

    if ( index != KErrNotFound )

        {

        // check if it is not already default, if not then set flag for new

        // otherwise there is no need to do anything

        if ( !iAttributeLists[ index ]->CurrentlyDefault() )

            {

            // it exists, just set the flag

            iAttributeLists[ index ]->SetNewDefault( ETrue );

            }

        }

    else

        {

        // it does not exist, create it and insert it in the array

        // with parameter new Default on

        CPEngAttributeListItem* newListItem =

            CPEngAttributeListItem::NewLC( model->PresenceAttributes() );

        // set it as new Default

        newListItem->SetNewDefault( ETrue );

        iAttributeLists.AppendL( newListItem );

        CleanupStack::Pop(); // newListItem

        iSize += newListItem->SizeOfEntry() ;

        }

    // store changes

    StoreChangesL();

    }

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

// CPEngAttributeListManager::DeleteDefaultAttributeListL()

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

//

void CPEngAttributeListManager::DeleteDefaultAttributeListL()

    {

    // check if there is somewhere new default attribute list

    TInt err ( FindNewDefaultAttributeList() );

    if ( err != KErrNotFound )

        {

        // set new default to zero and if attribute lists is no more needed

        // delete it (0 == zero contacts in attr list)

        if ( 0 == iAttributeLists[ err ]->SetNewDefault( EFalse ) )

            {

            // attr. list empty delete it

            delete iAttributeLists[ err ];

            iAttributeLists.Remove( err );

            }

        }

    // set flag to delete default attr list

    iDeleteDefaultAttrList = ETrue;

    StoreChangesL();

    }

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

// CPEngAttributeListManager::GetAttributeListForUserL()

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

//

MPEngAttributeList2* CPEngAttributeListManager::GetAttributeListForUserL(

    const TDesC&  aContactId,

    TPEngAttributeListsSet2 aAttrListsSet )

    {

    return GetAttributeListForContactL(

               aContactId,

               aAttrListsSet,

               CPEngAttributeListItem::ECurrentContactIDs,

               CPEngAttributeListItem::ENewContactIDs );

    }

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

// CPEngAttributeListManager::GetAttributeListForContactListL()

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

//

MPEngAttributeList2* CPEngAttributeListManager::GetAttributeListForContactListL(

    const TDesC& aContactList,

    TPEngAttributeListsSet2 aAttrListsSet )

    {

    return GetAttributeListForContactL(

               aContactList,

               aAttrListsSet,

               CPEngAttributeListItem::ECurrentContactLists,

               CPEngAttributeListItem::ENewContactLists );

    }

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

// CPEngAttributeListManager::AttachAttributeListToUserL()

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

//

void CPEngAttributeListManager::AttachAttributeListToUserL(

    const TDesC& aContactId,

    MPEngAttributeList2& aList )

    {

    AttachAttributeListToContactL(

        aContactId,

        aList,

        CPEngAttributeListItem::ECurrentContactIDs,

        CPEngAttributeListItem::ENewContactIDs,

        iDeleteAttrListContactIDs );

    }

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

// CPEngAttributeListManager::AttachAttributeListToContactListL()

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

//

void CPEngAttributeListManager::AttachAttributeListToContactListL(

    const TDesC& aContactList,

    MPEngAttributeList2& aList )

    {

    AttachAttributeListToContactL(

        aContactList,

        aList,

        CPEngAttributeListItem::ECurrentContactLists,

        CPEngAttributeListItem::ENewContactLists,

        iDeleteAttrListContactLists );

    }

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

// CPEngAttributeListManager::DeleteAttributeListFromUserL()

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

//

void CPEngAttributeListManager::DeleteAttributeListFromUserL(

    const TDesC& aContactId )

    {

    DeleteAttributeListFromContactL(

        aContactId,

        CPEngAttributeListItem::ENewContactIDs,

        iDeleteAttrListContactIDs );

    }

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

// CPEngAttributeListManager::DeleteAttributeListFromContactListL()

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

//

void CPEngAttributeListManager::DeleteAttributeListFromContactListL(

    const TDesC& aContactList )

    {

    DeleteAttributeListFromContactL(

        aContactList,

        CPEngAttributeListItem::ENewContactLists,

        iDeleteAttrListContactLists );

    }

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

// CPEngAttributeListManager::ExternalizeL()

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

//

void CPEngAttributeListManager::ExternalizeL( RWriteStream& aStream,

                                              TPEngStorageType aStorageType ) const

    {

    if ( !( aStorageType & StorageType() ) )

        {

        User::Leave( KErrGeneral );

        }

    // write delete default list flag

    aStream.WriteInt32L( iDeleteDefaultAttrList );

    aStream.WriteInt32L( iSynchronized );

    // externalize list of to be delete wv IDs's attribute lists

    TInt count ( iDeleteAttrListContactIDs.Count() );

    aStream.WriteInt32L( count );

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

        {

        aStream << iDeleteAttrListContactIDs.MdcaPoint( i );

        }

    // externalize list of to be deleted contact lists's attribute lists

    count = iDeleteAttrListContactLists.Count();

    aStream.WriteInt32L( count );

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

        {

        aStream << iDeleteAttrListContactLists.MdcaPoint( ii );

        }

    // externalize attribute lists

    count = iAttributeLists.Count();

    aStream.WriteInt32L( count );

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

        {

        iAttributeLists[x]->ExternalizeL( aStream );

        }

    }

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

// CPEngAttributeListManager::InternalizeL()

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

//

void CPEngAttributeListManager::InternalizeL( RReadStream& aStream,

                                              TPEngStorageType aStorageType )

    {

    if ( !( aStorageType & StorageType() ) )

        {

        User::Leave( KErrGeneral );

        }

    iSize = KIntEntrySize;

    iDeleteDefaultAttrList =  aStream.ReadInt32L();

    // read synchronize flag

    // member value isn't updated from stored data

    // ==> full sync is performed each time when attribute lists

    //     are used for the first time during the session

    //     (if member variable would be updated from persisted data, sync would hapen

    //      only when atttribute lists are updated for the first time to account.)

    aStream.ReadInt32L();

    // internalize list of to be delete wv IDs's attribute lists

    TInt count ( aStream.ReadInt32L() );

    iDeleteAttrListContactIDs.Reset();

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

        {

        // use max size as double of KWVIDMaxSize

        HBufC16* newContact = HBufC16::NewLC( aStream, 2 * KWVIDMaxSize );

        iDeleteAttrListContactIDs.InsertIsqL( *newContact, ECmpFolded );

        iSize += newContact->Size();

        CleanupStack::PopAndDestroy(); // newContact

        }

    // internalize list of to be deleted contact lists's attribute lists

    count = aStream.ReadInt32L();

    iDeleteAttrListContactLists.Reset();

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

        {

        // use max size as double of KWVIDMaxSize

        HBufC16* newContact = HBufC16::NewLC( aStream, 2 * KWVIDMaxSize );

        iDeleteAttrListContactLists.InsertIsqL( *newContact, ECmpFolded );

        iSize += newContact->Size();

        CleanupStack::PopAndDestroy(); // newContact

        }

    // reset array of the lists

    iAttributeLists.ResetAndDestroy();

    // first read  number of the Attribute lists

    count = aStream.ReadInt32L();

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

        {

        CPEngAttributeListItem* newLists =

            CPEngAttributeListItem::NewLC( aStream );

        iAttributeLists.AppendL( newLists );

        CleanupStack::Pop(); // newLists

        iSize += newLists->SizeOfEntry();

        }

    }

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

// CPEngAttributeListManager::StorageId()