/*

* 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: 

*     Main list reader

*

*/

// INCLUDE FILES

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <logengevents.h>

#include <logfilterandeventconstants.hrh>

#endif

#include <logview.h>

#include "CLogsMainReader.h"

#include "MLogsObserver.h"

#include "MLogsEvent.h"

#include "MLogsReaderConfig.h"

#include "LogsApiConsts.h"  //additional event uids

#include "MLogsEventArray.h"

// CONSTANTS

// ----------------------------------------------------------------------------

// CLogsMainReader::NewL

// ----------------------------------------------------------------------------

//

CLogsMainReader* CLogsMainReader::NewL(

    RFs& aFsSession,

    MLogsEventArray& aEventArray,

    TLogsEventStrings& aStrings,

    TLogsModel aModelId,

    MLogsObserver* aObserver,

    CLogsEngine* aLogsEngineRef )

    {

    CLogsMainReader* self = new (ELeave) CLogsMainReader

                                        (   aFsSession

                                        ,   aEventArray

                                        ,   aStrings

                                        ,   aModelId

                                        ,   aObserver

                                        ,   aLogsEngineRef

                                        );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

// ----------------------------------------------------------------------------

// CLogsMainReader::CLogsMainReader

// ----------------------------------------------------------------------------

//

CLogsMainReader::CLogsMainReader(

    RFs& aFsSession,

    MLogsEventArray& aEventArray,

    TLogsEventStrings& aStrings,

    TLogsModel aModelId,

    MLogsObserver* aObserver,

    CLogsEngine* aLogsEngineRef ) :

        CLogsBaseReader(

            aFsSession,

            aEventArray,

            aStrings,

            aModelId,

            aObserver,

            aLogsEngineRef )

    {

    }

// ----------------------------------------------------------------------------

// CLogsMainReader::~CLogsMainReader

// ----------------------------------------------------------------------------

//

CLogsMainReader::~CLogsMainReader()

    {

    Cancel();    

    delete iLogViewEvent;

    if( iFilterList )

        {

        iFilterList->ResetAndDestroy();

        delete iFilterList;

        }

    }

// ----------------------------------------------------------------------------

// CLogsMainReader::DoCancel

// ----------------------------------------------------------------------------

//

void CLogsMainReader::DoCancel()

    {

    CLogsBaseReader::DoCancel();    

    iLogViewEvent->Cancel();

    }

// ----------------------------------------------------------------------------

// CLogsMainReader::ConstructL

// ----------------------------------------------------------------------------

//

void CLogsMainReader::ConstructL()

    {

    BaseConstructL();   

    iLogClientRef->SetGlobalChangeObserverL( this );

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

    CActiveScheduler::Add( this ); 

    }

// ----------------------------------------------------------------------------

// CLogsMainReader::DoNextL

// ----------------------------------------------------------------------------

//

TBool CLogsMainReader::DoNextL()

    {

    TBool rc( EFalse );

    switch( iPhase )

        {

        case ERead:

            rc = iLogViewEvent->NextL( iStatus );

            break;

        case EFilter:

            rc = iLogViewEvent->FirstL( iStatus );

            if( rc )

                {

                iPhase = ERead;

                }

            else

                {

                iPhase = EDone;

                iObserver->StateChangedL( this );

                }

            break;

        default:

            break;

        } 

    return rc;

    }

// ----------------------------------------------------------------------------

// CLogsMainReader::SetOneFilterLC

// ----------------------------------------------------------------------------

//

CLogFilter* CLogsMainReader::SetOneFilterLC( TUid aFilterType )

    {

    CLogFilter* filter = CLogFilter::NewL();

    CleanupStack::PushL( filter );

    filter->SetEventType( aFilterType );

    //For message type events we only include events that have already been 

    //searched for remoty party information (CLogsSMSEventUpdater::RunL)

    if( aFilterType == KLogShortMessageEventTypeUid || 

        aFilterType == KLogsEngMmsEventTypeUid )

        {

        filter->SetFlags( KLogEventContactSearched );

        }

    return filter;

    }

// ----------------------------------------------------------------------------

// CLogsMainReader::SetOneFilterLC

// ----------------------------------------------------------------------------

//

CLogFilter* CLogsMainReader::SetOneFilterLC( TLogString& aDirection )

    {

    CLogFilter* filter = CLogFilter::NewL();

    CleanupStack::PushL( filter );

    filter->SetDirection( aDirection );

    return filter;

    }

// ----------------------------------------------------------------------------

// CLogsMainReader::SetOneFilterLC

// ----------------------------------------------------------------------------

//

CLogFilter* CLogsMainReader::SetOneFilterLC(

    const TDesC* aNumber,

    const TDesC* aName )

    {

    CLogFilter* filter = CLogFilter::NewL();

    CleanupStack::PushL( filter );

    if( aNumber->Length() > 0 )

        {

        filter->SetNumber( *aNumber );

        }

    else

        {

        filter->SetNullFields( ELogNumberField );

        }

    if( aName->Length() > 0 )

        {

        filter->SetRemoteParty( *aName );

        }

    else

        {

        filter->SetNullFields( ELogRemotePartyField );

        }

    return filter;

    }    

// ----------------------------------------------------------------------------

// CLogsMainReader::SetFilterL

// ----------------------------------------------------------------------------

//

void CLogsMainReader::SetFilterL(

    const TLogsFilter aFilter,

    const TDesC* aNumber,

    const TDesC* aName )

    {

    //We first empty the event array so that listing new filtered entries in the UI will always start from

    //beginning of an empty list without any old entries. This is because user may very quickly scroll to end 

    //of list in UI by scrolling up in the top of the list. This may cause problems because old lines will be 

    //soon deleted or replaced by new filtered lines.

    iEventArray.Reset();

    if( iFilterList )

        {

        iFilterList->ResetAndDestroy();

        delete iFilterList;

        iFilterList = NULL;

        }

    iFilterList = new ( ELeave ) CLogFilterList;

    switch( aFilter )

        {

        case ELogsFilterVoice:

            iFilterList->AppendL( SetOneFilterLC( KLogCallEventTypeUid ) );

            CleanupStack::Pop();

            //Show also Poc info events here

            iFilterList->AppendL( SetOneFilterLC( KLogsEngPocInfoEventTypeUid ) );

            CleanupStack::Pop();

            break;

        case ELogsFilterData:

            iFilterList->AppendL( SetOneFilterLC( KLogDataEventTypeUid ) );

            CleanupStack::Pop();

            break;

        case ELogsFilterMessages:

            iFilterList->AppendL( SetOneFilterLC( KLogShortMessageEventTypeUid ) );

            CleanupStack::Pop();

            // Mms events not (yet) logged to log db:

            // iFilterList->AppendL( SetOneFilterLC( KLogsEngMmsEventTypeUid ) );

            // CleanupStack::Pop();

            break;

        case ELogsFilterPacket:

            iFilterList->AppendL( SetOneFilterLC( KLogPacketDataEventTypeUid ) );

            CleanupStack::Pop();

            break;

        case ELogsFilterWlan:

            iFilterList->AppendL( SetOneFilterLC( KLogsEngWlanEventTypeUid ) );

            CleanupStack::Pop();

            break;

        case ELogsFilterPerson:

            iFilterList->AppendL( SetOneFilterLC( aNumber, aName ) );

            CleanupStack::Pop();

            break;

        case ELogsFilterIncoming:

            iFilterList->AppendL( SetOneFilterLC( iStrings.iInDirection ) );

            CleanupStack::Pop();

            iFilterList->AppendL( SetOneFilterLC( iStrings.iInDirectionAlt ) );

            CleanupStack::Pop();

            break;

        case ELogsFilterOutgoing:

            iFilterList->AppendL( SetOneFilterLC( iStrings.iOutDirection ) );

            CleanupStack::Pop();

            iFilterList->AppendL( SetOneFilterLC( iStrings.iOutDirectionAlt ) );

            CleanupStack::Pop();

            break;

        case ELogsFilterAllComms:

            iFilterList->AppendL( SetOneFilterLC( KLogShortMessageEventTypeUid ) );

            CleanupStack::Pop();

            // Mms events not (yet) logged to log db:            

            // iFilterList->AppendL( SetOneFilterLC( KLogsEngMmsEventTypeUid ) );

            // CleanupStack::Pop();

            iFilterList->AppendL( SetOneFilterLC( KLogCallEventTypeUid ) );

            CleanupStack::Pop();

            iFilterList->AppendL( SetOneFilterLC( KLogDataEventTypeUid ) );

            CleanupStack::Pop();

            iFilterList->AppendL( SetOneFilterLC( KLogFaxEventTypeUid ) );

            CleanupStack::Pop();

            iFilterList->AppendL( SetOneFilterLC( KLogPacketDataEventTypeUid ) );

            CleanupStack::Pop();

            iFilterList->AppendL( SetOneFilterLC( KLogsEngWlanEventTypeUid ) );

            CleanupStack::Pop();

            iFilterList->AppendL( SetOneFilterLC( KLogsEngPocInfoEventTypeUid ) );

            CleanupStack::Pop();

            break;

        default:            

            break;

        }

    }

// ----------------------------------------------------------------------------

// CLogsMainReader::Stop

// ----------------------------------------------------------------------------

//

void CLogsMainReader::Stop()

    {

    Cancel();

    }

// ----------------------------------------------------------------------------

// CLogsMainReader::StartL

// ----------------------------------------------------------------------------

//

void CLogsMainReader::StartL()

    {

    iIndex = 0;

    Cancel();

    iDirty = EFalse;

    iInterrupted = EFalse;

    TBool rc( EFalse );

    if( ! iFilterList )

        {

        // opened first time

        SetFilterL( ELogsFilterAllComms );

        }

    if( iFilterList )

        {

        TRAPD(  err

             ,  rc = iLogViewEvent->SetFilterParseFilterByFilterL

                                        (   *iFilterList

                                        ,   iStatus

                                        )

             );

        if( err == KErrAccessDenied )

            {

            iDirty = ETrue;

            return;

            }

        User::LeaveIfError(err);

        }

    if( rc )

        {

        iPhase = EFilter;

        iState = EStateInitializing;

        SetActive();

        }

    else if( iObserver )

        {

        iEventArray.Reset();

        iPhase = EDone;

        iState = EStateFinished;

        iObserver->StateChangedL( this );

        }

    } 

// ----------------------------------------------------------------------------

// CLogsMainReader::ConfigureL

// ----------------------------------------------------------------------------

//

void CLogsMainReader::ConfigureL( const MLogsReaderConfig* aConfig ) 

    {

    SetFilterL

        (   aConfig->Filter()

        ,   &aConfig->Number()

        ,   &aConfig->RemoteParty()

        );

    }

// ----------------------------------------------------------------------------

// CLogsMainReader::ViewCountL

// ----------------------------------------------------------------------------

//

TInt CLogsMainReader::ViewCountL() const

    {

    return iLogViewEvent->CountL();

    }

// ----------------------------------------------------------------------------

// CLogsMainReader::Event

// ----------------------------------------------------------------------------

//

CLogEvent& CLogsMainReader::Event() const

    {

    //The RVCT compiler provides warnings "type qualifier on return type is meaningless"

    //for functions that return const values. In order to avoid these numerous warnings and 

    //const cascading, the CLogEvent is const_casted here.

    return const_cast<CLogEvent&>( iLogViewEvent->Event() );

    }

// ----------------------------------------------------------------------------

// CLogsMainReader::ConstructEventL

// ----------------------------------------------------------------------------

//

void CLogsMainReader::ConstructEventL(

    MLogsEvent& aDest,

    const CLogEvent& aSource )

    {

    BaseConstructEventL( aDest, aSource );

    }

// ----------------------------------------------------------------------------

// CLogsMainReader::HandleLogClientChangeEventL

//

// Called by Log Database engine when it notifies a change in database (e.g.

// Log database cleared)

// ----------------------------------------------------------------------------

//

void CLogsMainReader::HandleLogClientChangeEventL(

    TUid aChangeType,

    TInt /*aChangeParam1*/,

    TInt /*aChangeParam2*/,

    TInt /*aChangeParam3*/ )

    {

    if( aChangeType == KLogClientChangeEventLogCleared )

        {

        HandleViewChangeL();

        }

    }