/*

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

*       CMsgLogsObserver implementation file

*

*/

// INCLUDE FILES

#include <e32base.h>

#include <logcli.h>

#include <logview.h>

#include <mmsconst.h>

#include <LogsApiConsts.h>

#include <AknGlobalNote.h>

#include "MsgErrorWatcher.h"

#include "MsgLogsObserver.h"

#include "MsgErrorWatcherLogging.h"

// CONSTANTS

_LIT(KMmsLogEventTypeName, "MMS");

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

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

// CMsgLogsObserver::CMsgLogsObserver

//

// C++ constructor can NOT contain any code, that

// might leave.

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

//

CMsgLogsObserver::CMsgLogsObserver( CMsgErrorWatcher* aWatcher, RFs& aFs )

    : CActive( CActive::EPriorityStandard ),

    iWatcher( aWatcher ),

    iFs( aFs )

    {

    CActiveScheduler::Add( this );

    }

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

// CMsgLogsObserver::NewL

//

// Two-phased constructor.

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

//

CMsgLogsObserver* CMsgLogsObserver::NewL( CMsgErrorWatcher* aWatcher, RFs& aFs )

    {

    CMsgLogsObserver* self = new ( ELeave ) CMsgLogsObserver( aWatcher, aFs );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CMsgLogsObserver::~CMsgLogsObserver

//

// Destructor

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

//

CMsgLogsObserver::~CMsgLogsObserver()

    {

    Cancel();

    if (iFilterList)

        {

        iFilterList->ResetAndDestroy(); // destroy old log filters

        }

    delete iFilterList;

    delete iLogViewEvent;

    delete iLogEvent;

    delete iDummyLogEvent1;

    delete iDummyLogEvent2;

    delete iLogClient;

    delete iLogEventType;

    }

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

// CMsgLogsObserver::ConstructL()

//

// Symbian OS default constructor can leave.

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

//

void CMsgLogsObserver::ConstructL()

    {

    iLogClient = CLogClient::NewL( iFs );

    iLogEvent = CLogEvent::NewL();

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

    iFilterList = new ( ELeave ) CLogFilterList();

    iLogClient->GetString( iDelivered, R_LOG_DEL_DONE );

    //AddNewEventType for dummy event

    AddEventTypeL();

    }

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

// CMsgLogsObserver::AppendFiltersL

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

//

void CMsgLogsObserver::AppendFiltersL()

    {

    CLogFilter* filter;

    /// Event Type: MMS

    /// Status: Delivered

    filter = CLogFilter::NewL();

    CleanupStack::PushL( filter );

    filter->SetEventType( KLogMmsEventTypeUid );

    filter->SetStatus( iDelivered );

    iFilterList->AppendL( filter );

    CleanupStack::Pop(); //filter

	// Event Type: MMS

	// Status: Read

	filter = CLogFilter::NewL();

	CleanupStack::PushL( filter );

	filter->SetEventType( KLogMmsEventTypeUid );

	filter->SetStatus( KLogsMsgReadText );

	iFilterList->AppendL( filter );

	CleanupStack::Pop(); //filter

    return;

    }

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

// CMsgLogsObserver::CreateFiltersL

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

//

void CMsgLogsObserver::CreateFiltersL()

    {

MEWLOGGER_WRITE( "CreateFiltersL()" );    

    iState = EMsgLogsCreatingFilters;

    AppendFiltersL();

    if( !IsActive() )

        {	

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

			{

			MEWLOGGER_WRITE( "Setting filter succesfully started" );

		    SetActive();

		    }

		else

		    {

		    MEWLOGGER_WRITE( "Setting filter: CompleteSelf();" ); 

            CompleteSelf();

		    }

        }

    }

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

// CMsgLogsObserver::DoCancel

//

// From active object framework

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

//

void CMsgLogsObserver::DoCancel()

    {

    if ( iLogViewEvent )

        {

        iLogViewEvent->Cancel();

        }

    if ( iLogClient )

        {

        iLogClient->Cancel();

        }

    }

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

// CMsgLogsObserver::RunL

//

// From active object framework

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

//

void CMsgLogsObserver::RunL()

    {

    switch ( iState )

        {

        case EMsgLogsIdle:

            MEWLOGGER_WRITE( "Idle state in RunL" );

            break;

        case EMsgLogsGettingEvent:

            {

            MEWLOGGER_WRITE( "call ShowNoteL()  in RunL" );

            TRAP_IGNORE( ShowNoteL() );

            iState = EMsgLogsIdle;

            break;

            }

        case EMsgLogsDeletingDummyEvent1:

            MEWLOGGER_WRITE( "call DeleteDummyEvent2()  in RunL" );

            DeleteDummyEvent2(); 

            break;

        case EMsgLogsDeletingDummyEvent2:

            iState = EMsgLogsIdle;

            break;

        case EMsgLogsCreatingFilters:

            MEWLOGGER_WRITE( "call DeleteDummyEvent1()  in RunL" ); 

            DeleteDummyEvent1(); 

            break;

        case EMsgLogsAddingEventType:

            //Event type already exists

            if ( iStatus.Int() == KErrAlreadyExists)

            	{

            	MEWLOGGER_WRITE( "Event type already exists in RunL" ); 

            	//No need to create any dummy entrys

            	//This not first boot

            	iState = EMsgLogsAddingDummyEvent2;

                CompleteSelf();

            	}

            else

            	{

            	MEWLOGGER_WRITE( "call AddDummyEvent1L()  in RunL" );	

                TRAP_IGNORE( AddDummyEvent1L() );

            	}

            break;

        case EMsgLogsAddingDummyEvent1:

            MEWLOGGER_WRITE( "call AddDummyEvent2L()  in RunL" ); 

            TRAP_IGNORE( AddDummyEvent2L() ); 

            break;   	

        case EMsgLogsAddingDummyEvent2:

            MEWLOGGER_WRITE( "call CreateFiltersL()  in RunL" ); 

            TRAP_IGNORE( CreateFiltersL() );

            break;	

        default:

            // Nothing to do but wait.

            iState = EMsgLogsIdle;

            break;

        }

    }

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

// CMsgLogsObserver::HandleLogViewChangeEventAddedL

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

//

void CMsgLogsObserver::HandleLogViewChangeEventAddedL(TLogId aId, TInt /*aViewIndex*/, TInt /*aChangeIndex*/, TInt /*aTotalChangeCount*/)

    {

    GetLogEventL( aId );

    }

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

// CMsgLogsObserver::HandleLogViewChangeEventChangedL

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

//

void CMsgLogsObserver::HandleLogViewChangeEventChangedL(TLogId aId, TInt /*aViewIndex*/, TInt /*aChangeIndex*/, TInt /*aTotalChangeCount*/)

    {

    GetLogEventL( aId );

    }

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

// CMsgLogsObserver::HandleLogViewChangeEventDeletedL

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

//

void CMsgLogsObserver::HandleLogViewChangeEventDeletedL(TLogId /*aId*/, TInt /*aViewIndex*/, TInt /*aChangeIndex*/, TInt /*aTotalChangeCount*/)

    {

    // We're not interested.

    }

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

// CMsgLogsObserver::GetLogEventL

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

//

void CMsgLogsObserver::GetLogEventL( TLogId aId )

    {

    if ( !IsActive() )

        {

        iState = EMsgLogsGettingEvent;

        iLogEvent->SetId( aId );

        iLogClient->GetEvent( *iLogEvent, iStatus );

        SetActive();

        }

    // else we missed this one!

    }

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

// CMsgLogsObserver::Delivered

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

//

void CMsgLogsObserver::ShowNoteL()

    {

    if ( iDelivered.Compare( iLogEvent->Status() ) == 0 &&

        !( iLogEvent->Flags() & KLogEventRead ) )

        {

        iWatcher->ShowDeliveredNoteL( iLogEvent->RemoteParty() );

        }

    else if ( iLogEvent->Status().Compare( KLogsMsgReadText ) == 0 &&

        !( iLogEvent->Flags() & KLogEventRead ) )

        {

        iWatcher->ShowReadNoteL( iLogEvent->RemoteParty() );

        }

    }

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

// CMsgLogsObserver::AddEventTypeL

//

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

//

void CMsgLogsObserver::AddEventTypeL()

    {

    iState = EMsgLogsAddingEventType; 

    if (!IsActive() )

    	{

        iLogEventType = CLogEventType::NewL();

        iLogEventType->SetUid( KLogMmsEventTypeUid );

        iLogEventType->SetDescription( KMmsLogEventTypeName );

        iLogEventType->SetLoggingEnabled( ETrue );

        iLogClient->AddEventType( *iLogEventType, iStatus );

        SetActive();

    	}

    } 

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

// CMsgLogsObserver::AddDummyEvent1L

//

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

//

void CMsgLogsObserver::AddDummyEvent1L() 

	{

	iState = EMsgLogsAddingDummyEvent1;

    if (!IsActive())

    	{	  

        iDummyLogEvent1 = CLogEvent::NewL();

        iDummyLogEvent1->SetEventType( KLogMmsEventTypeUid );

        iDummyLogEvent1->SetStatus( iDelivered );

        iLogClient->AddEvent( *iDummyLogEvent1, iStatus );    

        SetActive();

    	}    

	}

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

// CMsgLogsObserver::AddDummyEvent2L

//

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

//

void CMsgLogsObserver::AddDummyEvent2L() 

	{

	iState = EMsgLogsAddingDummyEvent2;

    if (!IsActive())

    	{	  

        iDummyLogEvent2 = CLogEvent::NewL();

        iDummyLogEvent2->SetEventType( KLogMmsEventTypeUid );

        iDummyLogEvent2->SetStatus( KLogsMsgReadText );

        iLogClient->AddEvent( *iDummyLogEvent2, iStatus );    

        SetActive();

    	}    

	}	

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

// CMsgLogsObserver::DeleteDummyEvent1

//

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

//

void CMsgLogsObserver::DeleteDummyEvent1() 

	{

	iState = EMsgLogsDeletingDummyEvent1;

    if (!IsActive() && iDummyLogEvent1 )

    	{	 

        TLogId dummyId = iDummyLogEvent1->Id();

        iLogClient->DeleteEvent( dummyId, iStatus );    

        SetActive();

    	}   

    else

    	{

    	iState = EMsgLogsIdle;

    	CompleteSelf();

    	}	 

	}

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

// CMsgLogsObserver::DeleteDummyEvent2

//

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

//

void CMsgLogsObserver::DeleteDummyEvent2() 

	{

	iState = EMsgLogsDeletingDummyEvent2;

    if (!IsActive() && iDummyLogEvent2 )

    	{	 

        TLogId dummyId = iDummyLogEvent2->Id();

        iLogClient->DeleteEvent( dummyId, iStatus );    

        SetActive();

    	}   

    else

    	{

    	iState = EMsgLogsIdle;

    	CompleteSelf();

    	}	 

	}	

void CMsgLogsObserver::CompleteSelf()

    {

	// If no events complete self to get to RunL()

	TRequestStatus* status = &iStatus;

	iStatus = KRequestPending;

	SetActive();	

	User::RequestComplete( status, KErrNone );

	}

// ================= OTHER EXPORTED FUNCTIONS ==============

//  End of File