/*

* 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 the License "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 logging SAPI deligator class.

*

*/

#include <logwrap.h>

#include <logcli.h>

#include <logview.h>

#include "loggingasyncservice.h"

#include "loggingsyncservice.h"

#include "loggingevent.h"

#include "logiter.h"

/**

* Default Constructor Method

*/

CLogSyncService :: CLogSyncService(): CActive(EPriorityStandard)

    {

    }

/**

* Default Destructor

*/

CLogSyncService :: ~CLogSyncService()

    {

    if(this->IsAdded())

        {

        this->Deque() ;

        }

    delete iLogViewEvents ;

    delete iLogViewRecent ;

    delete iLogClient ;

    delete iWaitScheduler;

    iFs.Close() ;

    }

/**

* Two phased constructor implementation

*/

EXPORT_C CLogSyncService* CLogSyncService :: NewL()

    {

    CLogSyncService* self = CLogSyncService::NewLC();

    CleanupStack::Pop(self);

    return self;

    }

/**

* Two phased constructor implementation

*/

CLogSyncService* CLogSyncService :: NewLC()

    {

    CLogSyncService* self = new (ELeave) CLogSyncService();

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

/**

* This function constructs the member elements of CLogSyncService Class

*/

void CLogSyncService :: ConstructL()

    {

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

    iLogClient = CLogClient::NewL(iFs);

    iLogViewEvents = CLogViewEvent :: NewL(*iLogClient) ;

    iLogViewRecent = CLogViewRecent :: NewL(*iLogClient) ;

    iTaskId  = -1 ;

    iWaitScheduler = new CActiveSchedulerWait();

    DoInitialiseL() ;

    }

/**

* DoInitialise Method, initalises the  members of the class,

* and puts the object in ActiveScheduler List

*/

void CLogSyncService :: DoInitialiseL()

    {

    if(!(this->IsAdded()))

        {

        CActiveScheduler :: Add (this) ;

        }

    }

/**

* RunL method implementation

*/

void CLogSyncService :: RunL()

    {

    iWaitScheduler->AsyncStop();

    }

/**

* DoCancel Implementation

*/

void CLogSyncService :: DoCancel()

    {

     ;

    }

/**

* Reads recent events from the event database

*

* @param aRecentList, recent event list

* @param aFilter, filter for events to appear in the view

* returns the ownership handle to Recentevents in the iter

*/

CLogIter* CLogSyncService :: ReadRecentEventsL( TLogRecentList aRecentList ,

                                                CLogFilter *aFilter )

    {

    CLogIter *iter = CLogIter :: NewL() ;

    CLogClient *logcli = CLogClient :: NewL(iter->GetRFs()) ;

    CLogViewRecent *LogViewRecent  = CLogViewRecent :: NewL(*logcli) ;

    iter->SetLogClient(logcli) ;

    iter->SetLogRecentView(LogViewRecent) ;

    iter->SetTaskId(EGetRecent) ;

    if (LogViewRecent->SetRecentListL(aRecentList, *aFilter, iStatus) )

        {

        // set this active object active to get the events

        // from the main event database, see RunL()

        SetActive();

        iWaitScheduler->Start() ;

        //Wrap the LogViewRecent in iter and return the ownership to

        // the consumer

        iter->SetRecentView(LogViewRecent) ;

        }

    else

        {

        delete iter ;

        iter = NULL ;

        }

    return iter ;

    }

/**

* Adds a new event to the event database

* @param aEvent: Details of the event to be added to the event database

*/

EXPORT_C TLogId  CLogSyncService :: AddL( CLogEvent* aEvent )

    {

    iLogClient->AddEvent( *aEvent , iStatus ) ;

    SetActive() ;

    iWaitScheduler->Start() ;

    if( iStatus.Int() != KRequestPending )

        {

        return aEvent->Id() ;

        }

    return iStatus.Int() ;

    }

/**

* Deletes a event from the event database

* @param aLogId Event id of the event in the database

*/

EXPORT_C TInt CLogSyncService :: Delete( TLogId aLogId )

    {

    if( aLogId > 0 )

        {

        iLogClient->DeleteEvent(aLogId , iStatus) ;

        }

    else

        {

        return KErrNotFound;

        }

    SetActive() ;

    iWaitScheduler->Start();

    return iStatus.Int() ;

    }

/**

* GetList(): Gets the events as specified by filter

*

* @param aFilter, view filter

* Returns the ownership of the iterator for the getlist

* result containing the handle to LogviewEvents.

*/

EXPORT_C CLogIter* CLogSyncService ::  GetListL( CLogFilter *aFilter )

    {

    CLogIter *iter = CLogIter :: NewL() ;

    CLogClient *cli = CLogClient :: NewL(iter->GetRFs()) ;

    CLogViewEvent* LogviewEvents =  CLogViewEvent :: NewL(*cli) ;

    iter->SetLogClient(cli) ;

    iter->SetLogViewEvents(LogviewEvents) ;

    //LogviewEvents->SetFilterL(*aFilter , iStatus) ;

    iter->SetTaskId(EReadEvents) ;

    if(LogviewEvents->SetFilterL(*aFilter , iStatus))

        {

        SetActive() ;

        iWaitScheduler->Start();

        iter->SetLogViewEvents(LogviewEvents);

        return iter ;

        }

    else

        {

        delete iter;

        return NULL;

        }

    }

/**

* Gets the details of the event as specified by the

* input paramater

*

* @param aEvent, details of the event to be fetched

* returns the owner ship of the iter to the consumer

*/

CLogIter* CLogSyncService :: GetEventL( CLogEvent *aEvent )

    {

    CLogIter *iter = CLogIter :: NewL() ;

    iter->SetTaskId(EGetEvent) ;

    CLogClient *cli = CLogClient :: NewL(iter->GetRFs()) ;

    iter->SetLogClient(cli) ;

    cli->GetEvent(*aEvent , iStatus) ;

    SetActive() ;

    iWaitScheduler->Start();

    if(iStatus.Int() != KErrNone)

        {

        delete iter ;

        return NULL ;

        }

    return  iter ;

    }