--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/serviceproviders/sapi_logging/loggingservice/src/loggingservice.cpp Fri Jul 03 15:51:24 2009 +0100
@@ -0,0 +1,284 @@
+/*
+* Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of the License "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: Implements logging SAPI deligator class.
+*
+*/
+
+
+#include <e32def.h>
+#include <logwrap.h>
+#include <logcli.h>
+
+#include "logiter.h"
+#include "loggingservice.h"
+#include "loggingasyncservice.h"
+#include "loggingsyncservice.h"
+#include "loggingevent.h"
+#include "loggingfilter.h"
+#include "loggingcallbackslot.h"
+
+/**
+* Default Constructor Method
+*/
+
+CLoggingService :: CLoggingService()
+ {
+ }
+
+/**
+* Default Destructor
+*/
+CLoggingService :: ~CLoggingService()
+ {
+ /**
+ * Iterate through the registration table and
+ * cancel and delete any outstanding async request
+ */
+ for(TInt iter = 0 ; iter < iRegTable.Count() ; ++iter)
+ {
+ delete iRegTable[iter] ;
+ }
+ delete iLogService;
+ delete iSapiEvent;
+ iRegTable.Close() ;
+ }
+
+/**
+*Two phased constructor implementation
+*/
+EXPORT_C CLoggingService* CLoggingService :: NewL()
+ {
+ CLoggingService* self = CLoggingService::NewLC();
+ CleanupStack::Pop(self);
+ return self;
+ }
+
+/**
+* Two phased constructor implementation
+*/
+CLoggingService* CLoggingService :: NewLC()
+ {
+ CLoggingService* self = new (ELeave) CLoggingService();
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ return self;
+ }
+
+/**
+* This function constructs the member elements of CLogsEvent Class
+*/
+void CLoggingService:: ConstructL()
+ {
+ iSapiEvent = CLogsEvent :: NewL();
+ iLogService = CLogSyncService :: NewL();
+ }
+
+/**
+* Adds an event to the event database synchronously
+* @parm Details of the event to be logged
+*/
+EXPORT_C TLogId CLoggingService :: AddEventL( CLogsEvent* aSapiEvent )
+ {
+ //Check The registration Table, and make sure that no async
+ // Request is pending
+ return iLogService->AddL(aSapiEvent->getEvent());
+ }
+
+/**
+* Async AddEvent function. adds an Event asynchronously
+* do event database
+* @param aEvent, details of the event to be added to the
+* event database
+*/
+EXPORT_C TInt CLoggingService :: AddEventL( TUint aTransId ,
+ CLogsEvent* aSapiEvent ,
+ MLoggingCallback* aCallback )
+ {
+ CLogAsyncService *LogAsyncService = CLogAsyncService :: NewL(aCallback) ;
+ LogAsyncService->AddL( aTransId ,aSapiEvent->getEvent());
+ CCallbackSlot *LogSlot = CCallbackSlot :: NewL() ;
+ LogSlot->SetUid(aTransId) ;
+ LogSlot->SetActiveObj(LogAsyncService) ;
+ iRegTable.Append(LogSlot) ;
+ return KErrNone ;
+ }
+
+/**
+* Deletes an event from the event database synchronously
+* @parm Details of the event to be logged
+* @param aFilter, search criteria for this event in event database
+*/
+
+EXPORT_C TInt CLoggingService :: DeleteEventL( TLogId aLogId )
+ {
+ return iLogService->Delete(aLogId);
+ }
+
+/**
+* Deletes a event from the event database
+* @param aLogId Event id of the event in the database
+* @param aFilter, search criteria for this event in event database
+*/
+EXPORT_C void CLoggingService :: DeleteEventL( TUint aTransId ,
+ TLogId aLogId,
+ MLoggingCallback* aCallback )
+
+ {
+ CLogAsyncService *LogAsyncService = CLogAsyncService :: NewL(aCallback) ;
+ LogAsyncService->Delete(aTransId ,aLogId);
+ CCallbackSlot *slot = CCallbackSlot :: NewL() ;
+ slot->SetUid(aTransId) ;
+ slot->SetActiveObj(LogAsyncService) ;
+ iRegTable.Append(slot) ;
+ }
+
+/**
+* Gets the event list from events from the log database synchronously
+*
+* @param aLogId Event id of the event in the database
+* @param aFilter, search criteria for this event in event database
+*
+* Returns the iterator
+*/
+EXPORT_C CLogIter* CLoggingService :: GetListL( CLogsFilter* aFilter )
+ {
+ CLogIter* iter=NULL ;
+ switch(aFilter->GetRequestType())
+ {
+ case EReadEvents :
+ {
+ iter = iLogService->GetListL(aFilter->getFilter()) ;
+ break ;
+ }
+
+ case EGetEvent :
+ {
+ CLogsEvent *event = aFilter->GetEvent() ;
+ iter = iLogService->GetEventL(event->getEvent()) ;
+
+ if(iter )
+ {
+ iter->SetEventL(event) ;
+ }
+
+ break ;
+ }
+
+ case EGetRecent :
+ {
+ iter = iLogService->ReadRecentEventsL( aFilter->GetRecentList(), aFilter->getFilter() ) ;
+ break ;
+ }
+
+ default :
+ {
+ User :: Leave(KErrArgument) ;
+ }
+ }
+ return iter ;
+ }
+
+/**
+* Gets the event list from events from the log database asynchronously
+*
+* @param aTransId, transactionid of the async event
+* @param aFilter, search criteria for this event in event database
+* @param aCallback, call back address
+*/
+EXPORT_C TInt CLoggingService :: GetListL( TUint aTransId ,
+ CLogsFilter* aFilter ,
+ MLoggingCallback* aCallback )
+ {
+ CLogAsyncService* LogAsyncService = CLogAsyncService :: NewL(aCallback) ;
+ /**
+ * Parse the request type and issue the request to loggingservice
+ * class accordingly
+ */
+ switch(aFilter->GetRequestType())
+ {
+ case EReadEvents :
+ {
+ LogAsyncService->GetListL(aTransId , aFilter->getFilter()) ;
+ break ;
+ }
+
+ case EGetEvent :
+ {
+ CLogsEvent *event = aFilter->GetEvent() ;
+ LogAsyncService->GetEventL(aTransId , event->getEvent()) ;
+ break ;
+ }
+
+ case EGetRecent :
+ {
+ LogAsyncService->ReadRecentEventsL(aTransId , aFilter->GetRecentList(), aFilter->getFilter()) ;
+ break ;
+ }
+
+ default :
+ {
+ User :: Leave(KErrArgument) ;
+ }
+ }
+ CCallbackSlot *slot = CCallbackSlot :: NewL() ;
+ slot->SetActiveObj(LogAsyncService) ;
+ slot->SetUid(aTransId) ;
+ iRegTable.Append(slot);
+ return KErrNone ;
+ }
+
+
+/**
+* Notifies the updates happening to the log database
+*
+* @param aDelay, notification interval.
+*/
+
+EXPORT_C TInt CLoggingService :: NotifyUpdatesL( TUint aUid ,
+ TTimeIntervalMicroSeconds32 aDelay ,
+ MLoggingCallback *aCallback )
+ {
+ CLogAsyncService *AsyncService = CLogAsyncService :: NewL(aCallback);
+ AsyncService->SetInterval(aDelay) ;
+ AsyncService->NotifyUpdates(aUid ,aDelay) ;
+ CCallbackSlot *slot = CCallbackSlot :: NewL() ;
+ slot->SetActiveObj(AsyncService) ;
+ slot->SetUid(aUid) ;
+ iRegTable.AppendL(slot) ;
+ return KErrNone ;
+ }
+
+/**
+* CancelServiceL, cancels the on going service
+* @param aTransid
+*/
+EXPORT_C TInt CLoggingService :: CancelServiceL( TUint aTransid )
+ {
+ for(TInt iterator = 0 ; iterator < iRegTable.Count() ; ++iterator)
+ {
+ if((iRegTable[iterator]->getUid()) == aTransid)
+ {
+ (iRegTable[iterator])->GetActiveObj()->Cancel() ;
+ delete iRegTable[iterator];
+ iRegTable[iterator]=NULL;
+ iRegTable.Remove( iterator );
+ iRegTable.Compress();
+ return KErrNone ;
+ }
+ }
+
+ return KErrNotFound ;
+ }
+
+