/*

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

*     Implements interface for log event getting

*

*/

// INCLUDE FILES

// #include <PbkFields.hrh>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <logengevents.h>

#endif

#include <logcli.h>

#include <logview.h>

#include <logviewchangeobserver.h>

#include <featmgr.h>

#include "CLogsGetEvent.h"

#include "CLogsEventData.h"

#include "CLogsEvent.h"

#include "MLogsObserver.h"

#include "CLogsEventGetter.h"

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

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES  

// CONSTANTS

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

//========================================CLogsGetEventNotify=============================================

//

class CLogsGetEventNotify : public CActive, 

                            public MLogViewChangeObserver

    {

    public:

        /**

         * Symbian OS constructor. 

         *

         * @param aFsSession ref. to file server session

         * @param aGetEvent pointer to Logs reader

         * @return New instance of this class

         */

        static CLogsGetEventNotify* NewL

                                    (   RFs& aFsSession

                                    ,   CLogsGetEvent* aGetEvent

                                    );

        /**

         *  Destructor

         */

        ~CLogsGetEventNotify();

    private:

        /**

         * Default constructor. 

         */

        CLogsGetEventNotify();

        /**

         * Second phase constructor. 

         */

        void ConstructL();

        /**

         * C++ constructor. 

         *

         * @param aFsSession ref. to file server session

         * @param aGetEvent pointer to Logs reader

         */

        CLogsGetEventNotify( RFs& aFsSession, CLogsGetEvent* aGetEvent );

    public:

        /**

         *  Sets Log ID

         *  @param aId Log ID

         */

        void SetId( TLogId aId );

    private:

        /**

         *  Creates and returns a filter.

         *  Leaves filter object on cleanupstack.

         *

         *  @param  aFilterType     Filter type id.

         *

         *  @return  Pointer to created and configured filter.

         */

        CLogFilter* SetOneFilterLC( TUid aFilterType );

    public: // from MLogViewChangeObserver

        void HandleLogViewChangeEventAddedL

                        (   TLogId aId

                        ,   TInt aViewIndex

                        ,   TInt aChangeIndex

                        ,   TInt aTotalChangeCount

                        );

        void HandleLogViewChangeEventChangedL

                        (   TLogId aId

                        ,   TInt aViewIndex

                        ,   TInt aChangeIndex

                        ,   TInt aTotalChangeCount

                        );

        void HandleLogViewChangeEventDeletedL

                        (   TLogId aId

                        ,   TInt aViewIndex

                        ,   TInt aChangeIndex

                        ,   TInt aTotalChangeCount

                        );

    private: /// from CActive

        void DoCancel();

    protected: /// from CActive

        void RunL();

        TInt RunError(TInt aError);

    private: // data

        /// Own:

        TLogId              iId;

        /// Ref: File server session

        RFs&                iFsSession;

        /// Own:

        CLogsGetEvent*      iGetEvent;

        /// Own: Log client

        CLogClient*         iLogClient;

        /// Own:

        CLogViewEvent*      iEventView;

        /// Own: Filterlist

        CLogFilterList*     iFilterList;

    };

//    

//========================================CLogsGetEventNotify=============================================

// LOCAL FUNCTION PROTOTYPES

// ==================== LOCAL FUNCTIONS ====================

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

CLogsGetEvent::CLogsGetEvent

    (   RFs& aFsSession

    ,   TLogsEventStrings& aStrings

    ,   MLogsObserver* aObserver

    )

    : CActive( EPriorityHigh )

    , iFsSession( aFsSession )

    , iStrings( aStrings )

    , iObserver( aObserver )

    , iState( EStateUndefined )

    , iStaticEmerg( ETrue )

    {

    }

CLogsGetEvent* CLogsGetEvent::NewL

    (   RFs& aFsSession

    ,   TLogsEventStrings& aStrings

    ,   MLogsObserver* aObserver

    )

    {

    CLogsGetEvent* self = new (ELeave) CLogsGetEvent

                                        (   aFsSession

                                        ,   aStrings

                                        ,   aObserver

                                        );

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();  // self

    return self;

    }

void CLogsGetEvent::ConstructL()

    {

    iLogClient = CLogClient::NewL( iFsSession );

    iNotify = CLogsGetEventNotify::NewL( iFsSession, this );    

    iLogEvent = CLogEvent::NewL();

    CLogsEvent* event = CLogsEvent::NewLC( );      

    CleanupStack::Pop(); // event

    iEvent = event;

    iWrapper = CLogsEventGetter::NewL( );   

    if ( FeatureManager::FeatureSupported( KFeatureIdProtocolCdma ) )

        {

        iStaticEmerg = EFalse;

        }

    CActiveScheduler::Add( this );

    }

CLogsGetEvent::~CLogsGetEvent()

    {

    Cancel();

    delete iLogClient;

    delete iLogEvent;

    delete iEvent;

    delete iWrapper;

    delete iNotify;

    }

void CLogsGetEvent::Get( TLogId aId )

    {

    Cancel();

    iLogEvent->SetId( aId );

    iNotify->SetId( aId );

    iLogClient->GetEvent( *iLogEvent, iStatus ); //Get details from db.This is an asynchronous request

    iState = EStateActive;        

    SetActive();

    }

const MLogsEventGetter* CLogsGetEvent::Event()

    {

    return iWrapper->Wrap( iEvent );

    }

const CLogEvent* CLogsGetEvent::LogEvent() const

    {

    return iLogEvent;

    }

void CLogsGetEvent::SetObserver( MLogsObserver* aObserver )

    {

    iObserver = aObserver;      //Observer to indicate when asynchronous retrieval is ok

    }

void CLogsGetEvent::DoCancel()

    {      

    iLogClient->Cancel();

    }

void CLogsGetEvent::RunL()

    {

    ConstructEventL( *iEvent, *iLogEvent );  

    iState = EStateFinished;    

    if( iObserver )

        {

        iObserver->StateChangedL( this ); //Indicate observer: Asynch retrieval is now done 

        }                                 // on CLogsDetailControlContainer::StateChangedL

    }

TInt CLogsGetEvent::RunError(TInt aError)

    {

    if( aError == KErrAccessDenied )

        {

        return KErrNone;

        }

    else

        {

        return aError;

        }

    }

TLogsState CLogsGetEvent::State() const

    {

    return iState;

    }

void CLogsGetEvent::ConstructEventL( MLogsEvent& aDest, const CLogEvent& aSource )

    {

    aDest.InitializeEventL( aSource, iStrings, ELogsDetailModel );

    }

//========================================CLogsGetEventNotify=============================================

//

CLogsGetEventNotify* CLogsGetEventNotify::NewL

    (   RFs& aFsSession

    ,   CLogsGetEvent* aGetEvent

    )

    {

    CLogsGetEventNotify* self = new (ELeave) CLogsGetEventNotify

                                            (   aFsSession

                                            ,   aGetEvent

                                            );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

CLogsGetEventNotify::CLogsGetEventNotify

    (   RFs& aFsSession

    ,   CLogsGetEvent* aGetEvent

    )

    : CActive( EPriorityStandard )

    , iFsSession( aFsSession )

    , iGetEvent( aGetEvent )

    {

    }

void CLogsGetEventNotify::ConstructL()

    {

    iLogClient = CLogClient::NewL( iFsSession );

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

    iFilterList = new ( ELeave ) CLogFilterList;

    iFilterList->AppendL( SetOneFilterLC( KLogShortMessageEventTypeUid ) );

    CleanupStack::Pop();

    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();

    CActiveScheduler::Add( this ); 

    TRAPD( err, iEventView->SetFilterL( *iFilterList, iStatus ) );

    if( err == KErrAccessDenied )

        {

        return;

        }

    User::LeaveIfError( err );

    SetActive();

    }

CLogFilter* CLogsGetEventNotify::SetOneFilterLC( TUid aFilterType )

    {

    CLogFilter* filter = CLogFilter::NewL();

    CleanupStack::PushL( filter );

    filter->SetEventType( aFilterType );

    return filter;

    }

CLogsGetEventNotify::~CLogsGetEventNotify()

    {

    Cancel();     

    delete iEventView;

    delete iLogClient;

    if( iFilterList )

        {

        iFilterList->ResetAndDestroy();

        delete iFilterList;

        iFilterList = NULL;

        }

    }

void CLogsGetEventNotify::DoCancel()

    {     

    if( iEventView )

        {

        iEventView->Cancel();

        }

    if( iLogClient )

        {

        iLogClient->Cancel();

        }

    }

void CLogsGetEventNotify::RunL()

    {

    }

TInt CLogsGetEventNotify::RunError(TInt aError)

    {

    if( aError == KErrAccessDenied )

        {

        return KErrNone;

        }

    else

        {

        return aError;

        }

    }

void CLogsGetEventNotify::HandleLogViewChangeEventAddedL

    (   TLogId /*aId*/

    ,   TInt /*aViewIndex*/

    ,   TInt /*aChangeIndex*/

    ,   TInt /*aTotalChangeCount*/

    )

    {  

    }

void CLogsGetEventNotify::HandleLogViewChangeEventChangedL

    (   TLogId aId

    ,   TInt /*aViewIndex*/

    ,   TInt /*aChangeIndex*/

    ,   TInt aTotalChangeCount

    )

    {   

    if( aTotalChangeCount && ( iId == aId ) )

        {

        iGetEvent->Get( iId );

        }

    }

void CLogsGetEventNotify::HandleLogViewChangeEventDeletedL

    (   TLogId /*aId*/

    ,   TInt /*aViewIndex*/

    ,   TInt /*aChangeIndex*/

    ,   TInt /*aTotalChangeCount*/

    )

    {    

    }

void CLogsGetEventNotify::SetId( TLogId aId )

    {

    iId = aId;

    }

//    

//========================================CLogsGetEventNotify=============================================

//  End of File