/*

* 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:  Contact lists manager base

*

*/

// INCLUDE FILES

#include <e32std.h>

#include "CPEngContactListManagerBase.h"

#include "PEngListLibTools.h"

#include "CPEngContactListModBase.h"

#include "CPEngWatcherList.h"

#include "CPEngContactListSettings.h"

#include "MPEngContactListAdvance.h"

#include "MPEngContactListManager.h"

#include "PEngStorageGlobals.h"

#include "MPEngStorageManager.h"

#include "PEngStorageManager.h"

#include "CPEngSessionSlotId.h"

#include "PresenceDebugPrint.h"

// Minimum store ocupation

//counts the settings count, syncFlag, domain length, each 4 bytes

static const TInt KMinimumStoreEntrySize = 12;

// ========================== HELPERS ============================================

/**

 * Abstract array entry id accessor.

 */

class MPEngEntryIdAccessor

    {

    public:

        /**

         * Gets descriptor id identifying the array item.

         * Derived implementation should cast the given

         * entry pointer to concrete type and return

         * descriptor identifying the entry.

         *

         * @param aEntry The array element.

         * @return The element descriptor id.

         */

        virtual const TDesC& DesId( const TAny* aEntry ) const = 0;

    };

/**

 * Concrete array entry id accessor to be used with

 * CPEngContactListSettings.

 */

NONSHARABLE_CLASS ( TPEngContactListSettingsIdAccessor ) : public MPEngEntryIdAccessor

    {

public:

    inline TPEngContactListSettingsIdAccessor() {}

    /**

     * Gets descriptor id identifying the

     * CPEngContactListSettings item.

     */

    inline const TDesC& DesId( const TAny* aEntry ) const

        {

        return ( ( CPEngContactListSettings* )aEntry )->Name();

        }

    };

/**

 * Concrete array entry id accessor to be used with

 * CPEngContactListModBase.

 */

NONSHARABLE_CLASS( TPEngContactListModelIdAccessor )

        : public MPEngEntryIdAccessor

    {

public:

    inline TPEngContactListModelIdAccessor() {}

    /**

     * Gets descriptor id identifying the

     * CPEngContactListModBase item.

     */

    inline const TDesC& DesId( const TAny* aEntry ) const

        {

        return ( ( CPEngContactListModBase* )aEntry )->Settings().Name();

        }

    };

/**

 * Templated find method.

 */

template<class T>

inline TInt FindEntryInArray( const RPointerArray<T>& aArray,

                              const TDesC& aContactId,

                              TInt& aIndex,

                              const MPEngEntryIdAccessor& aAccessor,

                              const TDesC& aUserDomain = KNullDesC )

    {

    TInt l( 0 );

    TInt r( aArray.Count() );

    TInt ret( KErrNotFound );

    while ( r > l )

        {

        TInt inx = ( l + r ) >> 1;

        TInt k ( NContactIdsTools::CompareContactIds( aContactId,

                                                      aAccessor.DesId( aArray[ inx ] ),

                                                      aUserDomain ) );

        if ( k == 0 )

            {

            aIndex = inx;

            return KErrNone;

            }

        else if ( k > 0 )

            l = inx + 1;

        else

            r = inx;

        }

    aIndex = r;

    return ret;

    }

//Default granurality for contact lists

const TInt KListObjectsGranurality = 3;

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

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

// CPEngContactListManagerBase::CPEngContactListManagerBase()

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

//

CPEngContactListManagerBase::CPEngContactListManagerBase(

    MPEngListLibFactory& aFactory )

        : CPEngStoreEntry( static_cast<TPEngStorageType> ( EPEngMixedPermanentCached |

                                                           EPEngStorageFlagVersionChecked ) ),

        iAccessCount( 1 ), // init ref count on 1

        iFactory( aFactory ),

        iContactListSettings( KListObjectsGranurality ),

        iContactLists( KListObjectsGranurality )

    {

    iSize = KMinimumStoreEntrySize;

    }

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

// CPEngContactListManagerBase::ConstructL()

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

//

void CPEngContactListManagerBase::ConstructL(

    const CPEngSessionSlotId& aSessionSlot )

    {

    iSessionId = aSessionSlot.CloneL();

    MPEngStorageManager* storageManager = NULL;

    storageManager = PEngStorageManager::GetStorageManagerL( *iSessionId );

    CleanupClosePushL( *storageManager );

    CPEngStoreEntry::BaseConstructL( *storageManager );

    CleanupStack::PopAndDestroy(); //storageManager

    InitDomainNameL( *iSessionId );

    TInt err( iStorageManager->RetrieveL( *this ) );

    if ( err == KErrNotFound )

        {

        // store does not exist, create it

        InitWatcherListL();

        StoreL();

        }

    }

// Destructor

CPEngContactListManagerBase::~CPEngContactListManagerBase()

    {

    iContactListSettings.ResetAndDestroy();

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

        {

        iContactLists[ x ]->Close();

        }

    iContactLists.Reset();

    iCntLstSettingsObservers.Reset();

    delete iSessionId;

    }

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

// CPEngContactListManagerBase::CreateEmptyAttributeListL()

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

//

const CPEngSessionSlotId& CPEngContactListManagerBase::SessionId( ) const

    {

    return *iSessionId;

    }

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

// CPEngContactListManagerBase::Open()

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

//

void CPEngContactListManagerBase::Open()

    {

    iAccessCount++;

    }

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

// =============== Functions from MPEngContactListSettingsManager ==============

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

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

// CPEngContactListManagerBase::ContactListSettingsOrNull()

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

//

CPEngContactListSettings* CPEngContactListManagerBase::ContactListSettingsOrNull(

    const TDesC& aContactList )

    {

    TInt x ( FindContactListSettings( aContactList ) );

    if ( x == KErrNotFound )

        {

        return NULL;

        }

    return iContactListSettings[ x ];

    }

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

// CPEngContactListManagerBase::AddContactListSettingsObserverL()

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

//

void CPEngContactListManagerBase::AddContactListSettingsObserverL(

    const MPEngContactListSettingsObserver* aObserver )

    {

    // add observer

    User::LeaveIfError( iCntLstSettingsObservers.InsertInAddressOrder( aObserver ) );

    }

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

// CPEngContactListManagerBase::RemoveContactListSettingsObserver()

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

//

void CPEngContactListManagerBase::RemoveContactListSettingsObserver(

    const MPEngContactListSettingsObserver* aObserver )

    {

    // remove observer

    TInt index ( iCntLstSettingsObservers.FindInAddressOrder( aObserver ) );

    if ( index != KErrNotFound )

        {

        iCntLstSettingsObservers.Remove( index );

        }

    }

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

// CPEngContactListManagerBase::RemoveModel()

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

//

void CPEngContactListManagerBase::RemoveModel( CPEngContactListModBase* aModel )

    {

    TInt index( iContactLists.Find( aModel ) );

    if ( index != KErrNotFound )

        {

        iContactLists.Remove( index );

        }

    }

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

// CPEngContactListManagerBase::UserDomain()

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

//

const TDesC& CPEngContactListManagerBase::UserDomain() const

    {

    return iUserDomain;

    }

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

// CPEngContactListManagerBase::StoreSettingsL()

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

//

void CPEngContactListManagerBase::StoreSettingsL()

    {

    StoreL();

    }

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

// CPEngContactListManagerBase::StoreSize()

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

//

TInt& CPEngContactListManagerBase::StoreSize( )

    {

    return iSize;

    }

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

// ==================== Functions from CPresenceStoreEntry =====================

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

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

// CPEngContactListMainArray::ExternalizeL()

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

//

void CPEngContactListManagerBase::ExternalizeL( RWriteStream& aStream,

                                                TPEngStorageType aStorageType ) const

    {

    switch ( aStorageType )

        {

        case EPEngStorageBasicPermanent:

            {

            TInt count ( iContactListSettings.Count() );

            aStream.WriteInt32L( count );

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

                {

                iContactListSettings[x]->ExternalizeL( aStream,

                                                       aStorageType );

                }

            break;

            }

        case EPEngStorageBasicCached:

            {

            aStream.WriteInt32L( iEnviromentSynchronized );

            TInt count ( iContactListSettings.Count() );

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

                {

                iContactListSettings[x]->ExternalizeL( aStream,

                                                       aStorageType );

                }

            break;

            }

        default:

            {

            break;

            }

        }

    }

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

// CPEngContactListManagerBase::InternalizeL()

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

//

void CPEngContactListManagerBase::InternalizeL(

    RReadStream& aStream,

    TPEngStorageType aStorageType )

    {

    switch ( aStorageType )

        {

        case EPEngStorageBasicPermanent:

            {

            iContactListSettings.ResetAndDestroy();

            iSize = KMinimumStoreEntrySize;

            TInt count ( aStream.ReadInt32L() );

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

                {

                CPEngContactListSettings* newSettings =

                    CPEngContactListSettings::NewStreamLC( aStream,

                                                           *this );

                iContactListSettings.AppendL( newSettings );

                CleanupStack::Pop(); // newSettings

                }

            iEnviromentSynchronized = EFalse;

            break;

            }

        case EPEngStorageBasicCached:

            {

            iEnviromentSynchronized = aStream.ReadInt32L();

            TInt count ( iContactListSettings.Count() );

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

                {

                iContactListSettings[ x ]->InternalizeL( aStream,

                                                         aStorageType );

                }

            break;

            }

        default:

            {

            break;

            }

        }

    }

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

// CPEngContactListManagerBase::StorageId()

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

//

const TDesC& CPEngContactListManagerBase::StorageId() const

    {

    return KPEngContactListManagerSId;

    }

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

// CPEngContactListManagerBase::EntrySize()

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

//

TUint32 CPEngContactListManagerBase::EntrySize() const

    {

    return iSize;

    }

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

// ==================== Functions from MPEngSIDChangeObserver ==================

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

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

// CPEngContactListManagerBase::HandleSIDsChangeL()

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

//

void CPEngContactListManagerBase::HandleSIDsChangeL(

    CPtrCArray& /* aChangedSIDs */ )

    {

    TInt err( iStorageManager->RetrieveL( *this ) );

    if ( err == KErrNotFound )

        {

        InitWatcherListL();

        StoreL();

        }

    NotifyCntLstSettingsObservers();

    HandleSettingsUpdateL();

    }

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

// CPEngContactListManagerBase::HandleSIDNotifyError()

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

//

void CPEngContactListManagerBase::HandleSIDNotifyError( TInt /* aError */ )

    {

    NotifyCntLstSettingsObservers();

    }

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

// =============== protected functions for derived classes =====================

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

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

// CPEngContactListManagerBase::FindContactListSettings()

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

//

TInt CPEngContactListManagerBase::FindContactListSettings(

    const TDesC& aContactList ) const

    {

    TInt index( KErrNotFound );

    TPEngContactListSettingsIdAccessor settingsOrder;

    if ( KErrNone == FindEntryInArray( iContactListSettings,

                                       aContactList,

                                       index,

                                       settingsOrder,

                                       iUserDomain ) )

        {

        return index;

        }

    return KErrNotFound;

    }

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

// CPEngContactListManagerBase::InsertContactListSettingsL()

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

//

void CPEngContactListManagerBase::InsertContactListSettingsL(

    CPEngContactListSettings& aSettings )

    {

    TInt index( KErrNotFound );

    TPEngContactListSettingsIdAccessor settingsOrder;

    if ( KErrNone == FindEntryInArray( iContactListSettings,

                                       aSettings.Name(),

                                       index,

                                       settingsOrder,

                                       iUserDomain ) )

        {

        delete iContactListSettings[ index ];

        iContactListSettings[ index ] = &aSettings;

        }

    else