/*

* 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