/*
* Copyright (c) 2004 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: Event notifier implementation base
*
*/
// INCLUDE FILES
#include <E32std.h>
#include <mimpsconnuipresenceeventobserverng.h>
#include <CPEngNWSessionSlotID2.h>
#include "CIMPSConnUiPresEventNotifierImpBase.h"
#include "CnUiEventMapper.h"
#include "CnUiPanics.h"
#include "IMPSCommonUiDebugPrint.h"
// ================= MEMBER FUNCTIONS =======================
// Destructor
CIMPSConnUiPresEventNotifierImpBase::~CIMPSConnUiPresEventNotifierImpBase()
{
iObserverArray.Close();
delete iSessionSlotID;
}
// C++ default constructor can NOT contain any code, that
// might leave.
//
CIMPSConnUiPresEventNotifierImpBase::CIMPSConnUiPresEventNotifierImpBase(
CIMPSConnUiPresEventNotifier& aInterface )
: iInterface( aInterface ),
iStarted( EFalse ),
iDying( EFalse )
{
}
// -----------------------------------------------------------------------------
// CIMPSConnUiPresEventNotifierImpBase::StartL()
// -----------------------------------------------------------------------------
//
void CIMPSConnUiPresEventNotifierImpBase::StartL()
{
//make here sanity checks to encapsulate
//real notifiers behaviour
if ( iDying )
{
//if dying, the notifier restart is silently ignored
//notifier is evidently going down anyway
return;
}
if ( iStarted )
{
User::Leave( KErrInUse );
}
if ( iObserverArray.Count() == 0 )
{
User::Leave( KErrNotReady );
}
RArray< TPEngNWSessionSlotEvent > pecEvents;
CleanupClosePushL( pecEvents );
CnUiEventMapper::AddAllKnownPecEventsL( pecEvents );
TRAPD( err, DoStartL( pecEvents.Array() ) );
if ( err != KErrNone )
{
DoStop();
User::Leave( err );
}
CleanupStack::PopAndDestroy(); //pecEvents
iStarted = ETrue;
}
// -----------------------------------------------------------------------------
// CIMPSConnUiPresEventNotifierImpBase::Stop()
// -----------------------------------------------------------------------------
//
void CIMPSConnUiPresEventNotifierImpBase::Stop()
{
StopAndNotifyObserversFromError( KErrCancel );
}
// -----------------------------------------------------------------------------
// CIMPSConnUiPresEventNotifierImpBase::Dying()
// -----------------------------------------------------------------------------
//
void CIMPSConnUiPresEventNotifierImpBase::Dying()
{
iDying = ETrue;
if ( iStarted )
{
iStarted = EFalse;
DoStop();
}
}
// -----------------------------------------------------------------------------
// CIMPSConnUiPresEventNotifierImpBase::AddObserverL()
// -----------------------------------------------------------------------------
//
void CIMPSConnUiPresEventNotifierImpBase::AddObserverL(
MIMPSConnUiPresenceEventObserver* aObserver )
{
__ASSERT_ALWAYS( aObserver,
CnUiPanicOrLeaveL( EIMPSConn_NULLPtr,
KErrArgument ) );
iObserverArray.AddObserverL( aObserver );
}
// -----------------------------------------------------------------------------
// CIMPSConnUiPresEventNotifierImpBase::RemoveObserver()
// -----------------------------------------------------------------------------
//
TInt CIMPSConnUiPresEventNotifierImpBase::RemoveObserver(
MIMPSConnUiPresenceEventObserver* aObserver )
{
return iObserverArray.RemoveObserver( aObserver );
}
// -----------------------------------------------------------------------------
// CIMPSConnUiPresEventNotifierImpBase::NotifyObserversFromEvent()
// -----------------------------------------------------------------------------
//
void CIMPSConnUiPresEventNotifierImpBase::NotifyObserversFromEvent(
const CPEngNWSessionSlotID2& aSessionSlotID,
TIMPSConnectionClient aClient,
TIMPSPresenceServiceEvent aEvent )
{
//if not running, don't notify the clients
if ( !iStarted )
{
return;
}
CPEngNWSessionSlotID2* tempSlot = NULL;
if ( &aSessionSlotID )
{
TRAPD( err, tempSlot = aSessionSlotID.CloneL() );
if ( err )
{
return;
}
delete iSessionSlotID;
iSessionSlotID = tempSlot;
iClient = aClient;
}
IMPSCUI_DP( D_IMPSCUI_LIT( "CIMPSConnUiPresEventNotifierImpBase::NotifyObserversFromEvent() [%d]" ), aEvent );
iObserverArray.NotifyObservers( *this, aEvent );
}
// -----------------------------------------------------------------------------
// CIMPSConnUiPresEventNotifierImpBase::StopAndNotifyObserversFromError()
// -----------------------------------------------------------------------------
//
void CIMPSConnUiPresEventNotifierImpBase::StopAndNotifyObserversFromError( TInt aError )
{
//if not running, don't notify the clients
if ( !iStarted )
{
return;
}
//Error propagating from the underlying implementation
//causes the notifier to stop. However, flag & actual
//stopping must be done before notifying the clients
//since some client may wan't to restart this notifier
//in the notification callback...
//Also the state must be set to "not started" before
//actual stopping since the stopping of some event
//sources cause further KErrCancel events
//(==>those will be filtered on !started check on above.)
iStarted = EFalse;
DoStop();
//do the notify
IMPSCUI_DP( D_IMPSCUI_LIT( "CIMPSConnUiPresEventNotifierImpBase::StopAndNotifyObserversFromError() [%d]" ), aError );
iObserverArray.NotifyObserversFromError( *this, aError );
}
// -----------------------------------------------------------------------------
// CIMPSConnUiPresEventNotifierImpBase::MediateNotifyL()
// From MGenObserverNotifyMediator
// -----------------------------------------------------------------------------
//
void CIMPSConnUiPresEventNotifierImpBase::MediateNotifyL(
MIMPSConnUiPresenceEventObserver& aObserverToNotify,
TIMPSPresenceServiceEvent& aNotifyData )
{
aObserverToNotify.HandlePresenceEventL( &iInterface, *iSessionSlotID, iClient, aNotifyData );
}
// -----------------------------------------------------------------------------
// CIMPSConnUiPresEventNotifierImpBase::MediateNotifyError()
// From MGenObserverNotifyMediator
// Forwards any error propagated from MediateNotifyL() to
// observer handle error.
// -----------------------------------------------------------------------------
//
void CIMPSConnUiPresEventNotifierImpBase::MediateNotifyError(
MIMPSConnUiPresenceEventObserver& aObserverToNotify,
TInt aLeaveError )
{
aObserverToNotify.HandlePresenceEventNotifyError( &iInterface, aLeaveError );
}
// -----------------------------------------------------------------------------
// CIMPSConnUiPresEventNotifierImpBase::MediateError()
// From MGenObserverNotifyMediator
// Forwards error to observer.
// -----------------------------------------------------------------------------
//
void CIMPSConnUiPresEventNotifierImpBase::MediateError(
MIMPSConnUiPresenceEventObserver& aObserverToNotify,
TInt aError )
{
aObserverToNotify.HandlePresenceEventNotifyError( &iInterface, aError );
}
// End of File