/*

* 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 operations (fetcher/notifier/publisher).

*

*/

// INCLUDE FILES

#include "CCAPEngPresenceManager.h"

#include "CAPresenceDefinitions.h"

#include "CAPresenceUtils.h"

#include "CCAPEngListManager.h"

// Contact handling

#include "CCAStorageManagerFactory.h"

#include "MCAStoredContacts.h"

#include "impsbuilddefinitions.h"

#include "MCAContactList.h"

#include "MCAStoredContact.h"

#include "ChatDebugPrint.h"

#include "MCAPresenceObserver.h"

#include "MCAWatcherObserver.h"

#include "MCASettings.h"

#include "CCAPresenceErrors.h"

#include "CAPresenceConst.h"

#include "MCAPresence.h"

#include "MCAContactLists.h"

#include "TCAWrappers.h"

#include "MCAReactiveAuthObserver.h"

#include "SServerPrefers.h"

#include "TDecodeAttrParams.h"

#include "ImpsCSPAllErrors.h"

#include <WVUIPresenceVariationNG.rsg>

#include <PEngWVPresenceAttributes2.h>

#include <PEngWVPresenceErrors2.h>

#include <CPEngPresenceNotifier2.h>

#include <CPEngAttributeTransaction2.h>

#include <CPEngAttributeStore2.h>

#include <CPEngTrackedPresenceIDs2.h>

#include <CPEngTrackedPresenceID2.h>

#include <CIMPSSAPSettingsStore.h>

#include <PEngPresenceEngineConsts2.h>

#include <CPEngNWSessionSlotID2.h>

#include <MPEngPresenceAttrModel2.h>

#include <MPEngTransactionStatus2.h>

#include <CPEngReactAuthStore.h>

#include <CPEngReactAuthTransaction.h>

#include <CPEngReactAuthNotifier.h>

#include <CPEngReactAuthTransaction.h>

#include <MPEngReactAuthObserver.h>

#include <MPEngReactAuthTransactionObserver.h>

#include <MPEngAuthorizationRequest.h>

#include <MPEngAuthorizationRespond.h>

#include <MPEngAuthorizationStatus.h>

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

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

// CCAPEngPresenceManager::CCAPEngPresenceManager

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

// might leave.

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

//

CCAPEngPresenceManager::CCAPEngPresenceManager()

        : iAuthMode( KUndefined ),

        iNetworkState( KUndefined ),

        iPEngAPIInitialized( EFalse ),

        iObserverQueued( EFalse ),

        iCachedStatus( EFalse ),

        iAttributeProcessing( ETrue )

    {

    }

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

// CCAPEngPresenceManager::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CCAPEngPresenceManager::ConstructL( MCASettings* aApplicationSettings )

    {

    // Set settings API

    SetSettingsAPIL( aApplicationSettings );

    // Assign attributes that we are handling

    ResetAttributesL( EFalse );

    // Create detailed error container

    iErrors = CCAPresenceErrors::NewL();

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

    }

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

// CCAPEngPresenceManager::NewL

// Two-phased constructor.

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

//

CCAPEngPresenceManager* CCAPEngPresenceManager::NewL(

    MCASettings* aApplicationSettings )

    {

    CCAPEngPresenceManager* self = new( ELeave ) CCAPEngPresenceManager;

    CleanupStack::PushL( self );

    self->ConstructL( aApplicationSettings );

    CleanupStack::Pop( self );

    return self;

    }

// Destructor

CCAPEngPresenceManager::~CCAPEngPresenceManager()

    {

    delete iPEngAttributeTransaction;

    delete iListManager;

    delete iPEngAttributeStore;

    delete iErrors;

    if ( iOwnPresenceNotifier )

        {

        iOwnPresenceNotifier->RemoveObserver( *this );

        }

    delete iOwnPresenceNotifier;

    delete iCachedStatusText;

    iAttributes.Close();

    if ( iRANotifier )

        {

        iRANotifier->RemoveObserver( *this );

        iRANotifier->Stop();

        }

    delete iRAStore;

    delete iRANotifier;

    delete iRATransaction;

    delete iSessionSlotID;

    iOwnStates.ResetAndDestroy();

    iPresenceStates.ResetAndDestroy();

    iFetchObjects.ResetAndDestroy();

    TInt count( iAttrArrays.Count() );

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

        {

        iAttrArrays[ a ].iArray.ResetAndDestroy();

        }

    iAttrArrays.Close();

    delete iIdle;

    }

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

// CCAPEngPresenceManager::AddWatcherL

// Sets watcher flag for given contact

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

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

//

void CCAPEngPresenceManager::AddWatcherL( const TDesC& aWVId )

    {

    CHAT_DP_TXT( "CCAPEngPresenceManager::AddWatcherL" );

    CCAStorageManagerFactory::ContactListInterfaceL()->SetWatched( aWVId, ETrue );

    }

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

// CCAPEngPresenceManager::GetOnlineFriendsL

// Fetches list of online-friends

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

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

//

void CCAPEngPresenceManager::GetOnlineFriendsL( CDesCArray &aOnlineList,

                                                TBool aFetchFromNetwork )

    {

    CHAT_DP_TXT( "CCAPEngPresenceManager::GetOnlineFriendsL()...starts" );

    CPtrCArray* friends = CAPresenceUtils::GenerateFriendsArrayLC(

                              CCAStorageManagerFactory::ContactListInterfaceL() );

    // Reset given array

    aOnlineList.Reset();

    // update our lists

    if ( aFetchFromNetwork )

        {

        CHAT_DP_TXT( "CCAPEngPresenceManager::GetOnlineFriendsL starting \

                      network fetch" );

        FetchAttributesL( *friends, &aOnlineList, NULL, NULL, EFalse );

        }

    // Populate aOnlineList with online friends

    TInt friendCount( friends->Count() );

    MCAStoredContact* contact = NULL;

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

        {

        contact = CCAStorageManagerFactory::ContactListInterfaceL()->

                  FindAnyContact( ( *friends )[i] );

        if ( contact )

            {

            TStorageManagerGlobals::TPresenceStatus status =

                contact->OnlineStatus();

            if ( status == TStorageManagerGlobals::EOnline ||

                 status == TStorageManagerGlobals::EAway ||

                 status == TStorageManagerGlobals::EBusy )

                {

                aOnlineList.AppendL( contact->UserId() );

                }

            }

        }

    CleanupStack::PopAndDestroy( friends );

    CHAT_DP_TXT( "CCAPEngPresenceManager::GetOnlineFriendsL...over" );

    }

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

// CCAPEngPresenceManager::GetOnlineUsersL

// Fetches list of online users from given user-list

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

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

//

void CCAPEngPresenceManager::GetOnlineUsersL( const CDesCArray &aUserList,

                                              CDesCArray *aOnlineList,

                                              CDesCArray *aOffLineList,

                                              TBool aUpdateStorage /*= EFalse*/ )

    {

    CHAT_DP( D_CHAT_LIT( "CCAPEngPresenceManager::GetOnlineUsersL, \

                          aUserList.Count() = %d, &aOnlineList = %d, \

                          &aOffLineList = %d" ),

             aUserList.Count(), aOnlineList, aOffLineList );

    FetchAttributesL( aUserList, aOnlineList, aOffLineList, NULL,

                      aUpdateStorage );

    CHAT_DP_TXT( "CCAPEngPresenceManager::GetOnlineUsersL done" );

    }

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

// CCAPEngPresenceManager::PresenceObserver

// Returns presence-observer pointer

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

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

//

MCAPresenceObserver* CCAPEngPresenceManager::PresenceObserver() const

    {

    return iPresenceObserver;

    }

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

// CCAPEngPresenceManager::RefreshFriendsL

// Refreshes the presence status of friends according to refresh-flags

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

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

//

void CCAPEngPresenceManager::RefreshFriendsL()

    {

    // Create needed MDesCArray-based array for presence operations

    CPtrCArray* contactsArray = CAPresenceUtils::GenerateFriendsArrayLC(

                                    CCAStorageManagerFactory::ContactListInterfaceL()/*, EFalse*/ );

    FetchAttributesL( *contactsArray, NULL, NULL, NULL, ETrue );

    CleanupStack::PopAndDestroy( contactsArray );

    }

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

// CCAPEngPresenceManager::SubscribeFriendsL

// Subscribes friends based on update-flag

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

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

//

void CCAPEngPresenceManager::SubscribeFriendsL( const TSubscribeMode aMode )

    {

    CHAT_DP( D_CHAT_LIT( "CCAPEngPresenceManager::SubscribeFriendsL, mode = %d" ),

             aMode );

    if ( !iPEngAPIInitialized )

        {

        return;

        }

    iListManager->SubscribeListsL( aMode == MCAPresence::ESubscribe );

    }

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

// CCAPEngPresenceManager::ContactLists

// Returns contact-list-handling interface

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

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

//

MCAContactLists* CCAPEngPresenceManager::ContactLists()

    {

    return iListManager;

    }

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

// CCAPEngPresenceManager::LastOperationResult

// Returns last operation's error results

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

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

//

const CCAPresenceErrors& CCAPEngPresenceManager::LastOperationResult() const

    {

    return *iErrors;

    }

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

// CCAPEngPresenceManager::SettingsAPI

// Return settings-API

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

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

//

MCASettings* CCAPEngPresenceManager::SettingsAPI() const

    {

    return iApplicationSettings;

    }

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

// CCAPEngPresenceManager::SetSettingsAPIL

// Sets settings API

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

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

//

void CCAPEngPresenceManager::SetSettingsAPIL(

    MCASettings* aApplicationSettings )

    {

    // CCAPEngPresenceManager need settings API to function correctly

    if ( !iApplicationSettings && !aApplicationSettings )

        {

        User::Leave( ECANoSettingsAPI );

        }

    // If settings API handle provided, then update current handle

    if ( aApplicationSettings )

        {

        iApplicationSettings = aApplicationSettings;

        }

    }

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

// CCAPEngPresenceManager::RemoveWatcherL

// Removes watcher from given user

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

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

//

void CCAPEngPresenceManager::RemoveWatcherL( const TDesC &aWVId )

    {

    CHAT_DP_TXT( "CCAPEngPresenceManager::RemoveWatcherL" );

    CCAStorageManagerFactory::ContactListInterfaceL()->

    SetWatched( aWVId, EFalse );

    }

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

// CCAPEngPresenceManager::SetPresenceObserver

// Sets presence observer

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

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

//

void CCAPEngPresenceManager::SetPresenceObserver(

    MCAPresenceObserver* aObserver )

    {

    iPresenceObserver = aObserver;

    }

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

// CCAPEngPresenceManager::SetWatcherObserver

// Sets watcher observer

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

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

//

void CCAPEngPresenceManager::SetWatcherObserver( MCAWatcherObserver* aObserver )

    {

    iWatcherObserver = aObserver;

    }

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

// CCAPEngPresenceManager::HandleNetworkStateL

// To be called when network state changes

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

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

//

void CCAPEngPresenceManager::HandleNetworkStateL( TNetworkStatus aState,

                                                  const SServerPrefers& aServerPreferences,

                                                  CPEngNWSessionSlotID2* aSessionSlotID )

    {

    CHAT_DP_FUNC_ENTER( "CCAPEngPresenceManager::HandleNetworkState" );

    // read own states from resource

    CAPresenceUtils::ReadStatesFromResourceL(

        RSC_CHAT_VARIATION_OWN_PRESENCE_STATES, iOwnStates );

    // read incoming presence states from resource

    CAPresenceUtils::ReadStatesFromResourceL(

        RSC_CHAT_VARIATION_PRESENCE_STATES, iPresenceStates );

    iServerPrefers = aServerPreferences;

    iAliasUsed = aServerPreferences.iAliasUsed;

    if ( aState != EUpdateBrand )

        {

        // notification of branding must not keep the state

        // changed, but should be returned to the existing state

        iNetworkState = aState;

        }

    if ( aState == ELoggedIn )

        {

        // initialize own presence observer, if one is queued

        InitializeOwnPresenceObserverL();

        // check if we have cached values

        if ( iCachedAppSettingsAuthValue )

            {

            SetPresenceAuthorizationL( iCachedAppSettingsAuthValue );

            iCachedAppSettingsAuthValue = 0;

            }

        if ( iCachedStatus )

            {

            ChangeStatusL( iCachedPresenceStatus, *iCachedStatusText );

            iCachedStatus = EFalse;

            delete iCachedStatusText;

            iCachedStatusText = NULL;

            }

        else if ( iCachedStatusText )

            {

            ChangeStatusMessageL( *iCachedStatusText );

            delete iCachedStatusText;

            iCachedStatusText = NULL;

            }

        }

    // update own state and notify observers

    NotifyOwnPresenceObserverL();

    if ( aState == EUpdateBrand )

        {

        iRAUsed = aServerPreferences.iReactiveAuthorization;

        iAliasUsed = aServerPreferences.iAliasUsed;

        return;

        }

    if ( iListManager )

        {

        iListManager->SetLoggedIn( iNetworkState == ELoggedIn, aSessionSlotID );

        }

    if ( !IsLoggedIn() )

        {

        // logging out

        CancelPendingRequests();

        // stop the RA notifier

        if ( iRANotifier )

            {

            iRANotifier->Stop();

            }

        }

    CHAT_DP_FUNC_DONE( "CCAPEngPresenceManager::HandleNetworkState" );

    }

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

// CCAPEngPresenceManager::InitializePEngAPIL

// Handles changes in setting values

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

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

//

void CCAPEngPresenceManager::InitializePEngAPIL()

    {

    // we can straight delete the old one, since

    // if creating does not work, then we cannot do anything anyway

    delete iListManager;

    iListManager = NULL;

    // Create list manager

    iListManager = CCAPEngListManager::NewL(

                       *iApplicationSettings,

                       iAttributes,

                       *this,             // presence observer

                       iSessionSlotID,

                       *this );           // presence updater

    delete iPEngAttributeTransaction;

    iPEngAttributeTransaction = NULL;

    // Create publisher

    iPEngAttributeTransaction =

        CPEngAttributeTransaction2::NewL( *iSessionSlotID );

    delete iPEngAttributeStore;

    iPEngAttributeStore = NULL;

    // Create attribute store

    iPEngAttributeStore = CPEngAttributeStore2::NewL( *iSessionSlotID );

    // reactive authorization stuffs

    delete iRAStore;

    iRAStore = NULL;

    iRAStore = CPEngReactAuthStore::NewL( *iSessionSlotID );

    delete iRANotifier;

    iRANotifier = NULL;

    iRANotifier = CPEngReactAuthNotifier::NewL( *iSessionSlotID );

    iRANotifier->AddObserver( *this );

    delete iRATransaction;

    iRATransaction = NULL;

    iRATransaction = CPEngReactAuthTransaction::NewL( *iSessionSlotID );

    iPEngAPIInitialized = ETrue;