/*

* Copyright (c) 2006 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:  Global interface for the UI to get notifications when theres a

*				 change in contact, list, invite, settings, conversation, group etc

*

*/

#include "MCAContactListModel.h"

#include "MCAChatInterface.h"

#include "MCAInvite.h"

#include "MCASettings.h"

#include "TStorageManagerGlobals.h"

#include "MCAContactList.h"

#include "MCAStoredContact.h"

#include "MCAStoredContacts.h"

#include "CCAStorageManagerFactory.h"

#include "MCAMessage.h"

#include "MCAMessageUtils.h"

#include "MCAUiGlobalNotificationObserverPC.h"

#include "CCAGlobalNotificationObserverPC.h"

#include "MCAMessageErrorInformer.h"

#include "MCAContactLists.h"

#include "capresencemanager.h"

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

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

// CCAGlobalNotificationObserverPC::CCAGlobalNotificationObserverPC

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

CCAGlobalNotificationObserverPC::CCAGlobalNotificationObserverPC(

    MCAContactListModel& aContactListModel,

    MCAChatInterface& aChatInterface,

    MCAInvite& aInviteInterface,

    MCASettings& aSettingsInterface,

    const MCAMessageUtils& aMessageUtils )

        : iContactListModel( aContactListModel ),

        iChatInterface( aChatInterface ),

        iInviteInterface( aInviteInterface ),

        iSettingsInterface( aSettingsInterface ),

        iMessageUtils( aMessageUtils )

    {

    }

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

// CCAGlobalNotificationObserverPC::NewL

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

CCAGlobalNotificationObserverPC* CCAGlobalNotificationObserverPC::NewL(

    MCAContactListModel& aContactListModel,

    MCAChatInterface& aChatInterface,

    MCAInvite& aInviteObserver,

    MCASettings& aSettingsInterface,

    const MCAMessageUtils& aMessageUtils )

    {

    CCAGlobalNotificationObserverPC* self

    = new ( ELeave ) CCAGlobalNotificationObserverPC(

        aContactListModel,

        aChatInterface,

        aInviteObserver,

        aSettingsInterface,

        aMessageUtils );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CCAGlobalNotificationObserverPC::ConstructL

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

void CCAGlobalNotificationObserverPC::ConstructL()

    {

    iContactInterface = CCAStorageManagerFactory::ContactListInterfaceL();

    iContactInterface->AddObserverL( this );// listen these events..

    iInviteInterface.AddInviteObserver( this );

    iSettingsInterface.AddObserverL( this );  //register with engine

    // Register this as chat observer

    iChatInterface.RegisterChatObserver( this );

    iMessageUtils.MessageErrorInformer().RegisterObserver( this );

    }

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

// CCAGlobalNotificationObserverPC::~CCAGlobalNotificationObserverPC

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

CCAGlobalNotificationObserverPC::~CCAGlobalNotificationObserverPC()

    {

    iGlobalNotificationObservers.ResetAndDestroy();

    iGlobalNotificationObservers.Close();

    if ( iContactInterface )

        {

        iContactInterface->RemoveObserver( this );

        }

    iInviteInterface.RemoveInviteObserver( this );

    iSettingsInterface.RemoveObserver( this );

    iChatInterface.UnregisterChatObserver( this );

    iMessageUtils.MessageErrorInformer().UnregisterObserver( this );

    }

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

// CCAGlobalNotificationObserverPC::HandleContactDelete

// MCAStoredContactsObserver implementation

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

void CCAGlobalNotificationObserverPC::HandleContactDelete( const TDesC& aContactId )

    {

    for ( TInt index = 0; index < iGlobalNotificationObservers.Count(); index++ )

        {

        iGlobalNotificationObservers[index]->HandleDelete( aContactId, TEnumsPC::EContactItem );

        }

    }

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

// CCAGlobalNotificationObserverPC::HandleAddition

// MCAStoredContactsObserver implementation

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

void CCAGlobalNotificationObserverPC::HandleAddition( MCAContactList& /*aList*/, MCAStoredContact& /*aContact*/ )

    {

    for ( TInt index = 0; index < iGlobalNotificationObservers.Count(); index++ )

        {

        iGlobalNotificationObservers[index]->HandleAddition( TEnumsPC::EContactItem );

        }

    }

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

// CCAGlobalNotificationObserverPC::HandleChange

// MCAStoredContactsObserver implementation

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

void CCAGlobalNotificationObserverPC::HandleChange( MCAContactList* aList, MCAStoredContact* /*aContact*/,

                                                    TStorageManagerGlobals::TCAObserverEventType aEventType,

                                                    TBool /*aUserIdChanged */ )

    {

    // we need to handle the change here..from storage manager...

    TEnumsPC::TChange eventtype = TEnumsPC::EUnknownEvent;

    TInt error( KErrNone );

    switch ( aEventType )

        {

        case TStorageManagerGlobals::EStorageEventPreChange:

            {

            // ignore the pre-change events

            return;

            }

        case TStorageManagerGlobals::EStorageEventListDelete:

        case TStorageManagerGlobals::EStorageEventMultipleChanges:

            {

            TInt index = iContactListModel.IndexOfList( aList, EFalse, ETrue );

            eventtype = aEventType == TStorageManagerGlobals::EStorageEventListDelete

                        ? TEnumsPC::EDelete : TEnumsPC::EMultipleChanges;

            for ( TInt index = 0; index < iGlobalNotificationObservers.Count(); index++ )

                {

                iGlobalNotificationObservers[index]->HandleChange(

                    TEnumsPC::EContactListItem,	eventtype );

                }

            break;

            }

        case TStorageManagerGlobals::EStorageEventPostChange:

            {

            // call back the UI with HandleChange here....

            for ( TInt index = 0; index < iGlobalNotificationObservers.Count(); index++ )

                {

                iGlobalNotificationObservers[index]->HandleChange(

                    TEnumsPC::EContactItem, TEnumsPC::EChanged );

                }

            break;

            }

        case TStorageManagerGlobals::EStorageEventListAddition:

        case TStorageManagerGlobals::EStorageEventListChanged:

            {

            eventtype = aEventType == TStorageManagerGlobals::EStorageEventListAddition

                        ? TEnumsPC::EAddition : TEnumsPC::EChanged;

            for ( TInt index = 0; index < iGlobalNotificationObservers.Count(); index++ )

                {

                iGlobalNotificationObservers[index]->HandleChange(

                    TEnumsPC::EContactListItem, eventtype );

                }

            break;

            }

        default:

            {

            break;

            }

        }

    if ( error )

        {

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

        }

    }

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

// CCAGlobalNotificationObserverPC::HandleSettingsChangeL

// @see MCASettingsObserver

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

void CCAGlobalNotificationObserverPC::HandleSettingsChangeL( TInt aChangedSettingEnum )

    {

    for ( TInt index = 0; index < iGlobalNotificationObservers.Count(); index++ )

        {

        TEnumsPC::TCASettingValues settings = ConvertToSettingsEnumsPC( aChangedSettingEnum );

        iGlobalNotificationObservers[index]->HandleSettingsChangeL( settings );

        }

    }

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

// CCAGlobalNotificationObserverPC::ConvertToSettingsEnumsPC

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

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

//

TEnumsPC::TCASettingValues CCAGlobalNotificationObserverPC::ConvertToSettingsEnumsPC(

    TInt aStatus )

    {

    MCASettings::TCASettingFlags engineFlags = ( MCASettings::TCASettingFlags )aStatus;

    TEnumsPC::TCASettingValues setValue = TEnumsPC::EUnknownValue;

    // Map status to setting item

    switch ( engineFlags )

        {

        case MCASettings::EDefaultScreenNameInUse :

            {

            setValue =  TEnumsPC::EDefaultScreenNameInUse;

            break;

            }

        case MCASettings::EAutomaticPresenceUpdate :

            {

            setValue =  TEnumsPC::EAutomaticPresenceUpdate;

            break;

            }

        case MCASettings::EShowOffline :

            {

            setValue =  TEnumsPC::EShowOffline;

            break;

            }

        case MCASettings::EShowTimeStamps :

            {

            setValue =  TEnumsPC::EShowTimeStamps;

            break;

            }

        default:

            {

            break;

            }

        }

    return setValue ;

    }

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

// CCAGlobalNotificationObserverPC::HandleInvitation()

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

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

//

void CCAGlobalNotificationObserverPC::HandleInvitationEventL(

    TInviteEventType aEvent, const MCAInvitation* aInvitation )

    {

    TEnumsPC::TInviteType inviteType = TEnumsPC::EInviteUnknown;

    switch ( aEvent )

        {

        case MCAInviteObserver::ENewInvite:

            {

            inviteType = TEnumsPC::ENewInvite;

            break;

            }

        case MCAInviteObserver::EInviteCancel: // Flowthrough

        case MCAInviteObserver::EInviteExpired:

            {

            inviteType = TEnumsPC::EInviteCancelOrExpired;

            break;

            }

        case MCAInviteObserver::EInviteRead:

            {

            inviteType = TEnumsPC::EInviteRead;

            break;

            }

        default:

            {

            inviteType = TEnumsPC::EInviteUnknown;

            break;

            }

        }

    for ( TInt index = 0; index < iGlobalNotificationObservers.Count(); index++ )

        {

        if ( aInvitation )

            {

            iGlobalNotificationObservers[index]->HandleInvitationEventL(

                inviteType,

                iContactInterface->Identification( aInvitation->UserID() ) ,

                aInvitation->Message() );

            }

        else

            {

            iGlobalNotificationObservers[index]->HandleInvitationEventL(

                inviteType,

                KNullDesC(), KNullDesC() );

            }

        }

    }

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

// CCAGlobalNotificationObserverPC::HandleInvitationResponse()

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

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

//

void CCAGlobalNotificationObserverPC::HandleInvitationResponse(

    TBool aAcceptance,

    const TDesC& aUserId,

    const TDesC& aGroupName,

    const TDesC& aResponse )

    {

    for ( TInt index = 0; index < iGlobalNotificationObservers.Count(); index++ )

        {

        iGlobalNotificationObservers[index]->HandleInvitationResponse( aAcceptance,

                                                                       aUserId,

                                                                       aGroupName,

                                                                       aResponse );

        }

    }

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

// CCAGlobalNotificationObserverPC::MCAGlobalNotificationObserverPCL()

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

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

//

void CCAGlobalNotificationObserverPC::AddGlobalObserverL(

    MCAUiGlobalNotificationObserverPC* aGlobalObserver )

    {

    ASSERT( aGlobalObserver );

    TInt status( iGlobalNotificationObservers.Append( aGlobalObserver ) );

    User::LeaveIfError( status );

    }

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

// CCAGlobalNotificationObserverPC::RemoveGlobalObserver()

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

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

//

void CCAGlobalNotificationObserverPC::RemoveGlobalObserver(

    MCAUiGlobalNotificationObserverPC* aGlobalObserver )

    {

    ASSERT( aGlobalObserver );

    const TInt status( iGlobalNotificationObservers.Find( aGlobalObserver ) );

    if ( status != KErrNotFound )

        {

        iGlobalNotificationObservers.Remove( status );

        iGlobalNotificationObservers.Compress();

        }

    }

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

// CCAGlobalNotificationObserverPC: HandleChatEvent

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

//

void CCAGlobalNotificationObserverPC::HandleChatEvent( TChatEventType aEvent,

                                                       MCAMessage* aMessage /*= NULL*/ )

    {

    TEnumsPC::TChatEventType aEventType = TEnumsPC::EEventNotSpecified;

    TEnumsPC::TMessagerType aMsgrType = TEnumsPC::EMessageOther;

    TEnumsPC::TMessageType aMsgType = TEnumsPC::EMessageInvalid;

    const TDesC& wvid( GetWvId( aMessage ) );

    const TDesC& msgText( aMessage ? aMessage->Text() : KNullDesC );

    const TPtrC& identification( aMessage ?

                                 iContactInterface->Identification( wvid ) : KNullDesC() );

    switch ( aEvent )

        {

        case EGroupListChanged:

            {

            aEventType = TEnumsPC::EGroupListChanged;

            break;

            }

        case EChatListChanged:

            {

            aEventType = TEnumsPC::EChatListChanged;

            break;

            }

        case ESendListChanged:

            {

            aEventType = TEnumsPC::ESendListChanged;

            break;

            }

        case EUnreadCountChanged:

            {

            aEventType = TEnumsPC::EUnreadCountChanged;

            break;

            }

        case EMemoryLow:

            {

            aEventType = TEnumsPC::EMemoryLow;

            break;

            }

        default:

            {

            break;

            }

        }

    if ( aMessage )

        {

        switch ( aMessage->MessagerType() )

            {

            case MCAMessage::EMessageSent:

                {

                aMsgrType = TEnumsPC::EMessageSent;

                break;

                }

            case MCAMessage::EMessageReceived:

                {

                aMsgrType = TEnumsPC::EMessageReceived;

                break;

                }

            default:

                {

                break;

                }

            }

        switch ( aMessage->MessageType() )

            {

            case MCAMessage::EMessagePTOP:

                {

                aMsgType = TEnumsPC::EMessagePTOP;

                break;

                }

            case MCAMessage::EMessageWhisper:

                {

                aMsgType = TEnumsPC::EMessageWhisper;

                break;

                }

            case MCAMessage::EMessageGroup:

                {

                aMsgType = TEnumsPC::EMessageGroup;

                break;

                }

            case MCAMessage::EMessageSystem:

                {

                aMsgType = TEnumsPC::EMessageSystem;

                break;

                }

            default:

                {

                break;

                }

            }

        }

    for ( TInt index = 0; index < iGlobalNotificationObservers.Count(); index++ )

        {

        iGlobalNotificationObservers[index]->HandleChatEvent(

            aEventType,

            wvid ,

            identification,

            msgText,

            aMsgrType,

            aMsgType );

        }

    }

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

// CCAAppUi::HandleMessageError

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

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

//

void CCAGlobalNotificationObserverPC::HandleMessageError( TInt aError, MCAMessage* aMessage )

    {

    for ( TInt index = 0; index < iGlobalNotificationObservers.Count(); index++ )

        {

        iGlobalNotificationObservers[index]->HandleMessageError(

            aError,

            aMessage->Text() );

        }

    }

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

// CCAGlobalNotificationObserverPC::GetWvId

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

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

//

const TDesC& CCAGlobalNotificationObserverPC::GetWvId( MCAMessage* aMessage )

    {

    if ( aMessage )

        {

        if ( aMessage->MessageType() == MCAMessage::EMessagePTOP )

            {

            return aMessage->Sender();

            }

        else

            {

            return aMessage->Target();