logexengine.cpp

Log Engine的使用

/*
* ============================================================================
*  Name     : CLogExEngine from LogExEngine.h
*  Part of  : LogExample
*  Created  : 26.05.2005 by Forum Nokia  
*  Implementation notes:
*  Version  : 1.0
*  Copyright: Nokia Corporation
* ============================================================================*/

//INCLUDE FILES
#include <eikenv.h>
#include <logwrap.h>
#include <logwrap.hrh>

#include "e32math.h"	// Random()        

#include "LogExEngine.h"


//DEBUG
#include <e32cons.h>

//LOCAL_D CConsoleBase* gConsole;



// CONSTANTS
_LIT(KOwnEventDescription, "Bluetooth");
_LIT(KOwnEventDirection, "Bluetooth"); 
_LIT(KOwnEventNumber, "No number"); 
_LIT(KOwnEventSubject, "RandomLogEvent");
_LIT(KOwnEventRemoteParty, "OwnContact");
_LIT(KEngineRunPanicText,"Engine-RunL");
_LIT(KEngineAddRandomText,"Engine-AddRandom");
_LIT(KEngineAddOwnText, "Engine-AddOwn");
_LIT(KEngineDefaultSwitch, "Engine-CreateRandom");

const TUid KOwnEventTypeUid = {0x10005570};

// ====================== PUBLIC ============================


// ----------------------------------------------------------
// CLogExEngine::CLogExEngine():CActive(EPriorityStandard)
// Defines priority for object
// ----------------------------------------------------------
//	
CLogExEngine::CLogExEngine():CActive(EPriorityStandard)
	{
	}

// ----------------------------------------------------
// CLogExEngine::~CLogExEngine()
// Destructor
// Frees reserved resources
// ----------------------------------------------------
//
CLogExEngine::~CLogExEngine()
	{
	Cancel();
	
	delete iLogViewEvent;
	delete iLogViewRecent;
	delete iLogEventType;	
	delete iLogClient;	
	delete iLogEvent;
	delete iLogFilter;
	delete iEmptyLogFilter;	

	iFs.Close();
	}


// ----------------------------------------------------
// CLogExEngine::NewL()
// Symbian 2-phase constructor
// ----------------------------------------------------
//
CLogExEngine* CLogExEngine::NewL()
	{
	CLogExEngine* self = CLogExEngine::NewLC();
	CleanupStack::Pop(self);
	return self;
	}

// ----------------------------------------------------
// CLogExEngine::NewLC()
// Symbian 2-phase constructor
// ----------------------------------------------------
//
CLogExEngine* CLogExEngine::NewLC()
	{
	CLogExEngine* self = new (ELeave) CLogExEngine();
	CleanupStack::PushL(self);
	self->ConstructL();
	return self;
	}

// ================= PRIVATE ======================= 

// ----------------------------------------------------
// CLogExEngine::ConstructL()
// Symbian 2-phase constructor
// ----------------------------------------------------
//
void CLogExEngine::ConstructL()
	{
	
	User::LeaveIfError(iFs.Connect());
	
	// Establish connection to log engine
	iLogClient = CLogClient::NewL(iFs);
 
	// Log view and view for recent events events with standard priority
	iLogViewEvent = CLogViewEvent::NewL(*iLogClient);
	iLogViewRecent = CLogViewRecent::NewL(*iLogClient);

	// Filter for events
	iLogFilter = CLogFilter::NewL();
	iEmptyLogFilter = CLogFilter::NewL(); 
		
	iOwnEvenTypeRegistered = EFalse;
	
	iObserver = NULL;
	
	iTask = ESleep; // Default task for RunL
		
	CActiveScheduler::Add(this);
	
	}

// ----------------------------------------------------
// CLogExEngine::RunL()
// RunL
// ----------------------------------------------------
//
void CLogExEngine::RunL()
	{
		
	switch (iTask)
		{
		case EGetEvent:
			{
			
			// Notify observer about change if it has been set
			if(iObserver)
				{
				iObserver->NotifyEventReadL(iLogViewEvent->Event()); 	
				}
			else
				{
				iTask = ESleep;
				break; // No observer, no need to do anything	
				}
				
			// if there are more events in the log engine database...
			if(iLogViewEvent->NextL(iStatus))
				{
				
				// ... set active to get the next one
				SetActive();
				}
			else // no more events
				{		
				iTask = ESleep;
				}
			break;
			}
		
		case EGetRecent:
			{
		
			// Notify observer about change if it has been set
			// Event in the view is sent as a parameter
			if(iRecentObserver)
				{
				iRecentObserver->NotifyEventReadL(iLogViewRecent->Event()); 	
				}
				
			// if there are more events in the log engine database...
			if(iLogViewRecent->NextL(iStatus))
				{
				
				// ... set active to get the next one with the 
				// next asynchronous call
				SetActive();
				}
			else // no more events
				{				
				iTask = ESleep;
				}
			break;
			}
		
		case EAddEvent: // add event to the log engine database
			{
			
			// Event added to log engine database 
			// Notify of change
			__ASSERT_ALWAYS( (iLogEvent != 0), User::Panic(KEngineRunPanicText,1) );
			if(iObserver)
				{
				iObserver->NotifyEventAddedL(*iLogEvent);	
				}
			
			delete iLogEvent;
			iLogEvent = NULL;
			
			iTask = ESleep;
			break;
			}
		case EAddEventType:
			{	
			if(iStatus == KErrAlreadyExists) 
				{
				iOwnEvenTypeRegistered = ETrue; 
				}
		
			AddOwnEventL();
			break;
			}
		case EDeleteEvent:
			{
	
			// Inform observers about deleted event if necessary
			if(iObserver)
				{
				iObserver->NotifyEventDeletedL();				
				}
				
			iTask = ESleep;
			break;
			}
		case ESleep:
		default:
			{
			break;
			}			
		}	 
	}
	

// ----------------------------------------------------
// CLogExEngine::RunError()
// RunL can leave so we need to implement RunError method
// ----------------------------------------------------
//
TInt CLogExEngine::RunError(TInt anError)
	{
	return anError;
	}

// ----------------------------------------------------
// CLogExEngine::DoCancel()
// Method to cancel outstanding request
// ----------------------------------------------------
//
void CLogExEngine::DoCancel()
	{
	//Cancel appropriate request
	switch ( iTask )
		{
		case EGetEvent:
			{
			iLogViewEvent->Cancel();
			break;
			}
		
		case EGetRecent:
			{
			iLogViewRecent->Cancel();
			break;
			}
			
		case EAddEvent:
			{
			iLogClient->Cancel();
			break;
			}
			
		case EAddEventType:
			{
			iLogClient->Cancel();
			break;	
			}	
					
		case EDeleteEvent:
		    {
		    iLogClient->Cancel();	
		    break;
		    }
		    
		case ESleep:
		default:
			break;
		}
	}	

// ----------------------------------------------------
// CLogExEngine::DeleteEventL(TLogId& aLogId)
// Deletes event from the main event log - asynchronous call
// ----------------------------------------------------
//
void CLogExEngine::DeleteEventL(TLogId& aLogId)
	{
	Cancel();
	iLogClient->DeleteEvent(aLogId, iStatus);
	iTask = EDeleteEvent;
	SetActive();
	}

// ----------------------------------------------------
// CLogExEngine::SetObserver(MEventsObserver* aObserver)
// Sets events observer
// ----------------------------------------------------
//
void CLogExEngine::SetObserver(MEventsObserver* aObserver)
	{
	iObserver = aObserver;	
	}

// ----------------------------------------------------
// CLogExEngine::RemoveObserver()
// Removes current events observer
// ----------------------------------------------------
//
void CLogExEngine::RemoveObserver()
	{
	iObserver = NULL;