/*

* 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:  Manager for presence-list handling

*               (Contact-list updater/ Attribute-list publisher ).

*

*/

// INCLUDE FILES

#include "CCAPEngListManager.h"

#include "ChatDebugPrint.h"

#include "CAPresenceDefinitions.h"

#include "MCASettings.h"

#include "CAPresenceUtils.h"

#include "CCAPresenceErrors.h"

#include "CAPresenceConst.h"

#include "CCAPEngListObserver.h"

#include "ImpsErrors.h"

#include "MCAPresenceError.h"

#include "CCAStorageManagerFactory.h"

#include "MCAStoredContacts.h"

#include "MCAStoredContact.h"

#include "MCAContactList.h"

#include "MCAPresenceUpdater.h"

#include "CAUtils.h"

#include "impsbuilddefinitions.h"

#include "ChatDebugAssert.h"

#include <MPEngAttributeList2.h>

#include <MPEngContactList2.h>

#include <PEngWVPresenceAttributes2.h>

#include <CPEngContactListTransaction2.h>

#include <CPEngContactListStore2.h>

#include <CPEngAttributeListStore2.h>

#include <CPEngAttributeListTransaction2.h>

#include <CPEngPresenceNotifier2.h>

#include <MPEngTransactionStatus2.h>

#include <MPEngPresenceObserver2.h>

#include <MPEngContactListProperties.h>

#include <PEngPresenceEngineConsts2.h>

#include <TPEngContactListBaseSettings.h>

#include "MCAListInitObserver.h"

#include <impspresenceconnectionuiconstsng.h>

#include <CPEngNWSessionSlot2.h>

#include <CPEngNWSessionSlotID2.h>

// =============================== CONSTANTS ===================================

const TInt KMaxIdattempts = 50; // max amount of attempts to find unused id

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

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

// CCAPEngListManager::CCAPEngListManager

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

// might leave.

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

//

CCAPEngListManager::CCAPEngListManager( RArray<TUint32>& aHandledAttributes,

                                        MPEngPresenceObserver2& aNotifierObserver,

                                        MCASettings& aApplicationSettings,

                                        MCAPresenceUpdater& aUpdater )

        : iOperationError( KErrNone ),

        iIsLoggedIn( EFalse ),

        iAttributes( aHandledAttributes ),

        iNotifierObserver( aNotifierObserver ),

        iApplicationSettings( &aApplicationSettings ),

        iPresenceUpdater( aUpdater ),

        iMainViewProcessObserver( NULL ),

        iContactFetchingComplete( EFalse )

    {

    CHAT_DP_TXT( "CCAPEngListManager::CCAPEngListManager()" );

    }

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

// CCAPEngListManager::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CCAPEngListManager::ConstructL( CPEngNWSessionSlotID2* aSessionSlotID )

    {

    CHAT_DP_TXT( "CCAPEngListManager::ConstructL()" );

    iPEngContactListUpdater =

        CPEngContactListTransaction2::NewL( *aSessionSlotID );

    iPEngAttributeListPublisher =

        CPEngAttributeListTransaction2::NewL( *aSessionSlotID );

    iPEngContactListStore = CPEngContactListStore2::NewL( *aSessionSlotID );

    iPEngAttributeListStore = CPEngAttributeListStore2::NewL( *aSessionSlotID );

    iPEngAttributeNotifier = CPEngPresenceNotifier2::NewL( *aSessionSlotID );

    User::LeaveIfError( iPEngAttributeNotifier->AddObserver( *this ) );

    iErrors = CCAPresenceErrors::NewL();

    iListObserver = CCAPEngListObserver::NewL( aSessionSlotID,

                                               *iPEngAttributeNotifier, iAttributes, iPresenceUpdater );

    iAttribListSupported = AttribListsSupportedL( *aSessionSlotID );

#ifndef IMPS_CONTACT_FETCH_BACKGROUND

    // Start listening for presence events.

    RestartNotifierL();

#endif //IMPS_CONTACT_FETCH_BACKGROUND

    iObserver = NULL;

    iListInitInProcees = ETrue;

    }

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

// CCAPEngListManager::NewL

// Two-phased constructor.

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

//

CCAPEngListManager* CCAPEngListManager::NewL(

    MCASettings& aApplicationSettings,

    RArray<TUint32>& aHandledAttributes,

    MPEngPresenceObserver2& aNotifierObserver,

    CPEngNWSessionSlotID2* aSessionSlotID,

    MCAPresenceUpdater& aUpdater )

    {

    CHAT_DP_TXT( "CCAPEngListManager::NewL()" );

    CCAPEngListManager* self = new( ELeave ) CCAPEngListManager(

        aHandledAttributes,

        aNotifierObserver,

        aApplicationSettings,

        aUpdater );

    CleanupStack::PushL( self );

    self->ConstructL( aSessionSlotID );

    CleanupStack::Pop();

    return self;

    }

// Destructor

CCAPEngListManager::~CCAPEngListManager()

    {

    CHAT_DP_TXT( "CCAPEngListManager::~CCAPEngListManager()" );

    ReleaseListManager( EFalse );

    iObserver = NULL;

    }

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

// CCAPEngListManager::ReleaseListManager

//

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

//

void CCAPEngListManager::ReleaseListManager(

    TBool /*aReleaseContactListModels*/ )

    {

    CHAT_DP_TXT( "CCAPEngListManager::~CCAPEngListManager()" );

    delete iPEngAttributeListPublisher;

    iPEngAttributeListPublisher = NULL;

    delete iPEngContactListUpdater;

    iPEngContactListUpdater = NULL;

    delete iPEngContactListStore;

    iPEngContactListStore = NULL;

    delete iPEngAttributeListStore;

    iPEngAttributeListStore = NULL;

    delete iPEngAttributeNotifier;

    iPEngAttributeNotifier = NULL;

    delete iErrors;

    iErrors = NULL;

    delete iListObserver;

    iListObserver = NULL;

    delete iIdle;

    iIdle = NULL;

    delete iFetchIdle;

    iFetchIdle = NULL;

    delete iListIds;

    iListIds = NULL;

    iAppendContactsArray.Close();

    TInt count = iUpdateListQueue.Count();

    iUpdateListQueue.ResetAndDestroy();

    iContactFetchStep = MCAContactLists::EBaseSynchronise;

    // If this assert fails then all changes were not updated to network!

    // Check the implemententation of DeleteServerContactL

    __CHAT_ASSERT_DEBUG( count == 0 )

    }

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

// CCAPEngListManager::SetLoggedIn

// Sets network state

// (other items were commented in a header).

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

//

void CCAPEngListManager::SetLoggedIn( TBool aIsLoggedIn,

                                      CPEngNWSessionSlotID2* /*aSessionSlotID*/ )

    {

    if ( iIsLoggedIn && !aIsLoggedIn ) // Logout after login

        {

        CHAT_DP( D_CHAT_LIT( "CCAPEngListManager::SetLoggedIn: \

                             Release old lists." ) );

        // Release contact storage

        CancelPendingRequests();

        ReleaseListManager( ETrue );

        }

    iIsLoggedIn = aIsLoggedIn;

    }

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

// CCAPEngListManager::IsLoggedIn

// Returns network state

// (other items were commented in a header).

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

//

TBool CCAPEngListManager::IsLoggedIn() const

    {

    return iIsLoggedIn;

    }

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

// CCAPEngListManager::FetchContacts

// Launch next step of fetchcontacts

// (other items were commented in a header).

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

//

TInt CCAPEngListManager::FetchContacts( TAny *aInstance )

    {

    // called by CIdle to fetch the contacts on background

    CCAPEngListManager* instance = static_cast<CCAPEngListManager*>( aInstance );

    TInt launchAgain = EFalse;

    TRAPD( error, launchAgain = instance->FetchStateMachineL() );

    if ( error != KErrNone )

        {

        switch ( instance->iContactFetchStep )

            {

            case EPublishAttributeLists:

                {

                // creating the list of lists failed, sync can't continue

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

                instance->iContactFetchStep = ESynchronizeDone;

                break;

                }

            default:

                {

                MCAStoredContacts* storage = NULL;

                TRAP_IGNORE( storage = CCAStorageManagerFactory::ContactListInterfaceL() );

                if ( storage )

                    {

                    // list fetching failed, try next list

                    if ( storage->SetNextForSynchroniseProcess() != KErrNotFound )

                        {

                        return ETrue;

                        }

                    }

                // next list can't be tried, sync can't continue

                if ( error == KErrNoMemory )

                    {

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

                    }

                instance->iContactFetchStep = ESynchronizeDone;

                break;

                }

            }

        }

    return launchAgain;

    }

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

// CCAPEngListManager::FetchStateMachineL

// Launch next step of FetchStateMachineL

// (other items were commented in a header).

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

//

TInt CCAPEngListManager::FetchStateMachineL()

    {

    TBool launchAgain = EFalse;

    MCAStoredContacts* storage = CCAStorageManagerFactory::ContactListInterfaceL();

    switch ( iContactFetchStep )

        {

        case EBaseSynchronise: // -> ContactListTransactionComplete / Error

            {

            // Can leave cause first time is called from UI.

            // Base synchronise for getting lists.

            TBool autoUpdate =

                iApplicationSettings->Value( MCASettings::EAutomaticPresenceUpdate );

            TBool needToUnSubscribe = EFalse;

            //Mode is manual or automatic there is no need of sending unsubscribe message..

            User::LeaveIfError(

                iPEngContactListUpdater->BaseSynchronizeContactLists( *this, needToUnSubscribe ) );

            iContactFetchStep = EPublishAttributeLists;

            break;

            }

        case EPublishAttributeLists:

            {

            iContactFetchStep = EInitializeLists;

            launchAgain = ETrue;

            UpdatePresenceAuthorizeL();

            break;

            }

        case EInitializeLists:

            {

            TContactListsWrapper contactLists( iPEngContactListStore->AllContactListsL() );

            TInt count( contactLists.MdcaCount() );

            if ( count == 0 ) // no action needed cause no lists.

                {

                iContactFetchStep = ESynchronizeDone;

                storage->ResetContactLists();   // Used to send notification to UI

                iListInitInProcees = EFalse;

                if ( iObserver )

                    {

                    iObserver->HandleListInitChange( !iListInitInProcees );

                    }

                return KErrNone;

                }

            // Append lists to storage.

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

                {

                TPtrC listId( contactLists.MdcaPoint( a ) );

                TPtrC displayName( CAUtils::DisplayId( listId, ETrue ) );

                MCAContactList* newCaList =

                    storage->AddContactListIdL( listId, displayName );

                }

            // notify the View to show waiting nore for synch

            if ( storage->InitSynchroniseProcess() != KErrNotFound )

                {

                iContactFetchStep = ESynchronizeList;

                launchAgain = ETrue;

                }

            else

                {

                iContactFetchStep = ESynchronizeDone;

                }

            // Reset notifier.

            iListObserver->ClearListNotifier();

            break;

            }

        case ERestartSynchronize:

            {

            if ( storage->InitSynchroniseProcess() > KErrNotFound )

                {

                iContactFetchStep = ESynchronizeList;

                launchAgain = ETrue;

                }

            else

                {

                iContactFetchStep = ESynchronizeDone;

                }

            // Reset notifier.

            iListObserver->ClearListNotifier();

            break;

            }

        case ESynchronizeList: //-> ContactListTransactionCompleteL / Error

            {

            MCAContactList& list = storage->ListInSyncProcessL();

            iPEngContactListUpdater->SynchronizeContactList( list.ListId(), *this );

            iContactFetchStep = ESubscribeList;

            // init completed

            break;

            }

        case ESubscribeList: // SubscribeListL / HandleContactListTransactionCompleteL / Error

            {

            MCAContactList& list = storage->ListInSyncProcessL();

            TBool autoUpdate( iApplicationSettings->Value( MCASettings::EAutomaticPresenceUpdate ) );

            TPtrC listId( list.ListId() );

            TRAPD( error,

                   MPEngContactList2& cntList = iPEngContactListStore->ContactListL( listId );

                   // subscribe the list

                   iContactFetchStep = EFetchContacts;

                   SubscribeListL( cntList, listId, autoUpdate, ETrue );

                 );

            if ( error != KErrNone )

                {

                // sync failed, try next list

                list.SetSynchronised( MCAContactList::ESynchroniseFailed );

                User::Leave( error );

                }

            CDesCArray* contactlist = new( ELeave ) CDesCArrayFlat( 1 );

            CleanupStack::PushL( contactlist );

            contactlist->AppendL( listId );

            RestartNotifierL( contactlist );

            CleanupStack::PopAndDestroy( contactlist );

            iListInitInProcees = EFalse;

            if ( iObserver )

                {

                iObserver->HandleListInitChange( !iListInitInProcees );

                }

            break;

            }

        case EFetchContacts: // DoAppendContacts

            {

            MCAContactList& list = storage->ListInSyncProcessL();

            TPtrC listId( list.ListId() );

            // Make sure we have list in storage

            TAppendContactsParams appendParams = {

                NULL,

                NULL,

                NULL,

                storage,

                0,

                &list

                };

            TRAPD( error,

                   MPEngContactList2& cntList = iPEngContactListStore->ContactListL( listId );

                   appendParams.iContactList = &cntList;

                   appendParams.iEntryIndex = ( cntList.Count() - 1 );

                   User::LeaveIfError( iAppendContactsArray.Append( appendParams ) );

                   if ( !iIdle )

            {

            iIdle = CIdle::NewL( CActive::EPriorityIdle );

                }

            if ( !iIdle->IsActive() )

            {

            iIdle->Start( TCallBack( AppendContacts, this ) );

                }

            iContactFetchStep = EFinalizeList;

                 );

            if ( error != KErrNone )

                {

                // sync failed, try next list

                list.SetSynchronised( MCAContactList::ESynchroniseFailed );

                User::Leave( error );

                }

            break;

            }

        case EFinalizeList:

            {

            MCAContactList& list = storage->ListInSyncProcessL();

            TPtrC listId( list.ListId() );

            TRAPD( error,

                   MPEngContactList2& cntList = iPEngContactListStore->ContactListL( listId );

                   TPtrC displayName;

                   TInt success = ( cntList.ListProperties().DisplayName( displayName ) == KErrNone );

                   if ( success )

            {

            list.SetDisplayNameL( displayName );

                }

            list.SetSynchronised();

            // update list notifier

            iListObserver->AddL( listId );

                 );

            if ( error != KErrNone )

                {

                list.SetSynchronised( MCAContactList::ESynchroniseFailed );

                User::LeaveIfError( error );

                }

            // Keep lists sorted

            storage->SortContactLists();

            if ( storage->SetNextForSynchroniseProcess() > KErrNotFound )

                {

                // Then next one

                iContactFetchStep = ESynchronizeList;

                launchAgain = ETrue;

                }

            else

                {

                // All synchronised

                // and subscribed to network

                iContactFetchStep = EPublishListsDone;

                launchAgain = ETrue;

                }

            break;

            }

        case EPublishListsDone:

            {

            iContactFetchStep = ESynchronizeDone;

            RestartNotifierL();

            launchAgain = iStartFetchAgain;

            iStartFetchAgain = EFalse;

            iContactFetchingComplete = ETrue;

            if ( iMainViewProcessObserver )

                {

                iMainViewProcessObserver->HandleListInitChange( ETrue );

                }

            break;

            }

        default: //Should not come here

            {

            __CHAT_ASSERT_DEBUG( EFalse );

            break;

            }

        }

    CHAT_DP( D_CHAT_LIT( "CCAPEngListManager::DoFetchContactsL : Done" ) );

    return launchAgain;

    }

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