/*
* Copyright (c) 2002-2007 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:  Provides way to notify events and register observers
*                for events
*
*/



// INCLUDE FILES
#include    "TSatEventMediator.h"
#include    "TSatEventsObserver.h"
//lint -e766 Used inside TRAP macro, lint misfunction.
#include    "EnginePanic.h"
#include    "MSatEventObserver.h"
#include    "SatLog.h"

// FORWARD DECLARE
class MSatEventObserver;

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

// -----------------------------------------------------------------------------
// TSatEventMediator::TSatEventMediator
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
TSatEventMediator::TSatEventMediator() :
    iEventsObservers(),
    iIsNotifying( EFalse ),
    iDeletionsMarked( EFalse )
    {
    LOG( SIMPLE,
        "SATENGINE: TSatEventMediator::TSatEventMediator calling - exiting" )
    }

// -----------------------------------------------------------------------------
// TSatEventMediator::Reset
// Replaces destructor since T classes cannot have one
// -----------------------------------------------------------------------------
//
void TSatEventMediator::Reset()
    {
    LOG( SIMPLE, "SATENGINE: TSatEventMediator::Reset calling" )

    iEventsObservers.ResetAndDestroy();

    LOG( SIMPLE, "SATENGINE: TSatEventMediator::Reset exiting" )
    }

// -----------------------------------------------------------------------------
// TSatEventMediator::Notify
// All observers, who are registered to get the notification of aEvent, are
// notified
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void TSatEventMediator::Notify(
    TInt aEvent ) // Event
    {
    LOG( DETAILED, "SATENGINE: TSatEventMediator::Notify calling" )

    // Go through the list of observers and call notify for observers who are
    // observing aEvent.

    // Set the flag on. No one can remove observers when this flag is on
    iIsNotifying = ETrue;

    TInt count( iEventsObservers.Count() );
    LOG2( DETAILED, "SATENGINE: TSatEventMediator::Notify observers \
          count: %d", count )
    for ( TInt i = 0; i < count; i++ )
        {
        TSatEventsObserver* eventsObserver =
            iEventsObservers[i];
        __ASSERT_ALWAYS( eventsObserver,
            PanicSatEngine( ESatEngineNullPointer ) );

        if ( eventsObserver->ObservingEvent( aEvent ) )
            {
            MSatEventObserver* observer =
                eventsObserver->Observer();

            if ( observer )
                {
                LOG( DETAILED, "TSatEventMediator::Notify observer found" )
                // Observer found, notify it
                observer->Event( aEvent );

                // Check is iEventObservers list changed. Some observers might
                // remove themselves and notify a new event (new Notify loop)
                // and marked observers are deleted there. When it comes back 
                // here iEventsObserver has changed           
                if ( count > iEventsObservers.Count() )
                    {
                    LOG( DETAILED, "TSatEventMediator::Notify \
                    count > iEventsObservers.Count()" )
                    TInt newCount( iEventsObservers.Count() );
                    i = i - ( count - newCount );
                    count = newCount;
                    }
                }
            else
                {
                LOG( DETAILED, "TSatEventMediator::Notify observer not found" )
                // Found NULL observer -> Mark fo deleted. This is deleted after
                // this notification loop
                eventsObserver->RemoveEvent( aEvent );
                eventsObserver->MarkForDelete();
                }
            }
        }

    // Set the flag off. Now observers can be removed
    iIsNotifying = EFalse;

    // Check was there any deletions during notify loop
    if ( iDeletionsMarked )
        {
        LOG( DETAILED, "TSatEventMediator::Notify iDeletionsMarked true" )
        // Delete marked observers
        DeleteMarkedObservers();
        iDeletionsMarked = EFalse;
        }

    LOG( DETAILED, "SATENGINE: TSatEventMediator::Notify exiting" )
    }

// -----------------------------------------------------------------------------
// TSatEventMediator::RegisterL
// Registers observer for getting the event when event is notified using
// Notify( TInt aEvent ).
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void TSatEventMediator::RegisterL(
    MSatEventObserver* aObserver, // Observer of aEvent.
    TInt aEvent ) // Event, which will be trigger of notification.
    {
    LOG( SIMPLE, "SATENGINE: TSatEventMediator::RegisterL calling" )

    __ASSERT_ALWAYS( aObserver, PanicSatEngine( ESatEngineNullPointer ) );
    // Check if aObserver instance is already registered, so that we dont
    // create a new TSatEventsObserver entry in to the iEventsObserver list.
    TSatEventsObserver* eventsObserver = HasObserverInstance( aObserver );

    if ( NULL != eventsObserver )
        {
        LOG( SIMPLE, "SATENGINE: TSatEventMediator::RegisterL eventsObserver \
             not NULL" )
        // Add the event for the observer.
        eventsObserver->AddEventL( aEvent );
        }
    else
        {
        LOG( SIMPLE, "SATENGINE: TSatEventMediator::RegisterL eventsObserver \
             NULL" )
        // Observer is registering for the first time.
        eventsObserver = new( ELeave )TSatEventsObserver( aObserver );
        CleanupStack::PushL( eventsObserver );
        eventsObserver->AddEventL( aEvent );
        User::LeaveIfError( iEventsObservers.Append( eventsObserver ) );
        CleanupStack::Pop( eventsObserver );
        }

    LOG( SIMPLE, "SATENGINE: TSatEventMediator::RegisterL exiting" )
    }

// -----------------------------------------------------------------------------
// TSatEventMediator::Unregister
// Removes aEvent from aObservers observable events.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void TSatEventMediator::Unregister(
    const MSatEventObserver* aObserver, // Observer of aEvent.
    TInt aEvent ) // Event, which the observer is observing.
    {
    LOG( SIMPLE, "SATENGINE: TSatEventMediator::Unregister calling" )

    // Check if observer is registered.
    TSatEventsObserver* eventsObserver = HasObserverInstance( aObserver );
    if ( NULL != eventsObserver )
        {
        LOG( SIMPLE, "SATENGINE: TSatEventMediator::RegisterL eventsObserver \
             not NULL" )
        eventsObserver->RemoveEvent( aEvent );

        // Remove the eventsObserver from the list if the observer has
        // no longer any events to observe.
        if ( 0 == eventsObserver->EventCount() )
            {
            // Prevent delete if we are notifying observers
            if ( !iIsNotifying )
                {
                LOG( SIMPLE, "SATENGINE: TSatEventMediator::Unregister \
                     iIsNotifying false" )
                const TInt index = iEventsObservers.Find( eventsObserver );
                // Does not destroy the object.
                iEventsObservers.Remove( index ); 
                iEventsObservers.GranularCompress();
                delete eventsObserver;
                }
            else
                {
                LOG( SIMPLE, "SATENGINE: TSatEventMediator::Unregister \
                     iIsNotifying true" )
                // If we are notifying, mark this observer as deleted
                eventsObserver->MarkForDelete();
                iDeletionsMarked = ETrue;
                }
            }
        }

    LOG( SIMPLE, "SATENGINE: TSatEventMediator::Unregister exiting" )
    }

// -----------------------------------------------------------------------------
// TSatEventMediator::Unregister
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void TSatEventMediator::Unregister(
    const MSatEventObserver* aObserver ) // Observer of aEvent.
    {
    LOG( SIMPLE, "SATENGINE: TSatEventMediator::Unregister calling" )

    // Check if observer is registered.
    TSatEventsObserver* eventsObserver = HasObserverInstance( aObserver );
    if ( NULL != eventsObserver )
        {
        // Prevent delete if we are notifying observers
        if ( !iIsNotifying )
            {
            LOG( SIMPLE, "SATENGINE: TSatEventMediator::Unregister \
                 iIsNotifying false" )
            const TInt index = iEventsObservers.Find( eventsObserver );
            iEventsObservers.Remove( index ); // Does not destroy the object.
            iEventsObservers.GranularCompress();
            delete eventsObserver;
            }
        else
            {
            LOG( SIMPLE, "SATENGINE: TSatEventMediator::Unregister \
                 iIsNotifying true" )
            // If we are notifying, mark this observer as deleted
            eventsObserver->MarkForDelete();
            iDeletionsMarked = ETrue;
            }
        }

    LOG( SIMPLE, "SATENGINE: TSatEventMediator::Unregister exiting" )
    }

// -----------------------------------------------------------------------------
// TSatEventMediator::HasObserverInstance
// Checks if aObserver is already registered to this mediator and returns the
// result.
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TSatEventsObserver* TSatEventMediator::HasObserverInstance(
    const MSatEventObserver* aObserver ) const // Observer looked from the list.
    {
    LOG( SIMPLE, "SATENGINE: TSatEventMediator::HasObserverInstance calling" )

    // Go through the list until same observer instance is found or
    // all entries have been checked.
    TSatEventsObserver* foundEventsObserver = NULL;
    const TInt count( iEventsObservers.Count() );
    LOG2( NORMAL, "SATENGINE: TSatEventMediator::HasObserverInstance \
          observer count: %d", count )
    for ( TInt i = 0; ( i < count ) && ( !foundEventsObserver ); i++ )
        {
        TSatEventsObserver* eventsObserver = iEventsObservers[i];
        __ASSERT_ALWAYS( eventsObserver,
            PanicSatEngine( ESatEngineNullPointer ) );

        if ( aObserver == eventsObserver->Observer() )
            {
            LOG( SIMPLE, "SATENGINE: TSatEventMediator::HasObserverInstance \
            aObserver == eventsObserver->Observer()" )
            foundEventsObserver = eventsObserver;
            }
        }

    LOG( SIMPLE, "SATENGINE: TSatEventMediator::HasObserverInstance exiting" )
    return foundEventsObserver;
    }

// -----------------------------------------------------------------------------
// TSatEventMediator::DeleteMarkedObservers
// Deletes all observers marked as deleted during Notify loop
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void TSatEventMediator::DeleteMarkedObservers()
    {
    LOG( SIMPLE, "SATENGINE: TSatEventMediator::DeleteMarkedObservers calling" )

    // Go through the list and delete all observers wich are
    // marked as deleted
    TInt count( iEventsObservers.Count() );
    LOG2( NORMAL, "SATENGINE: TSatEventMediator::DeleteMarkedObservers \
          observer count: %d", count )
    for ( TInt i = 0; i < count; i++ )
        {
        TSatEventsObserver* eventsObserver =
            iEventsObservers[i];
        if ( eventsObserver )
            {
            LOG( SIMPLE, "SATENGINE: TSatEventMediator::DeleteMarkedObservers\
            eventsObserver true" )
            // Check is obserer marked and it has no events
            if ( eventsObserver->IsMarkedForDelete() &&
                 ( 0 == eventsObserver->EventCount() ) )
                {
                LOG( SIMPLE, "SATENGINE: TSatEventMediator::\
                DeleteMarkedObservers delete Observer" )
                iEventsObservers.Remove( i ); // Does not destroy the object.
                iEventsObservers.GranularCompress();
                delete eventsObserver;

                // Update count value. We just removed an object from list
                count = iEventsObservers.Count();
                i--;
                }
            }
        }

    LOG( SIMPLE, "SATENGINE: TSatEventMediator::DeleteMarkedObservers exiting" )
    }

//  End of File