/*

* Copyright (c) 2002-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:  Storage manager implementation

 *

*/

// INCLUDE FILES

#include "CCAStorageManager.h"

#include "CCAStorage.h"

#include "CCARefreshTimer.h"

#include "CCAContactList.h"

#include "CCAGroup.h"

#include "CCAContact.h"

#include "CCAContactSorter.h"

#include "CAUtils.h"

#include "ChatDebugPrint.h"

#include "chatdebugassert.h"

#include <PEngPresenceEngineConsts2.h> // for KPEngUserOwnPresenceId

// CONSTANTS

// Own device type, default to mobile

const TStorageManagerGlobals::TClientType KOwnDeviceType =

    TStorageManagerGlobals::EMobile;

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

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

// CCAStorageManager::InstanceL

// Factory method to return the singleton instance of this class,

// used by CCAStorageManagerFactory

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

//

CCAStorageManager* CCAStorageManager::InstanceL()

    {

    CCAStorageManager *sm = NULL;

    sm = static_cast<CCAStorageManager*>( Dll::Tls() );

    if ( ! sm )

        {

        // no existing instance, create a new one

        CCAStorageManager *manager = CCAStorageManager::NewL();

        sm = manager;

        CleanupStack::PushL( manager );

        User::LeaveIfError( Dll::SetTls( static_cast<TAny*>( sm ) ) );

        CleanupStack::Pop( manager );

        }

    return sm;

    }

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

// CCAStorageManager::ReleaseL

// Factory method to release the singleton instance of this class,

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

//

TInt CCAStorageManager::ReleaseL()

    {

    // about to unload, so kill the singleton instance

    if ( Dll::Tls() )

        {

        CCAStorageManager *storage = NULL;

        storage = static_cast<CCAStorageManager*>( Dll::Tls() );

        if ( storage )

            {

            delete storage;

            storage = NULL;

            }

        }

    // Ignore error

    Dll::SetTls( NULL );

    return KErrNone;

    }

// panic handler

GLDEF_C void Panic( TCAStoragePanics aPanic )

    {

    User::Panic( KChatStoragePanicString, aPanic );

    }

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

// CCAStorageManager::CCAStorageManager

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CCAStorageManager::CCAStorageManager() :

        iNotifyUponSave( ETrue ),

        iRefreshStartCounter( 0 ),

        iShowNickname( ETrue ),

        iGroupDeleted( EFalse )

    {

    }

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

// CCAStorageManager::ConstructL

// Symbian 2nd phase constructor can leave.

// The constructor also does synchronizing with Phone Book by removing the

// deleted elements from the persistent storage

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

//

void CCAStorageManager::ConstructL()

    {

    CHAT_DP_TXT( "CCAStorageManager::ConstructL" );

    CHAT_DP_TXT( "CCAStorageManager::Creating Storage" );

    iStorage = CCAStorage::NewL();

    iRefreshTimer = CCARefreshTimer::NewL( this );

    // create sorter for contacts

    iContactSorter = CCAContactSorter::NewL();

    // handle Groups

    CHAT_DP_TXT( "CCAStorageManager::ConstructL - Synching group data with \

                  persistent storage" );

    SynchronizeGroupsL();

    iOwnStatus = CCAContact::NewL( this, this );

    iOwnStatus->SetClientType( KOwnDeviceType );

    CHAT_DP_TXT( "CCAStorageManager::ConstructL - Done" );

    }

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

// CCAStorageManager::SynchronizeGroups

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

//

void CCAStorageManager::SynchronizeGroupsL()

    {

    // read the groups, if any

    TBool fetching( ETrue );

    for ( TInt i = 0; fetching ; i++ )

        {

        CCAGroup* group = CCAGroup::NewL( iStorage, this );

        CleanupStack::PushL( group );

        TInt storStatus( KErrNone );

        TInt err( KErrNone );

        if ( 0 == i )

            {

            // first iteration

            CHAT_DP_TXT( "CCAStorageManager::SynchronizeGroupsL - Loading \

                          first group" );

            // Load Leaves if storage has no more groups

            TRAP( err, storStatus = iStorage->LoadFirstL( group ) );

            }

        else

            {

            // subsequent iterations

            CHAT_DP_TXT( "CCAStorageManager::SynchronizeGroupsL - Loading next \

                          group" );

            // Load Leaves if storage has no more groups

            TRAP( err, storStatus = iStorage->LoadNextL( group ) );

            }

        if ( ( KErrNotFound == storStatus ) || ( KErrNone != err ) )

            {

            // no more groups, that's all

            CHAT_DP_TXT( "CCAStorageManager::SynchronizeGroupsL - No groups in \

                          persistent storage" );

            fetching = EFalse;

            }

        else

            {

            // found some group, add to our list

            CHAT_DP_TXT( "CCAStorageManager::SynchronizeGroupsL - Found group, \

                          adding to list" );

            // valid group, add to our list

            group->SetStorageType( TStorageManagerGlobals::EStoragePersistent );

            TInt status = iGroupList.Append( group );

            User::LeaveIfError( status );

            }

        if ( fetching == EFalse )

            {

            // all done

            CleanupStack::PopAndDestroy( group ); // group

            }

        else

            {

            // going to next iteration

            CleanupStack::Pop( group ); // group

            }

        }

    CHAT_DP_TXT( "CCAStorageManager::SynchronizeGroupsL - Done" );

    }

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

// CCAStorageManager::NewL

// Two-phased constructor.

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

//

EXPORT_C CCAStorageManager* CCAStorageManager::NewL()

    {

    CCAStorageManager* self = new( ELeave ) CCAStorageManager;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// Destructor

CCAStorageManager::~CCAStorageManager()

    {

    CHAT_DP_TXT( "CCAStorageManager::~CCAStorageManager" );

    delete iRefreshTimer;

    delete iLatestContactToRefresh;

    iContactObservers.Reset();

    iContactObservers.Close();

    iGroupObservers.Reset();

    iGroupObservers.Close();

    iContactList.ResetAndDestroy();

    iGroupList.ResetAndDestroy();

    delete iStorage;

    delete iContactSorter;

    delete iOwnStatus;

    CHAT_DP_TXT( "CCAStorageManager::~CCAStorageManager - I am dead" );

    }

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

// CCAStorageManager::SendObserverEventL

// If the changed/deleted contact is in our list, the observers are notified.

// Otherwise the observers are not notified.

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

void CCAStorageManager::SendObserverEvent(

    TStorageManagerGlobals::TCAObserverEventType aType,

    MCAStoredContact* aContact,

    const TDesC& aContactId,

    MCAContactList* aList /*= NULL*/,

    TBool aUserIdChanged /*= EFalse*/ )

    {

    CHAT_DP_TXT( "CCAStorageManager::SendObserverEventL (contact)" );

    CHAT_DP_TXT( "CCAStorageManager::SendObserverEventL - Notifying \

                  MCAStoredContactsObserver observers" );

    if ( !iContactListLock )

        {

        switch ( aType )

            {

            case TStorageManagerGlobals::EStorageEventPostChange: // flowtrough

            case TStorageManagerGlobals::EStorageEventOwnStatusChange:

                {

                NotifyAllObserversWithDelay( aType, aContact, aContactId, aList,

                                             aUserIdChanged );

                break;

                }

            default:

                {

                NotifyAllObservers( aType, aContact, aContactId, aList, aUserIdChanged );

                break;

                }

            }

        }

    }

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

// CCAStorageManager::NotifyAllObservers

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

//

void CCAStorageManager::NotifyAllObservers( TStorageManagerGlobals::TCAObserverEventType aType,

                                            MCAStoredContact* aContact, const TDesC& aContactId,

                                            MCAContactList* aList,

                                            TBool aUserIdChanged )

    {

    CHAT_DP_FUNC_ENTER( "NotifyAllObservers" );

    // tell all of the observers about the event.

    // the amount of observers might change during the loop,

    // so the count MUST be taken in every round

    for ( TInt i = 0; i < iContactObservers.Count(); i++ )

        {

        MCAStoredContactsObserver* obs = iContactObservers[i];

        switch ( aType )

            {

            case TStorageManagerGlobals::EStorageEventPreChange:

            case TStorageManagerGlobals::EStorageEventPostChange:

                {

                obs->HandleChange( aList, aContact, aType, aUserIdChanged );

                break;

                }

            case TStorageManagerGlobals::EStorageEventContactDelete:

                {

                obs->HandleContactDelete( aContactId );

                break;

                }

            case TStorageManagerGlobals::EStorageEventContactAddition:

                {

                if ( aList )

                    {

                    obs->HandleAddition( *aList, *aContact );

                    }

                break;

                }

            case TStorageManagerGlobals::EStorageEventOwnStatusChange:

            case TStorageManagerGlobals::EStorageEventMultipleChanges:

            case TStorageManagerGlobals::EStorageEventListAddition:

            case TStorageManagerGlobals::EStorageEventListDelete:

            case TStorageManagerGlobals::EStorageEventListChanged:

                {

                obs->HandleChange( aList, NULL, aType, EFalse );

                break;

                }

            default:

                {

                break;

                }

            }

        }

    CHAT_DP_FUNC_DONE( "NotifyAllObservers" );

    }

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

// CCAStorageManager::NotifyAllObserversWithDelay

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

//

void CCAStorageManager::NotifyAllObserversWithDelay(

    TStorageManagerGlobals::TCAObserverEventType aType,

    MCAStoredContact* aContact, const TDesC& aContactId,

    MCAContactList* aList,

    TBool aUserIdChanged )

    {

    TRAPD( err, DoNotifyAllObserversWithDelayL( aType, aContact, aContactId,

                                                aList, aUserIdChanged ) );

    if ( err )

        {

        CActiveScheduler::Current()->Error( err );

        }

    }

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

// CCAStorageManager::DoNotifyAllObserversWithDelayL

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

//

void CCAStorageManager::DoNotifyAllObserversWithDelayL(

    TStorageManagerGlobals::TCAObserverEventType aType,

    MCAStoredContact* /*aContact*/, const TDesC& aContactId,

    MCAContactList* aList, TBool aUserIdChanged )

    {

    HBufC* tmpID = aContactId.AllocL();

    delete iLatestContactToRefresh;

    iLatestContactToRefresh = tmpID;

    iLatestContactList = aList;

    tmpID = NULL;

    iRefreshEventType = aType;

    iRefreshUserIdChanged = aUserIdChanged;

    ++iRefreshStartCounter;

    if ( iRefreshTimer->IsActive() )

        {

        iRefreshTimer->Cancel();

        }

    iRefreshTimer->Start();

    }

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

// CCAStorageManager::SendObserverEventL (overridden for group)

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

//

void CCAStorageManager::SendObserverEvent(

    TStorageManagerGlobals::TCAObserverEventType aType,

    const TDesC& aParameter )

    {

    CHAT_DP_TXT( "CCAStorageManager::SendObserverEventL (group)" );

    TInt pos( FindGroupIndexByGroupId( aParameter ) );

    if ( KErrNotFound == pos )

        {

        return;     // not found in the list

        }

    CHAT_DP_TXT( "CCAStorageManager::SendObserverEventL - Notifying \

                  MCAStoredGroupsObserver observers" );

    // tell all of the observers about the event

    const TInt count( iGroupObservers.Count() );

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

        {

        MCAStoredGroupsObserver* obs = iGroupObservers[i];

        switch ( aType )

            {

            case TStorageManagerGlobals::EStorageEventGroupChange:

                {

                obs->HandleChange( aParameter );

                break;

                }

            case TStorageManagerGlobals::EStorageEventContactDelete:

                {

                obs->HandleDelete( aParameter );

                break;

                }

            case TStorageManagerGlobals::EStorageEventContactAddition:

                {

                obs->HandleAddition( aParameter );

                break;

                }

            default:

                {

                break;

                }

            }

        }

    }

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

// CCAStorageManager::AddObserverL

// From MCAStoredContacts

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

//

void CCAStorageManager::AddObserverL( MCAStoredContactsObserver*

                                      aObserver )

    {

    __ASSERT_ALWAYS( aObserver, Panic( EObserverIsNull ) );

    TInt status( iContactObservers.Append( aObserver ) );

    User::LeaveIfError( status );

    }

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

// CCAStorageManager::RemoveObserverL

// From MCAStoredContacts

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

void CCAStorageManager::RemoveObserver( MCAStoredContactsObserver*

                                        aObserver )

    {

    __ASSERT_ALWAYS( aObserver, Panic( EObserverIsNull ) );

    const TInt status( iContactObservers.Find( aObserver ) );

    if ( status != KErrNotFound )

        {

        iContactObservers.Remove( status );

        iContactObservers.Compress();

        }

    }

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

// CCAStorageManager::AddObserverL

// From MCAStoredGroups

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

//

void CCAStorageManager::AddObserverL( MCAStoredGroupsObserver*

                                      aObserver )

    {

    __ASSERT_ALWAYS( aObserver, Panic( EObserverIsNull ) );

    TInt status( iGroupObservers.Append( aObserver ) );

    User::LeaveIfError( status );

    }

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

// CCAStorageManager::RemoveObserverL

// From MCAStoredGroups

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

//

void CCAStorageManager::RemoveObserver( MCAStoredGroupsObserver*

                                        aObserver )

    {

    __ASSERT_ALWAYS( aObserver, Panic( EObserverIsNull ) );

    const TInt status( iGroupObservers.Find( aObserver ) );

    if ( status != KErrNotFound )

        {

        iGroupObservers.Remove( status );

        iGroupObservers.Compress();

        }

    }

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

// CCAStorageManager::AddContactListIdL

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

//

MCAContactList* CCAStorageManager::AddContactListIdL(

    const TDesC& aContactListId,

    const TDesC& aDisplayName,

    TBool aNotify )

    {

    CCAContactList* contactList = CCAContactList::NewLC( *this,

                                                         *iContactSorter,

                                                         *this,

                                                         aContactListId,

                                                         aDisplayName );

    TIdentityRelation< CCAContactList > findBy(

        CCAStorageManager::ContactListFindByContactId );

    TInt indexOfList( iContactList.Find( contactList, findBy ) );

    if ( indexOfList == KErrNotFound )

        {

        TLinearOrder< CCAContactList > order(

            CCAStorageManager::ContactListOrderByDisplayName );

        iContactList.InsertInOrderAllowRepeats( contactList, order );

        CleanupStack::Pop( contactList );

        }

    else

        {

        CleanupStack::PopAndDestroy( contactList );

        contactList = iContactList[ indexOfList ];

        }

    // Inform observers

    if ( aNotify )

        {

        SendObserverEvent( TStorageManagerGlobals::EStorageEventListAddition,

                           NULL,