diff -r 000000000000 -r b497e44ab2fc devicediagnosticsfw/diagframework/src/diaglogeventeraser.cpp --- /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 // CActiveSchedulerWait +#include // CLogClient +#include // CLogViewEvent +#include // 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