/*

* 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:  Implementation of EventNotifier class.

*

*/

#include "EventNotifier.h"

#include "EventBase.h"

#include <ControlObserver.h>

#include "tracemacros.h"

using namespace multimedia;

const TInt KInvalidIndex = -1;

///////////////////////////////////////////////////////////////////////////////

//                  CObserverManager

///////////////////////////////////////////////////////////////////////////////

CObserverManager::CObserverManager()

:iObserverCount(0),

iCurrentObserverIndex(KInvalidIndex)

    {

    // No impl

    }

CObserverManager::~CObserverManager()

    {

    iObserversList.Reset();

    iActiveList.Reset();

    iObserversList.Close();

    iActiveList.Close();

    }

CObserverManager* CObserverManager::NewL()

    {

    CObserverManager* self = new (ELeave)CObserverManager;

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

void CObserverManager::ConstructL()

    {

    }

// Adds observer to list

TInt CObserverManager::AddObserver( const MControlObserver& aObserver )

    {

    // Add to list if observer is not already added

    TInt status = iObserversList.Find(&aObserver);

    if ( status == KErrNotFound )

        {

        status = iObserversList.Append(&aObserver);

        status = iActiveList.Append(ETrue);

        // Update count

        iObserverCount++;

        }

    else

        {

        status = KErrAlreadyExists;

        }

    return status;

    }

// Marks observer as inactive in the list

TInt CObserverManager::RemoveObserver( const MControlObserver& aObserver )

    {

    TInt status = iObserversList.Find(&aObserver);

    // If found status has index to observer in the array

    // else it would contain KErrNotFound

    if ( status >= 0 )

        {

        // Mark the observer as inactive, but remove it later in Purge();

        iActiveList[status] = EFalse;

        // Update count

        iObserverCount--;

        status = KErrNone;

        }

    return status;

    }

// Moves the pointer to element before the first in list

void CObserverManager::Init()

    {

    iCurrentObserverIndex = KInvalidIndex;

    }

// Moves the pointer to next active observer. Client should

// call this after Init() to get to the first element.

TBool CObserverManager::Next()

    {

    TBool status(EFalse);

    // Starting from the next index count find an active observer

    TInt i(iCurrentObserverIndex+1);

    // Assume that we are not going to find one.

    iCurrentObserverIndex = KInvalidIndex;

    for (; i< iActiveList.Count(); i++)

        {

        if ( iActiveList[i] == TInt(ETrue) )

            { // We have found an active observer in the list

            iCurrentObserverIndex = i;

            status = ETrue;

            break;

            }

        }

    return status;

    }

// Returns a reference to current observer

void CObserverManager::Observer( MControlObserver*& aObserver )

    {

    if ( iCurrentObserverIndex == KInvalidIndex )

        {

        aObserver = NULL;

        }

    else

        {

        aObserver = iObserversList[iCurrentObserverIndex];

        }

    }

// Returns the count of active observers

TInt CObserverManager::Count()

    {

    return iObserverCount;

    }

// Purge inactive observers in the list

void CObserverManager::Purge()

    {

    TInt index(0);

    iObserverCount = 0; // Recalculate observer count

    while (index < iActiveList.Count())

        {

        if ( iActiveList[index] == TInt(EFalse) )

            {

            iObserversList.Remove(index);

            iActiveList.Remove(index);

            }

        else

            {

            iObserverCount++;

            index++;

            }

        }

    }

// Resets the list

void CObserverManager::Reset()

    {

    iCurrentObserverIndex = KInvalidIndex;

    iObserverCount = 0;

    iObserversList.Reset();

    iActiveList.Reset();

    }

///////////////////////////////////////////////////////////////////////////////

//                  CEventQueueItem

///////////////////////////////////////////////////////////////////////////////

CEventQueueItem::CEventQueueItem(MControl* aControl, TUint aEvent, CEventBase* aEventObject )

: iEvent( aEvent), iEventObject(aEventObject),iControl(aControl)

    {

    }

CEventQueueItem::~CEventQueueItem()

    {

    if ( iEventObject )

        {

        delete iEventObject;

        }

    }

CEventQueueItem* CEventQueueItem::NewL(MControl* aControl, TUint aEvent, CEventBase* aEventObject )

    {

    CEventQueueItem* self = new (ELeave)CEventQueueItem( aControl,aEvent, aEventObject );

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

void CEventQueueItem::ConstructL()

    {

    // No impl

    }

TUint CEventQueueItem::EventType()

    {

    return iEvent;

    }

MControl* CEventQueueItem::ControlObject()

    {

    return iControl;

    }

CEventBase* CEventQueueItem::EventObject()

    {

    return iEventObject;

    }

TAny* CEventQueueItem::GetInterface()

    {

    if ( iEventObject )

        return iEventObject->GetInterface();

    else

        return NULL;

    }

///////////////////////////////////////////////////////////////////////////////

//                  CObserverManager

///////////////////////////////////////////////////////////////////////////////

CEventNotifier::CEventNotifier()

: CActive( CActive::EPriorityStandard )

    {

    CActiveScheduler::Add(this);

    }

CEventNotifier::~CEventNotifier()

    {

    Cancel();

    delete iObserverManager;

    EmptyQueue();

    delete iEventQueue;

    }

CEventNotifier* CEventNotifier::NewL()

    {

    CEventNotifier* self = new (ELeave)CEventNotifier;

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

void CEventNotifier::ConstructL()

    {

    iObserverManager = CObserverManager::NewL();

    iEventQueue = new(ELeave) TSglQue<CEventQueueItem>(_FOFF(CEventQueueItem, iLink));

    }

// Adds observer

TInt CEventNotifier::AddObserver( const MControlObserver& aObserver )

    {

    return iObserverManager->AddObserver(aObserver);

    }

// Remove observer

TInt CEventNotifier::RemoveObserver( const MControlObserver& aObserver )

    {

    return iObserverManager->RemoveObserver(aObserver);

    }

// Send notification to observers. If another event is

// being processed, this will append event to queue and observers will

// be notified after current event is notified

TInt CEventNotifier::Event(MControl* aControl, TUint aEvent, CEventBase* aEventObject )

    {

    CEventQueueItem* item(NULL);

    TInt status(KErrNone);

    // If there are no observers in the list, just delete the event and return

    if ( iObserverManager->Count() == 0 )

        {

        EMC_TRACE2(_L("CEventNotifier::Event:No observers for this event[%d]"), aEvent);

        delete aEventObject;

        }

    else // Observer list is not empty, proceed notifying observers

        {

        TRAP( status, item = CEventQueueItem::NewL(aControl, aEvent, aEventObject ) );

        if ( status == KErrNone )

            {

            iEventQueue->AddLast(*item);

            KickSignal();

            }

        }

    return status;

    }

void CEventNotifier::KickSignal()

    {

    if (!IsActive())

        {

        TRequestStatus* s = &iStatus;

        SetActive();

        User::RequestComplete( s, KErrNone );

        }

    }

void CEventNotifier::EventNotified()

    {

    CEventQueueItem* eventItem = iEventQueue->First();

    iEventQueue->Remove(*eventItem);

    delete eventItem;

    iObserverManager->Init();

    }

void CEventNotifier::RunL()

    {

    if ( !iEventQueue-> IsEmpty() && (iStatus == KErrNone) )

        {

        // Get the current item from the observer list

        if ( iObserverManager->Next() )

            {

            MControlObserver* observer(NULL);

            iObserverManager->Observer(observer);

            if ( observer ) // Just to make sure. This should never happen

                {

                CEventQueueItem* eventItem = iEventQueue->First();

                observer->Event(eventItem->ControlObject(), eventItem->EventType(), eventItem->GetInterface() );

                }

#ifdef _DEBUG

            else

                {

                EMC_TRACE1(_L("CEventNotifier::RunL:ERROR[Observer reference is NULL]"));

                }

#endif // _DEBUG

            }

        else // if ( iObserverManager->Next() )

            { // There are no more observers in the list, all observers are

            // notified of this event.

            EventNotified();

            }

        KickSignal();

        }

    }

void CEventNotifier::DoCancel()

    {

    }

TInt CEventNotifier::RunError(TInt /*aError*/)

    {

    return KErrNone;

    }

void CEventNotifier::EmptyQueue()

    {

    CEventQueueItem* item;

    while ( !iEventQueue->IsEmpty() )

        {

        item = iEventQueue->First();

        iEventQueue->Remove(*item);

        delete item;

        }

    }

// End of file