--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/devicediagnosticsfw/diagframework/src/diaglogeventeraser.cpp Thu Dec 17 09:07:52 2009 +0200
@@ -0,0 +1,325 @@
+/*
+* 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 "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: This is the implementation of the Diagnostics Log Event
+* Eraser, which is used to delete OS log entries.
+*
+*/
+
+
+// System Include Files
+#include <e32base.h> // CActiveSchedulerWait
+#include <logcli.h> // CLogClient
+#include <logview.h> // CLogViewEvent
+#include <DiagFrameworkDebug.h> // Debugging macros
+
+// Local Include Files
+#include "diaglogeventeraser.h" // CDiagLogEventEraser
+#include "diaglogeventeraserobserver.h" // MDiagLogEventEraserObserver
+
+
+// ============================ MEMBER FUNCTIONS =============================
+
+// ---------------------------------------------------------------------------
+// Static two-phase constructor.
+// ---------------------------------------------------------------------------
+//
+EXPORT_C CDiagLogEventEraser* CDiagLogEventEraser::NewL(
+ MDiagLogEventEraserObserver& aObserver,
+ CLogFilter* aFilter )
+ {
+ LOGSTRING( "CDiagLogEventEraser::NewL()" )
+
+ CleanupStack::PushL( aFilter );
+ CDiagLogEventEraser* self = new ( ELeave ) CDiagLogEventEraser(
+ aObserver,
+ aFilter );
+ CleanupStack::Pop( aFilter );
+
+ CleanupStack::PushL( self );
+ self->ConstructL();
+ CleanupStack::Pop( self );
+
+ return self;
+ }
+
+// ---------------------------------------------------------------------------
+// Destructor.
+// ---------------------------------------------------------------------------
+//
+EXPORT_C CDiagLogEventEraser::~CDiagLogEventEraser()
+ {
+ LOGSTRING( "CDiagLogEventEraser::~CDiagLogEventEraser()" )
+
+ Cancel();
+
+ delete iLogFilter;
+ delete iLogView;
+ delete iLogClient;
+ delete iWaitScheduler;
+
+ iFsSession.Close();
+ }
+
+// ---------------------------------------------------------------------------
+// Gets the filter to use when erasing logs.
+// ---------------------------------------------------------------------------
+//
+EXPORT_C CLogFilter& CDiagLogEventEraser::Filter()
+ {
+ LOGSTRING( "CDiagLogEventEraser::Filter()" )
+ return *iLogFilter;
+ }
+
+// ---------------------------------------------------------------------------
+// Gets the log client used for the log erasure.
+// ---------------------------------------------------------------------------
+//
+EXPORT_C CLogClient& CDiagLogEventEraser::LogClient()
+ {
+ LOGSTRING( "CDiagLogEventEraser::LogClient()" )
+ return *iLogClient;
+ }
+
+// ---------------------------------------------------------------------------
+// Begins asynchronous erasure of logs. The observer will be notified of
+// completion via callback.
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CDiagLogEventEraser::StartAsyncEraseLogsL()
+ {
+ LOGSTRING( "CDiagLogEventEraser::StartAsyncEraseLogsL()" )
+
+ __ASSERT_DEBUG( iState == EStateInitial, User::Invariant() );
+
+ // Apply the filter.
+ if( iLogView->SetFilterL( *iLogFilter, iStatus ) )
+ {
+ iState = EStateApplyingFilter;
+ iIsDeletingSynchronous = EFalse;
+ SetActive();
+ }
+
+ // There are no logs, so set this object active so that the callback will
+ // be asynchronous.
+ else
+ {
+ iState = EStateComplete;
+ TRequestStatus* status = &iStatus;
+ User::RequestComplete( status, KErrNone );
+ SetActive();
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// Begins synchronous erasure of logs.
+// ---------------------------------------------------------------------------
+//
+EXPORT_C void CDiagLogEventEraser::EraseLogsL()
+ {
+ LOGSTRING( "CDiagLogEventEraser::EraseLogsL()" )
+
+ __ASSERT_DEBUG( iState == EStateInitial, User::Invariant() );
+
+ iError = KErrNone;
+
+ // Apply the filter. iWaitScheduler->Start() will return after the wait
+ // scheduler is stopped.
+ if( iLogView->SetFilterL( *iLogFilter, iStatus ) )
+ {
+ iState = EStateApplyingFilter;
+ iIsDeletingSynchronous = ETrue;
+ SetActive();
+ iWaitScheduler->Start();
+ }
+
+ // If there is an error, iError will be set when the active object is run.
+ User::LeaveIfError( iError );
+ }
+
+// ---------------------------------------------------------------------------
+// The default constructor.
+// ---------------------------------------------------------------------------
+//
+CDiagLogEventEraser::CDiagLogEventEraser(
+ MDiagLogEventEraserObserver& aObserver,
+ CLogFilter* aFilter )
+: CActive( EPriorityStandard ),
+ iObserver( aObserver ),
+ iLogFilter( aFilter )
+ {
+ LOGSTRING( "CDiagLogEventEraser::CDiagLogEventEraser()" )
+ CActiveScheduler::Add( this );
+ }
+
+// ---------------------------------------------------------------------------
+// The second phase constructor.
+// ---------------------------------------------------------------------------
+//
+void CDiagLogEventEraser::ConstructL()
+ {
+ LOGSTRING( "CDiagLogEventEraser::ConstructL()" )
+
+ User::LeaveIfError( iFsSession.Connect() );
+ iWaitScheduler = new( ELeave ) CActiveSchedulerWait;
+ iLogClient = CLogClient::NewL( iFsSession );
+ iLogView = CLogViewEvent::NewL( *iLogClient );
+ if ( !iLogFilter )
+ {
+ iLogFilter = CLogFilter::NewL();
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// Handles the completion of log erasing and performs different operations
+// depending on whether the erasing was asynchronous or not.
+// ---------------------------------------------------------------------------
+//
+void CDiagLogEventEraser::HandleCompletionL( TInt aError )
+ {
+ LOGSTRING2( "CDiagLogEventEraser::HandleCompletionL( %d )", aError )
+
+ // Reset the state so that the object can be reused.
+ iState = EStateInitial;
+
+ // For synchronous erasure, set the error code and stop the wait
+ // scheduler, so that it will return in EraseLogsL.
+ if ( iIsDeletingSynchronous )
+ {
+ iError = aError;
+ iWaitScheduler->AsyncStop();
+ }
+
+ // For asynchronous erasure, inform the observer that erasing has
+ // completed.
+ else
+ {
+ iObserver.CompleteEventEraseL( aError );
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// Handles the completion of active requests.
+// ---------------------------------------------------------------------------
+//
+void CDiagLogEventEraser::RunL()
+ {
+ LOGSTRING( "CDiagLogEventEraser::RunL()" )
+
+ // Check that the request completed successfully.
+ if( iStatus != KErrNone )
+ {
+ HandleCompletionL( iStatus.Int() );
+ return;
+ }
+
+ LOGSTRING2( "CDiagLogEventEraser::RunL() - State %d", iState )
+ switch( iState )
+ {
+ case EStateApplyingFilter:
+ {
+ // The log view filter has been successfully applied. Issue
+ // another request to start processing log events. Events are
+ // read from last to first. The reason for this arrangement is
+ // that we are deleting entries while reading them.
+ if( iLogView->LastL( iStatus ) )
+ {
+ iState = EStateReadingEntries;
+ SetActive();
+ }
+
+ // There are no events in the view.
+ else
+ {
+ HandleCompletionL( KErrNone );
+ }
+
+ break;
+ }
+
+ case EStateReadingEntries:
+ {
+ const CLogEvent& event = iLogView->Event();
+
+ // The log event has been fetched successfully. Ask the observer
+ // if this event should be erased. If so, issue another request
+ // to begin erasing the event.
+ if( iObserver.IsEventToBeDeleted( event ) )
+ {
+ iState = EStateDeletingEntry;
+ iLogClient->DeleteEvent( event.Id(), iStatus );
+ SetActive();
+ }
+
+ // The log event should not be erased, so get the next event.
+ else if( iLogView->PreviousL( iStatus ) )
+ {
+ SetActive();
+ }
+
+ // There are no events in the view.
+ else
+ {
+ HandleCompletionL( KErrNone );
+ }
+
+ break;
+ }
+
+ case EStateDeletingEntry:
+ {
+ // The log event was successfully deleted. Issue another request
+ // to read the next entry.
+ if( iLogView->PreviousL( iStatus ) )
+ {
+ iState = EStateReadingEntries;
+ SetActive();
+ }
+
+ // There are no events in the view.
+ else
+ {
+ HandleCompletionL( KErrNone );
+ }
+
+ break;
+ }
+
+ case EStateComplete:
+ {
+ HandleCompletionL( KErrNone );
+ break;
+ }
+
+ default:
+ // This state should never be reached.
+ LOGSTRING( "CDiagLogEventEraser::RunL() - Invalid State." )
+ User::Invariant();
+ break;
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// Handles the cancellation of active requests.
+// ---------------------------------------------------------------------------
+//
+void CDiagLogEventEraser::DoCancel()
+ {
+ LOGSTRING( "CDiagLogEventEraser::DoCancel()" )
+
+ iLogView->Cancel();
+ iLogClient->Cancel();
+ iState = EStateInitial;
+ }
+
+// End of file