/*

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

*

*/

//USER

#include "logsremove.h"

#include "logsmodel.h"

#include "logslogger.h"

#include "logsremoveobserver.h"

#include <logcli.h>

#include <f32file.h>

#include <logview.h>

//SYSTEM

// CONSTANTS

_LIT( KMaxLogsTime, "99991130:235959.999999");

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

//

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

//

LogsRemove::LogsRemove( LogsRemoveObserver& observer, bool readingAllEvents )

: CActive(EPriorityStandard),

  mObserver(observer),

  mReadingAllEvents(readingAllEvents),

  mLogClient(0),

  mRecentView(0)

{

	CActiveScheduler::Add( this );

    mFsSession = new RFs();

}

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

// LogsRemove::~LogsRemove

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

//

LogsRemove::~LogsRemove()

{

    LOGS_QDEBUG( "logs [ENG] <-> LogsRemove::~LogsRemove()" )

    Cancel();

    delete mRecentView;

    delete mLogClient;

    if ( mFsSession ){

        mFsSession->Close();

    }

    delete mFsSession;

}

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

// LogsRemove::RunL

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

//

void LogsRemove::RunL()

{

    LOGS_QDEBUG( "logs [ENG] -> LogsRemove::RunL()->" )

   if (iStatus.Int() == KErrNone){

    	LOGS_QDEBUG( "logs [ENG] -> LogsRemove::RunL() KErrNone" )

    	if ( !DeleteNextEvent() ){

            mObserver.removeCompleted();

    	}

    }

    else {

    	User::Leave( iStatus.Int() );

    	LOGS_QDEBUG( "logs [ENG] -> LogsRemove::RunL() !KErrNone" )

    }

    LOGS_QDEBUG( "logs [ENG] <- LogsRemove::RunL()<-" )

}

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

// LogsRemove::DoCancel

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

//

void LogsRemove::DoCancel()

{

	if ( mLogClient ){

        mLogClient->Cancel();

    }

}

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

// LogsRemove::RunError

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

//

TInt LogsRemove::RunError(TInt aError)

{

	mObserver.logsRemoveErrorOccured(aError);

	return KErrNone;	

}

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

// LogsRemove::init

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

//

int LogsRemove::init()

{

    LOGS_QDEBUG( "logs [ENG] -> LogsRemove::init()" )    

    TRAPD( err, initL() );

    LOGS_QDEBUG_2( "logs [ENG] <- LogsRemove::init(), err:", err )    

    return err;

}

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

// LogsRemove::clearList

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

//

bool LogsRemove::clearList(LogsModel::ClearType cleartype)

{

    LOGS_QDEBUG( "logs [ENG] <- LogsRemove::clearList->" )

    if ( init() != KErrNone ) {

        return false;

    }

    bool clearingStarted(false);

    TTime time( KMaxLogsTime );

    if ( !IsActive() ){

        if (cleartype == LogsModel::TypeLogsClearAll){

            mLogClient->ClearLog( time, iStatus );

        }

        else{

            mLogClient->ClearLog( cleartype, iStatus );

        }

        SetActive();  

        clearingStarted = true;

    } else {

    }

    LOGS_QDEBUG_2( "logs [ENG] <- LogsRemove::clearList, started", clearingStarted )

    return clearingStarted;

}

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

// LogsRemove::initL

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

//

void LogsRemove::initL()

{

    if ( mLogClient ){

        // Already initialized

        return;

    }  

    User::LeaveIfError( mFsSession->Connect() );

    mLogClient = CLogClient::NewL( *mFsSession );

}

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

// LogsRemove::clearEvents

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

//

int LogsRemove::clearEvents(const QList<int>& eventIds, bool& async)

{

    TRAPD( err, clearEventsL(eventIds, async) );

    return err;

}

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

// LogsRemove::clearEventsL

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

//

void LogsRemove::clearEventsL(const QList<int>& eventIds, bool& async)

{

    LOGS_QDEBUG( "logs [ENG] -> LogsRemove::clearEventL()")

    async = false;

    initL();

    if ( mReadingAllEvents ){

        // When all events are read, recent view cannot be used for 

        // event removal.

        Cancel();

        mRemovedEvents = eventIds;

        async = DeleteNextEvent();

    } else {

        if ( !mRecentView ) {

            mRecentView = CLogViewRecent::NewL( *mLogClient );

        }

        foreach( int currId, eventIds ){

            LOGS_QDEBUG_2( "logs [ENG]  Removing, currid: ", currId )

            mRecentView->RemoveL( currId );

        }

        delete mRecentView;

        mRecentView = NULL;

    }

    LOGS_QDEBUG_2( "logs [ENG] <- LogsRemove::clearEventL(): async", async ) 

}

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

// LogsRemove::DeleteNextEvent

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

//

bool LogsRemove::DeleteNextEvent()

{

    bool deleting(false);

    if ( !mRemovedEvents.isEmpty() ){

        int currId = mRemovedEvents.takeFirst();

        LOGS_QDEBUG_2( "logs [ENG]  LogsRemove::DeleteNextEvent, id: ", currId )

        mLogClient->DeleteEvent( currId, iStatus );

        SetActive();

        deleting = true;

    }

    return deleting;  

}

// End of file