/*
* 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:  Event manager implementation.
*
*/



// INCLUDE FILES
#include    "CVtEngEventManager.h"
#include    "MVtEngEventObserver.h"
#include    "VtEngUtils.h"
#include    "VtEngEvents.h"
#include    "VtEngPanic.h"
#include    <cvtlogger.h>

// CONSTANTS
const TInt KMaxEventsInQueue = 8;

// max amount of simultanous event observers
const TInt KMaxVtEventObservers = 2;

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

// -----------------------------------------------------------------------------
// CVtEngEventManager::CVtEngEventManager
// C++ constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CVtEngEventManager::CVtEngEventManager() : CActive( CActive::EPriorityHigh ),
    iObservers( KMaxVtEventObservers ) 
    {
    CActiveScheduler::Add( this );
    }


// -----------------------------------------------------------------------------
// CVtEngEventManager::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CVtEngEventManager* CVtEngEventManager::NewL(
    MVtEngEventObserver& aEventObserver )
    {
    CVtEngEventManager* self = 
        new ( ELeave ) CVtEngEventManager();        
    CleanupStack::PushL( self );
    self->ConstructL( aEventObserver );
    CleanupStack::Pop(); // self 
    return self;
    }

// -----------------------------------------------------------------------------
// CVtEngEventManager::ConstructL
// 2nd phase constructor.
// -----------------------------------------------------------------------------
//
void CVtEngEventManager::ConstructL( MVtEngEventObserver& aEventObserver )
	{
	iEventQueue = new ( ELeave ) CArrayFixFlat< TInt >( KMaxEventsInQueue );
    iEventQueue->SetReserveL( KMaxEventsInQueue );
    User::LeaveIfError( iObservers.Append( &aEventObserver ) );
	}
	
// Destructor
CVtEngEventManager::~CVtEngEventManager()
    {
    Cancel();
    delete iEventQueue;
    iObservers.Close();
    }

// -----------------------------------------------------------------------------
// CVtEngEventManager::SessionStateChangedL
// Notifies session state change to UI.
// -----------------------------------------------------------------------------
//
void CVtEngEventManager::SessionStateChanged()
    {
    __VTPRINTENTER( "EventManager.SessionStateChanged" )
    NotifyEvent( KVtEngSessionStateChanged );
    __VTPRINTEXIT( "EventManager.SessionStateChanged" )
    }

// -----------------------------------------------------------------------------
// CVtEngEventManager::NotifyEvent
// -----------------------------------------------------------------------------
//
void CVtEngEventManager::NotifyEvent( const TInt aEvent )
    {
    __VTPRINTENTER( "EventManager.NotifyEvent" )
    __VTPRINT2( DEBUG_GEN, "EventManager.NotifyEvent event=%d", aEvent );
    CVtEngEventManager& eventManager = 
            CVtEngUtility::EventManager();
    if ( !eventManager.QueueAsyncEvent( aEvent ) )
        {        
        eventManager.DoNotifyEvent( aEvent );
        }
    __VTPRINTEXIT( "EventManager.NotifyEvent" )
    }

// -----------------------------------------------------------------------------
// CVtEngEventManager::AddObserverL
//
// -----------------------------------------------------------------------------
//
void CVtEngEventManager::AddObserverL( MVtEngEventObserver* aObserver )
    {
    TInt count( iObservers.Count() );
    TBool duplicate = EFalse;
    while ( count-- )
        {
        if ( aObserver == iObservers[ count ] )
            {
            count = 0; // break loop
            duplicate = ETrue;
            }
        }
    if ( !duplicate )
        {
        User::LeaveIfError( iObservers.Append( aObserver ) );
        }
    }

// -----------------------------------------------------------------------------
// CVtEngEventManager::RemoveObserver
//
// -----------------------------------------------------------------------------
//
void CVtEngEventManager::RemoveObserver( const MVtEngEventObserver* aObserver )
    {
    TInt count( iObservers.Count() );
    while ( count-- )
        {
        if ( aObserver == iObservers[ count ] )
            {
            iObservers.Remove( count );
            count = 0; // break loop
            }
        }
    }

// -----------------------------------------------------------------------------
// CVtEngEventManager::RunL
// Notify event
// -----------------------------------------------------------------------------
//
void CVtEngEventManager::RunL()
    {
    __VTPRINTENTER( "EventManager.RunL" )
    __VTPRINT2( DEBUG_GEN, "EventManager.RunL count=%d", iEventQueue->Count() );
    // get oldest event in queue (event at index 0)
    const TInt event = iEventQueue->At( 0 ) ;
    
    // delete event before calling DoNotifyEvent(), because DoNotifyEvent() may
    // hang if it causes ASynchronous call in handler
    iEventQueue->Delete( 0 );

    // if more events pending -> signal again
    if( iEventQueue->Count() > 0  )
        {
        Signal();    
        }

    // and finally notify event
    DoNotifyEvent( event );      
    __VTPRINTEXIT( "EventManager.RunL" )
    }

// -----------------------------------------------------------------------------
// CVtEngEventManager::DoCancel
// No op
// -----------------------------------------------------------------------------
//
void CVtEngEventManager::DoCancel()
    {
    }

// -----------------------------------------------------------------------------
// CVtEngEventManager::DoNotifyEvent
// -----------------------------------------------------------------------------
//
void CVtEngEventManager::DoNotifyEvent( const TInt aEvent )
    {
    __VTPRINTENTER( "EventManager.DoNotifyEvent" )
    __VTPRINT2( DEBUG_GEN, "EventManager.DoNotifyEvent event=%d", aEvent );
    TRAP_IGNORE( {
        TInt count( iObservers.Count() );
        while ( count-- )
            {
            iObservers[count]->HandleVtEventL( aEvent ) ;
            }
        } )
    __VTPRINTEXIT( "EventManager.DoNotifyEvent" )
    }

// -----------------------------------------------------------------------------
// CVtEngEventManager::QueueAsyncEvent
// -----------------------------------------------------------------------------
//
TBool CVtEngEventManager::QueueAsyncEvent( const TInt aEvent )
    {
    __VTPRINTENTER( "EventManager.QueueAsyncEvent" )
    __VTPRINT2( DEBUG_GEN, "EventManager.QueueAsyncEvent event=%d", aEvent );
    TBool async( EFalse );
    switch ( aEvent )
        {
        case KVtEngSessionStateChanged:
        case KVtEngNegotiationProblem:
        case KVtEngShareImageInitializeBegin:
        case KVtEngShareImageInitializeEnd:
            async = ETrue;
            QueueAndSignal( aEvent );
            break;
        default:
            break;
        }
    __VTPRINTEXIT( "EventManager.QueueAsyncEvent" )
    return async;
    }

// -----------------------------------------------------------------------------
// CVtEngEventManager::QueueAndSignal
// -----------------------------------------------------------------------------
//
void CVtEngEventManager::QueueAndSignal( const TInt aEvent )
    {
    __VTPRINTENTER( "EventManager.QueueAndSignal" )
    __VTPRINT2( DEBUG_GEN, "EventManager.QueueAndSignal event=%d", aEvent );
    if( iEventQueue->Count() < KMaxEventsInQueue )
        {
        TRAP_IGNORE( iEventQueue->AppendL( aEvent ) ); // can't leave
        Signal();
        }
    else
        {
        Panic( EVtEngPanicInvalidTooManyPendingEvents );        
        }
    __VTPRINTEXIT( "EventManager.QueueAndSignal" )
    }

// -----------------------------------------------------------------------------
// CVtEngEventManager::Signal
// -----------------------------------------------------------------------------
//
void CVtEngEventManager::Signal()
    {
    __VTPRINTENTER( "EventManager.Signal" )
    if( !IsActive() )
        {
        SetActive();
        TRequestStatus* status = &iStatus;
        User::RequestComplete( status, KErrNone );
        __VTPRINT2( DEBUG_GEN, "EventManager.QueueAndSignal count=%d", iEventQueue->Count() );
        }                
    __VTPRINTEXIT( "EventManager.Signal" )
    }

//  End of File