/*
* Copyright (c) 2008 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:  Engine class for Events Management UI.
*
*/

#include <lbt.h> 

#include "evtevent.h"
#include "evtmgmtuilbtadapter.h"
#include "evteventmanager.h"
#include "evtmgmtuiengine.h"
#include "evtdebug.h"
#include "evttoneaction.h"

// Constants
static const TInt KHighAccValue = 500;
static const TInt KMidAccValue = 1500;

// ---------------------------------------------------------------------------
// CEvtMgmtUiModel::ConstructL()
// ---------------------------------------------------------------------------
//
void CEvtMgmtUiEngine::ConstructL()
    {
    EVTUIDEBUG("+ CEvtMgmtUiEngine::ConstructL()" );
    
    iEventManager = CEvtEventManager::NewL();
    iEventManager->SetObserver(this);
           
    EVTUIDEBUG("Create lbtadapter object" );      
    iLbtAdapter = CEvtMgmtUiLbtAdapter::NewL(*this);
    
    EVTUIDEBUG("- CEvtMgmtUiEngine::ConstructL()" );
    }

// ---------------------------------------------------------------------------
// CEvtMgmtUiEngine::NewL()
// ---------------------------------------------------------------------------
//
EXPORT_C CEvtMgmtUiEngine* CEvtMgmtUiEngine::NewL()
    {
    CEvtMgmtUiEngine* self = CEvtMgmtUiEngine::NewLC();
    CleanupStack::Pop( self );
    return self;
    }


// ---------------------------------------------------------------------------
// CEvtMgmtUiEngine::NewLC()
// ---------------------------------------------------------------------------
//
EXPORT_C CEvtMgmtUiEngine* CEvtMgmtUiEngine::NewLC()
    {
    CEvtMgmtUiEngine* self = new( ELeave ) CEvtMgmtUiEngine();
    CleanupStack::PushL( self );
    self->ConstructL();
    return self;
    }

// ---------------------------------------------------------------------------
// CEvtMgmtUiEngine::CEvtMgmtUiEngine()
// ---------------------------------------------------------------------------
//
CEvtMgmtUiEngine::CEvtMgmtUiEngine()
    {       
    }

// ---------------------------------------------------------------------------
// CEvtMgmtUiEngine::~CEvtMgmtUiEngine()
// ---------------------------------------------------------------------------
//
CEvtMgmtUiEngine::~CEvtMgmtUiEngine()
    {        
    // Reseting the Observer array
    iObserverArray.Reset();
    iObserverArray.Close();
    
    delete iEventManager;   
    iEventManager = NULL;
    
    delete iLbtAdapter;
    iLbtAdapter = NULL;
    }

// ---------------------------------------------------------------------------
// CEvtMgmtUiEngine::SetObserver()
// ---------------------------------------------------------------------------
//
EXPORT_C void CEvtMgmtUiEngine::SetObserver(MEvtMgmtUiEngineObserver* aObserver)
    {
    // Append the observer to the observer array waiting for notifications
    iObserverArray.Append( aObserver );
    }

// ---------------------------------------------------------------------------
// CEvtMgmtUiEngine::RemoveObserver()
// ---------------------------------------------------------------------------
//
EXPORT_C void CEvtMgmtUiEngine::RemoveObserver(MEvtMgmtUiEngineObserver* aObserver)
    {
    // Remove the observer from receiving notifications
    for( TInt i = 0; i < iObserverArray.Count(); i++ )
        {
        if ( iObserverArray[i] == aObserver )
            {
            iObserverArray.Remove( i );
            break;   
            }
        }
    }

// ---------------------------------------------------------------------------
// CEvtMgmtUiEngine::EventL()
// ---------------------------------------------------------------------------
//
EXPORT_C CEvtEvent* CEvtMgmtUiEngine::EventL( TEvtEventId aId )
    {        
    EVTUIDEBUG1("+ CEvtMgmtUiEngine::EventL() event id = %d", aId);
    
    CEvtEvent* evt = NULL;
    if( aId!= 0 )
	    {
	    evt = iEventManager->GetEventL( aId ); 
	    CleanupStack::PushL( evt );
	    RetrieveLocationL( aId, evt->Location() );
	    CleanupStack::Pop();
	    }
    else
	    {
	    evt = CEvtEvent::NewL();	
	    }
    
    EVTUIDEBUG("- CEvtMgmtUiEngine::EventL()" );
    return evt;
    }

// ---------------------------------------------------------------------------
// CEvtMgmtUiEngine::AddEventL()
// ---------------------------------------------------------------------------
//
EXPORT_C void CEvtMgmtUiEngine::AddEventL( CEvtEvent& aEvtEvent )
    {  
    EVTUIDEBUG("+ CEvtMgmtUiEngine::AddEventL()" );
   
    CLbtTriggerEntry::TLbtTriggerState state;
    if(aEvtEvent.EventStatus()==EActive)
        {
        state = CLbtTriggerEntry::EStateEnabled;
        }
    else
        {
        state = CLbtTriggerEntry::EStateDisabled;
        }
        
    iEvent = &aEvtEvent;
     
    //create trigger
    if(iEvent->Subject().Compare(KNullDesC) == 0)
       iLbtAdapter->CreateTrigger(iEvent->Location(),TReal(iEvent->Radius()),_L("Un Named Location Event"), state );
    else
       iLbtAdapter->CreateTrigger(iEvent->Location(),TReal(iEvent->Radius()),iEvent->Subject(), state );

    EVTUIDEBUG("- CEvtMgmtUiEngine::AddEventL()" );  
    }

// ---------------------------------------------------------------------------
// CEvtMgmtUiEngine::ModifyEventL()
// ---------------------------------------------------------------------------
//
EXPORT_C void CEvtMgmtUiEngine::ModifyEventL( CEvtEvent& aEvtEvent, TEvtEventAttributeMask aEventAttributeMask )
    {  
    EVTUIDEBUG("+ CEvtMgmtUiEngine::ModifyEventL()" );
  
    //if loc and/or state information are changed
    if( (aEventAttributeMask & EEvtEventAttributeStatus) == EEvtEventAttributeStatus ||
       (aEventAttributeMask & EEvtEventAttributePlace) == EEvtEventAttributePlace ||
       (aEventAttributeMask & EEvtEventAttributeRadius) == EEvtEventAttributeRadius )
        {
        CLbtTriggerEntry::TLbtTriggerState state;
        if( aEvtEvent.EventStatus() == EActive )
          {
          state = CLbtTriggerEntry::EStateEnabled;
          }
        else
          {
          state = CLbtTriggerEntry::EStateDisabled;
          }
        
        iEvent = &aEvtEvent;
        
        iLbtAdapter->UpdateTriggerL(aEvtEvent.EventId(), aEvtEvent.Location(), 
                                aEvtEvent.Radius(), state );
        } 
    else
        {
        iEventManager->UpdateEventL(aEvtEvent);
        
        if ( iObserverArray.Count())
            {
            for( TInt i = 0; i < iObserverArray.Count(); i++ )
                {
                iObserverArray[i]->NotifyEventChangeL( KErrNone,CEvtMgmtUiLbtAdapter::ELbtAdapterUpdate );
                }
            }
        }

    EVTUIDEBUG("- CEvtMgmtUiEngine::ModifyEventL()" );  
    }

// ---------------------------------------------------------------------------
// CEvtMgmtUiEngine::DeleteEventL()
// ---------------------------------------------------------------------------
//
EXPORT_C void CEvtMgmtUiEngine::DeleteEventL( TEvtEventId aEventId )
    {   
    EVTUIDEBUG1("+ CEvtMgmtUiEngine::DeleteEventL() event id =%d", aEventId );   
    TInt err = KErrNone;
    if( aEventId!=0 ) //if it is present in lbt database        
        {      
        iLbtAdapter->DeleteTriggerL( aEventId );
        iEventManager->RemoveEventL( aEventId );
        }
        
    if ( iObserverArray.Count())
        {
        for( TInt i = 0; i < iObserverArray.Count(); i++ )
            {
            iObserverArray[i]->NotifyEventChangeL( err,CEvtMgmtUiLbtAdapter::ELbtAdapterDelete );
            }
        }
    EVTUIDEBUG("- CEvtMgmtUiEngine::DeleteEventL()" );  
    }

// ---------------------------------------------------------------------------
// CEvtMgmtUiEngine::DeleteEventsL()
// ---------------------------------------------------------------------------
//
EXPORT_C void CEvtMgmtUiEngine::DeleteEventsL( const RArray<TEvtEventId>* aEvtIdArray )
    {    
    iEvtIdArray = aEvtIdArray;
    iLbtAdapter->DeleteTriggersL( *aEvtIdArray );  
    }

// ---------------------------------------------------------------------------
// CEvtMgmtUiEngine::SetEventStateL()
// ---------------------------------------------------------------------------
//
EXPORT_C void CEvtMgmtUiEngine::SetEventStateL( TEvtEventStatus aEvtStatus, TEvtEventId aEventId)
    {
    EVTUIDEBUG("+ CEvtMgmtUiEngine::SetEventStateL()" );  
    TInt err = KErrNone;
    if( aEventId != 0 )
    	{ 
	    switch(aEvtStatus)
	        {
	        case EActive:
	            {            
	            iLbtAdapter->SetTriggerStateL( aEventId, CLbtTriggerEntry::EStateEnabled);
                iEventManager->UpdateEventStatusL( aEventId, aEvtStatus );
	            break;
	            }
	        case EDraft:
	            { 
	            iLbtAdapter->SetTriggerStateL( aEventId, CLbtTriggerEntry::EStateDisabled );
                iEventManager->UpdateEventStatusL( aEventId, aEvtStatus ); 
	            break;
	            }  
	        case ECompleted:
	            { 
                iEventManager->UpdateEventStatusL( aEventId, aEvtStatus ); 
	            iLbtAdapter->SetTriggerStateL( aEventId, CLbtTriggerEntry::EStateDisabled );
	            break;
	            }  
	        default:
	        	break;                  
	        } 
        }   
        
    if ( iObserverArray.Count())
        {
        for( TInt i = 0; i < iObserverArray.Count(); i++ )
            {
            iObserverArray[i]->NotifyEventChangeL( err,CEvtMgmtUiLbtAdapter::ELbtAdapterSetTriggerState );
            }
        }
	EVTUIDEBUG("- CEvtMgmtUiEngine::SetEventStateL()" ); 
    }

// ---------------------------------------------------------------------------
// CEvtMgmtUiEngine::SetEventsStateL()
// ---------------------------------------------------------------------------
//
EXPORT_C void CEvtMgmtUiEngine::SetEventsStateL( TEvtEventStatus aEvtStatus, const RArray<TEvtEventId>* aEvtIdArray )
    {
    EVTUIDEBUG("+ CEvtMgmtUiEngine::SetEventsStateL()" );
    iEvtIdArray = aEvtIdArray;
    iEvtStatus = aEvtStatus;
    switch(aEvtStatus)
        {
        case EActive:
            {            
            iLbtAdapter->SetTriggersStateL( *aEvtIdArray, CLbtTriggerEntry::EStateEnabled);
            break;
            }
        case EDraft:
        case ECompleted:
            {  
            iLbtAdapter->SetTriggersStateL( *aEvtIdArray, CLbtTriggerEntry::EStateDisabled);
            break;
            }  
        default:
            break;                  
        }                
    EVTUIDEBUG("- CEvtMgmtUiEngine::SetEventsStateL()" );
    }

// ---------------------------------------------------------------------------
// CEvtMgmtUiEngine::UpdateModelL()
// ---------------------------------------------------------------------------
//
EXPORT_C void CEvtMgmtUiEngine::UpdateModelL( RPointerArray<CEvtBasicEventInfo>& aEventsArray,
												TEvtEventStatusFilter  aEventStatusFilter )
    {
    EVTUIDEBUG("+ CEvtMgmtUiEngine::UpdateModelL()" );
  
    if( aEventsArray.Count() )
         {
         aEventsArray.ResetAndDestroy();         
         } 
         
    if( aEventStatusFilter == EEvtFilterAll )
        iEventManager->GetEventsL( aEventsArray );
    else
        iEventManager->GetEventsL( static_cast<TEvtEventStatus>(aEventStatusFilter), aEventsArray );
    
    EVTUIDEBUG("- CEvtMgmtUiEngine::UpdateModelL()" );  
    }

// ---------------------------------------------------------------------------
// CEvtMgmtUiEngine::SyncDbsL()
// ---------------------------------------------------------------------------
//
EXPORT_C void CEvtMgmtUiEngine::SyncDbsL()
    {
    EVTUIDEBUG("+ CEvtMgmtUiEngine::SyncDbsL()" );
	TInt err;
    
    // Handle the Enabled and Disabled Trigger list from LBT 
    RArray<TLbtTriggerId> enabledtriggerList;
    RArray<TLbtTriggerId> disabledtriggerList;
    
	TRAP(err, iLbtAdapter->GetTriggerListL(disabledtriggerList, CLbtTriggerEntry::EStateDisabled ) );
	if(err != KErrNone)
		{
		EVTUIDEBUG1("CEvtMgmtUiEngine::SyncDbsL:Error while retrieving trigger ids = %d", err);
		disabledtriggerList.Close();
		enabledtriggerList.Close();
		User::Leave( err );
		}
		
	TRAP(err, iLbtAdapter->GetTriggerListL(enabledtriggerList, CLbtTriggerEntry::EStateEnabled ) );
	if(err != KErrNone)
		{
		EVTUIDEBUG1("CEvtMgmtUiEngine::SyncDbsL:Error while retrieving trigger ids = %d", err);
		disabledtriggerList.Close();
		enabledtriggerList.Close();
		User::Leave( err );
		}
				
	// Get Events list from EvtStorage
	RPointerArray<CEvtBasicEventInfo> eventsArray;
	RArray<TEvtEventId> removeArray;
	iEventManager->GetEventsL( eventsArray );
	
	// Compute
	TInt count = eventsArray.Count();
	TInt index=KErrNotFound;
	for(TInt i=0; i<count; i++)
	{
    if( eventsArray[i]->EventStatus() == EActive )
		{
        if( KErrNotFound != (index = disabledtriggerList.Find(eventsArray[i]->EventId())) )
            {
			iEventManager->UpdateEventStatusL( eventsArray[i]->EventId(), EDraft );
			disabledtriggerList.Remove(index);
            }
		else if( KErrNotFound == (index = enabledtriggerList.Find(eventsArray[i]->EventId())) )
		    {
			removeArray.Append(eventsArray[i]->EventId());
		    }
		else
		    {
		    enabledtriggerList.Remove(index);
		    }
		}
	else
		{
        if( KErrNotFound != (index = enabledtriggerList.Find(eventsArray[i]->EventId())) )
            {
			iEventManager->UpdateEventStatusL( eventsArray[i]->EventId(), EActive );
			enabledtriggerList.Remove(index);
            }
		else if( KErrNotFound == (index = disabledtriggerList.Find(eventsArray[i]->EventId())) )
		    {
			removeArray.Append(eventsArray[i]->EventId());
		    }
        else
            {
            disabledtriggerList.Remove(index);
            }
		}
	}

	// Update the Storage Db for removed triggers.
	if( removeArray.Count() != 0 )
		iEventManager->RemoveEventsL( removeArray );
	
	// Update the LBT Db for non existant triggers.
	count = enabledtriggerList.Count();
	for(TInt i=0; i<count; i++)
	    disabledtriggerList.Append(enabledtriggerList[i]);
	
	// We Nullify iEvtIdArray to ensure that observers are not notified of this delete triggers
	iEvtIdArray = NULL;
	if( disabledtriggerList.Count() != 0 )
    	iLbtAdapter->DeleteTriggersL( disabledtriggerList );  

	removeArray.Close();
	disabledtriggerList.Close();
	enabledtriggerList.Close();
	eventsArray.ResetAndDestroy();
	eventsArray.Close();
	EVTUIDEBUG("- CEvtMgmtUiEngine::SyncDbsL()" );
    }

// ---------------------------------------------------------------------------
// CEvtMgmtUiEngine::CalculateFiredAccuracyL()
// ---------------------------------------------------------------------------
//
EXPORT_C TEvtFireAccuracy CEvtMgmtUiEngine::CalculateFiredAccuracyL( 
											const TEvtEventId aEventId )
	{
	EVTUIDEBUG1("+ CEvtMgmtUiEngine::CalculateFiredAccuracyL() - %d", aEventId );
	TEvtFireAccuracy accuracy = ELowAccuracy;
	TReal32 distance(KMidAccValue+1);
	iLbtAdapter->GetFiredTriggerAccuracyL(aEventId, distance);
	
	EVTUIDEBUG1("= CalculateFiredAccuracyL() distance = %d", distance );
	
	if( distance <= KHighAccValue )
		accuracy = EHighAccuracy;
	else if( distance <= KMidAccValue )
		accuracy = EMidAccuracy;
	else
		accuracy = ELowAccuracy;
	
	EVTUIDEBUG("- CEvtMgmtUiEngine::CalculateFiredAccuracyL()" );
	return accuracy;
	}

// ---------------------------------------------------------------------------
// CEvtMgmtUiEngine::HandleFiredTriggerStateL()
// ---------------------------------------------------------------------------
//
EXPORT_C void CEvtMgmtUiEngine::HandleFiredTriggerStateL( 
											const TEvtEventId aEventId )
	{	
	EVTUIDEBUG1("+ CEvtMgmtUiEngine::HandleFiredTriggerStateL() - %d", aEventId );    
    CEvtEvent* evt = NULL;
    if( aEventId!= 0 )
	    {
	    evt = iEventManager->GetEventL( aEventId ); 
	    if( evt )
		    {
		    CleanupStack::PushL( evt );	
			if( !evt->Repeat() )
				{
				SetEventStateL( ECompleted, aEventId );
				}
		    CleanupStack::PopAndDestroy( evt );
		    }	
	    }
	EVTUIDEBUG("- CEvtMgmtUiEngine::HandleFiredTriggerStateL()" );
	}

// ---------------------------------------------------------------------------
// CEvtMgmtUiEngine::CancelRequest()
// ---------------------------------------------------------------------------
//
EXPORT_C void CEvtMgmtUiEngine::CancelRequest()
    {     
    EVTUIDEBUG("+ CEvtMgmtUiEngine::CancelRequest()" );
	if( iLbtAdapter->IsActive() )
    	iLbtAdapter->CancelRequest();
    EVTUIDEBUG("- CEvtMgmtUiEngine::CancelRequest()" );
    }

// ---------------------------------------------------------------------------
// CEvtMgmtUiEngine::HandleStorageDbChangedL()
// ---------------------------------------------------------------------------
//
void CEvtMgmtUiEngine::HandleStorageDbChangedL()
    {     
    // Notify all observers
    if ( iObserverArray.Count())
        {
        for( TInt i = 0; i < iObserverArray.Count(); i++ )
            {
            iObserverArray[i]->NotifyModelChangeL();
            }
        }
    }

// ---------------------------------------------------------------------------
// CEvtMgmtUiEngine::RetrieveLocationL()
// ---------------------------------------------------------------------------
//
EXPORT_C void CEvtMgmtUiEngine::RetrieveLocationL( TEvtEventId aEventId, TCoordinate& aCoordinate )
    {
    EVTUIDEBUG("+ CEvtMgmtUiEngine::RetrieveLocationL()" );
    iLbtAdapter->RetrieveLocationL( aEventId, aCoordinate);
    EVTUIDEBUG("- CEvtMgmtUiEngine::RetrieveLocationL()" );
    }

// ---------------------------------------------------------------------------
// CEvtMgmtUiEngine::NotifyLbtChangeL()
// ---------------------------------------------------------------------------
//
void CEvtMgmtUiEngine::NotifyLbtChangeL(TLbtTriggerId &  aTriggerId, TInt aState )
    {   
    EVTUIDEBUG("+ CEvtMgmtUiEngine::NotifyLbtChangeL()" );
    
    // Notify all observers
    if ( iObserverArray.Count() )
        {
        for( TInt i = 0; i < iObserverArray.Count(); i++ )
            {
            iObserverArray[i]->NotifyEventChangeL( KErrNone,aState );
            }
        }
    
    //iState = aState;
    switch(aState)
        {
        case CEvtMgmtUiLbtAdapter::ELbtAdapterCreate:       
            {
            EVTUIDEBUG1("Trigger is created TriggerId=%d", aTriggerId );
            
            // Update the the command Line argument (Temporarily commented)
            iLbtAdapter->UpdateCmdLineArgL( aTriggerId, aTriggerId );
            
			// Add the new Event to the Local Db.
			if( iEvent->EventId() == 0 )
			   {
			   iEvent->SetEventId( aTriggerId );
			   
			   EVTUIDEBUG("========== Event Details ============================" );
			   TBuf<256>debug;
			   debug.Copy( iEvent->Subject() );
			   EVTUIDEBUG1("Subject: %S", &debug);
			   debug.Copy( iEvent->Place() );
			   EVTUIDEBUG1("Place: %S", &debug);
			   EVTUIDEBUG1("Radius: %f", iEvent->Radius());
			   EVTUIDEBUG1("Repeat: %d", iEvent->Repeat());
			   
			   CEvtToneAction* tone = CEvtToneAction::NewLC();
				if( iEvent->HasAction() )
					{              
					tone->InternalizeL( iEvent->Action() );
					debug.Copy( tone->FileName() );
					EVTUIDEBUG1("Ringtone: %S", &debug);
					EVTUIDEBUG1("Audio Loop: %d", tone->ToneLoop());    
					}
			    CleanupStack::PopAndDestroy(tone);
			    
			   EVTUIDEBUG("==========End Event Details ============================" );    
			   iEventManager->AddEventL( *iEvent );       
			   
			   EVTUIDEBUG1( "Event is added to local database eventid = %d" , iEvent->EventId() );
			   }
            break;
            }
        case CEvtMgmtUiLbtAdapter::ELbtAdapterUpdate:       
            {         
            iEventManager->UpdateEventL(*iEvent);
            break;
            }    
        case CEvtMgmtUiLbtAdapter::ELbtAdapterDeleteTriggers:
            {           
            if(iEvtIdArray && iEvtIdArray->Count())
                {
                iEventManager->RemoveEventsL( *iEvtIdArray );
                iEvtIdArray = NULL;
                }
            else
                {
                return; // This condition is satisfied by DeleteTriggers in SyncDbL
                }
            break;
            }
        case CEvtMgmtUiLbtAdapter::ELbtAdapterSetTriggersState:
            {
            if(iEvtIdArray && iEvtIdArray->Count())
                {
                iEventManager->UpdateEventsStatusL( *iEvtIdArray, iEvtStatus );
                iEvtIdArray = NULL;
                }
            }
            break;
        default:
            {
            //error
            break;
            }
        }
		
    EVTUIDEBUG("- CEvtMgmtUiEngine::NotifyLbtChangeL()" );
    }

// ---------------------------------------------------------------------------
// CEvtMgmtUiEngine::NotifyLbtError()
// ---------------------------------------------------------------------------
//
void CEvtMgmtUiEngine::NotifyLbtError(TInt aErrorCode, TInt aState )
    {   
    EVTUIDEBUG1("+ CEvtMgmtUiEngine::NotifyLbtErrorL() error =%d", aErrorCode);
    // Notify all observers
    if ( iObserverArray.Count())
        {
        for( TInt i = 0; i < iObserverArray.Count(); i++ )
            {
            TRAP_IGNORE( iObserverArray[i]->NotifyEventChangeL( aErrorCode, aState ));
            }
        }
    
    EVTUIDEBUG("- CEvtMgmtUiEngine::NotifyLbtErrorL()" );
    }

// ---------------------------------------------------------------------------
// CEvtMgmtUiEngine::NotifyTriggerChangeL()
// ---------------------------------------------------------------------------
//
void CEvtMgmtUiEngine::NotifyTriggerChangeL( const TLbtTriggerId &  aTriggerId,
    								TLbtTriggerChangeType aType )
	{
	EVTUIDEBUG("+ CEvtMgmtUiEngine::NotifyTriggerChangeL()" );
	CLbtTriggerEntry::TLbtTriggerState state = CLbtTriggerEntry::EStateDisabled;
	CEvtEvent* evt = NULL;
	switch( aType )
		{
		case ETriggerMultipleModified:
			SyncDbsL();
			break;
		case ETriggerModified:
			state = iLbtAdapter->GetTriggerStateL( aTriggerId );
			
			evt = iEventManager->GetEventL( aTriggerId );
			CleanupStack::PushL( evt );
			if( evt->EventStatus() == EActive )
				{
				if( CLbtTriggerEntry::EStateDisabled == state )
					{
					iEventManager->UpdateEventStatusL( evt->EventId(), ECompleted );
					}
				}
			else
				{
				if( CLbtTriggerEntry::EStateEnabled == state )
					{
					iEventManager->UpdateEventStatusL( evt->EventId(), EActive );
					}
				}
			CleanupStack::PopAndDestroy( evt );
			break;
		case ETriggerDeleted:
			iEventManager->RemoveEventL( aTriggerId );
			break;
		default:
			break;
		}
	EVTUIDEBUG("- CEvtMgmtUiEngine::NotifyTriggerChangeL()" );
	}
//End of file