--- a/eventsui/eventsengine/src/evtmgmtuiengine.cpp Thu Aug 19 09:48:36 2010 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,695 +0,0 @@
-/*
-* 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