/*

* Copyright (c) 2002 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:  

*     Messaging Centre application's engine class that reads events from

*     log DB.

*

*/

// INCLUDE FILES

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <logfilterandeventconstants.hrh>

#endif

#include <coemain.h>            // for CCoeEnv

#include <logview.h>            // CLogViewEvent

#include "DllMain.h"			// panic function

#include "MceLogEngineReader.h"

#include <LogsApiConsts.h>

// ================= MEMBER FUNCTIONS =======================

CMceLogEngineReader::CMceLogEngineReader(

    CMceLogEngine* aObserver)

    : CActive(EPriorityStandard),

      iObserver(aObserver)

    {

    }

CMceLogEngineReader* CMceLogEngineReader::NewL(

    CMceLogEngine* aObserver)

    {

    CMceLogEngineReader* self = new (ELeave) CMceLogEngineReader(aObserver);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

void CMceLogEngineReader::ConstructL()

    {

    User::LeaveIfError(iFsSession.Connect());

    iLogClient = CLogClient::NewL(iFsSession);

    iLogViewEvent = CLogViewEvent::NewL(*iLogClient, *this);

    SetSpecialFilterL();

    CActiveScheduler::Add(this);

    }

CMceLogEngineReader::~CMceLogEngineReader()

    {

    Cancel();

    delete iLogViewEvent;

    delete iLogClient;

    iFsSession.Close();

    if (iFilterList)

        {

        iFilterList->ResetAndDestroy();

        delete iFilterList;

        }

    }

void CMceLogEngineReader::StartReadingL()

    {

    Cancel();

    iEventCounter = 0;

    iEventsInView = 0;

    iArrayReset = EFalse;

    if( iLogViewEvent->SetFilterL(*iFilterList, iStatus) )

        {

        iReaderState = ESettingFilter;

        SetActive();

        }

    else if( iObserver )

        {

        iObserver->ResetArray();

        iObserver->ReadEventsCompletedL();

        }

    }

void CMceLogEngineReader::DoCancel()

    {

    /// cancel filter setting or event reading

    iLogViewEvent->Cancel();

    }

TInt CMceLogEngineReader::RunError(TInt aError)

    {

    if( aError == KErrAccessDenied )

        {

        return KErrNone;

        }

    else

        {

        return aError;

        }

    }

void CMceLogEngineReader::RunL()

    {

    CLogEvent* event;

    if (iStatus != KErrNone)

        {

        // reading entries failed somehow.

        iObserver->ReadEventsCompletedL( EFalse );

        }

    else

        {

        switch (iReaderState)

            {

            /// filter setting asyncronous request completed

            case ESettingFilter:

                if (iLogViewEvent->CountL() == 0)

                    {

                    iObserver->ResetArray();

                    iObserver->ReadEventsCompletedL();

                    }

                else

                    {

                    /// start first event reading asyncronous request

                    iReaderState = EReadingEntry;

                    iLogViewEvent->FirstL(iStatus);

                    SetActive();

                    }

                break;

            /// event reading asyncronous request completed

            case EReadingEntry:

                if( ! iArrayReset )

                    {

                    iArrayReset = ETrue;

                    iObserver->ResetArray();

                    }

                event = CLogEvent::NewL();

                CleanupStack::PushL( event );

                event->CopyL(iLogViewEvent->Event());

                iEventsInView++;

                if( event->Number().Length() || event->RemoteParty().Length() )

                    {

                    iObserver->AddEventToListL( event );

                    CleanupStack::Pop(); // event

                    iEventCounter++;

                    }

                else

                    {

                    CleanupStack::PopAndDestroy(); // event

                    }

                if ( iEventsInView < iLogViewEvent->CountL() &&

                                        iEventCounter < KMceLogEngFetchLimit )

                    {

                    /// read next event

                    iLogViewEvent->NextL( iStatus );

                    SetActive();

                    }

                else

                    {

                    /// inform observer, that reading is done

                    iObserver->ReadEventsCompletedL();

                    }

                break;

            default:

                break;

                }

            }

    }

void CMceLogEngineReader::SetSpecialFilterL()

    {

    /// create filter array to pass through only

    /// events needed in Delivery Report

    CLogFilter* filter;

    if( iFilterList )

        {

        iFilterList->ResetAndDestroy();

        delete iFilterList;

        iFilterList = NULL;

        }

    iFilterList = new (ELeave) CLogFilterList();

    /// Direction: OUT

    TLogString inOutName;

    iLogClient->GetString(inOutName, R_LOG_DIR_OUT);

    filter = CLogFilter::NewL();

    CleanupStack::PushL( filter );

    filter->SetDirection(inOutName);

    filter->SetFlags( KLogEventRead );

    filter->SetNullFields( ELogFlagsField );

    iFilterList->AppendL(filter);

    CleanupStack::Pop(); //filter

    /// Event Type: SMS

    filter = CLogFilter::NewL();

    CleanupStack::PushL( filter );

    filter->SetEventType(KLogShortMessageEventTypeUid);

    iFilterList->AppendL(filter);

    CleanupStack::Pop(); //filter

    /// Event Type: MMS

    filter = CLogFilter::NewL();

    CleanupStack::PushL( filter );

    filter->SetEventType( KLogsEngMmsEventTypeUid );

    iFilterList->AppendL(filter);

    CleanupStack::Pop(); //filter

    /// Status: Pending

    TLogString pending;

    iLogClient->GetString(pending, R_LOG_DEL_PENDING);

    filter = CLogFilter::NewL();

    CleanupStack::PushL( filter );

    filter->SetStatus( pending );

    iFilterList->AppendL(filter);

    CleanupStack::Pop(); //filter

    /// Status: Delivered

    TLogString done;

    iLogClient->GetString(done, R_LOG_DEL_DONE);

    filter = CLogFilter::NewL();

    CleanupStack::PushL( filter );

    filter->SetStatus( done );

    iFilterList->AppendL(filter);

    CleanupStack::Pop(); //filter

    /// Status: Failed

    TLogString failed;

    iLogClient->GetString(failed, R_LOG_DEL_FAILED);

    filter = CLogFilter::NewL();

    CleanupStack::PushL( filter );

    filter->SetStatus( failed );

    iFilterList->AppendL(filter);

    CleanupStack::Pop(); //filter

    /// Event Type: MMS

    /// Status: Read

    filter = CLogFilter::NewL();

    CleanupStack::PushL( filter );

    filter->SetEventType( KLogsEngMmsEventTypeUid );

    filter->SetStatus( KLogsMsgReadText );

    iFilterList->AppendL( filter );

    CleanupStack::Pop(); //filter

    }

void CMceLogEngineReader::HandleLogViewChangeEventAddedL(

                TLogId /*aId*/,   

                TInt /*aViewIndex*/, 

                TInt /*aChangeIndex*/, 

                TInt /*aTotalChangeCount*/ )

    {

    StartReadingL();

    }

void CMceLogEngineReader::HandleLogViewChangeEventChangedL(

                TLogId /*aId*/,   

                TInt /*aViewIndex*/, 

                TInt /*aChangeIndex*/, 

                TInt /*aTotalChangeCount*/ )

    {

    StartReadingL();

    }

void CMceLogEngineReader::HandleLogViewChangeEventDeletedL(

                TLogId /*aId*/,   

                TInt /*aViewIndex*/, 

                TInt /*aChangeIndex*/, 

                TInt /*aTotalChangeCount*/ )

    {

    StartReadingL();

    }

void CMceLogEngineReader::ClearDrListL()

    {

    __ASSERT_DEBUG( iLogViewEvent, LogsEnginePanic( ELogsEnginePanicPreCond ) );

    iLogViewEvent->SetFlagsL( KLogEventRead );

    StartReadingL();

    }

// End of file