/*
* 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();
}
}
return KNullDesC;
}
// -----------------------------------------------------------------------------
// CCAGlobalNotificationObserverPC::IsContactListsSyncDoneL()
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TBool CCAGlobalNotificationObserverPC::IsContactListsSyncDoneL()
{
MCAContactLists* contactLists =
CAPresenceManager::InstanceL()->ContactLists();
if ( !contactLists )
{
// not logged in yet, so sync state is ok
return ETrue;
}
return contactLists->IsSyncDone();
}
// -----------------------------------------------------------------------------
// CCAGlobalNotificationObserverPC::StoredContactsIsAllSynchronised
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TBool CCAGlobalNotificationObserverPC::StoredContactsIsAllSynchronised( TBool& aFailed )
{
return iContactInterface->IsAllSynchronised( aFailed );
}
// -----------------------------------------------------------------------------
// CCAGlobalNotificationObserverPC::IsValidListInterface
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TBool CCAGlobalNotificationObserverPC::IsValidStoredContactsInterface()
{
if ( iContactInterface )
{
return ETrue;
}
else
{
return EFalse;
}
}
// -----------------------------------------------------------------------------
// CCAGlobalNotificationObserverPC::IsValidListInterfaceL
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TBool CCAGlobalNotificationObserverPC::IsValidListInterfaceL()
{
MCAContactLists* contactLists =
CAPresenceManager::InstanceL()->ContactLists();
if ( contactLists )
{
return ETrue;
}
else
{
return EFalse;
}
}
//end of file