/*

* Copyright (c) 2006 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:  This file implements the Location triggering container

*                interface

*

*/

#include "lbtdboperationao.h"

#include "lbtdbtriggersmanager.h"

#include "lbtlogger.h"

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

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

// The Symbian 2 phase constructor

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

//

CLbtDbOperationAO* CLbtDbOperationAO::NewL(

    RDbDatabase& aDb,

    CLbtDbTriggersManager* aObserver)

    {

    CLbtDbOperationAO* self = new( ELeave ) CLbtDbOperationAO(aDb, aObserver);

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// Execute a SQL query asynchronously

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

//

void CLbtDbOperationAO::ExecuteQuery(

    RDbView& aView,

    TDesC& aQuery)

    {

    FUNC_ENTER("CLbtDbOperationAO::ExecuteQuery");

    if (  IsActive() )

        {

        // We are already executing an asynchronous operation so return error

        TRAP_IGNORE( iObserver->DbSqlOperationCompletedL( KErrInUse ) );

        return;

        }

    iView = &aView;

    iView->Prepare( iDb, TDbQuery(aQuery, EDbCompareFolded) );

    iView->Evaluate(iStatus);

    SetActive();

    iOperation = EDbSqlQuery;

    }

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

// CLbtDbOperationAO::ExecuteSyncQuery

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

//

TInt CLbtDbOperationAO::ExecuteSyncQuery(

    RDbView& aView,

    TDesC& aQuery)

    {

    FUNC_ENTER("CLbtDbOperationAO::ExecuteSyncQuery");

    TInt err = aView.Prepare( iDb, TDbQuery(aQuery, EDbCompareFolded),KDbUnlimitedWindow );

    // This should evaluate the query fully

    if ( err == KErrNone )

        {

        err = aView.EvaluateAll();

        }

    return err;

    }

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

// Compact the database

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

//

void CLbtDbOperationAO::CompactDb()

    {

    FUNC_ENTER("CLbtDbOperationAO::CompactDb");

    if (  IsActive() )

        {

        // We are already executing an asynchronous operation so return error

        iObserver->DbIncrementalOperationCompleted( KErrInUse );

        return;

        }

    TInt error = iDbIncrOp.Compact(iDb, iSteps);

    if(error != KErrNone)

    	{

    	ERROR("iDbIncrOp.Compact returned %d", error);

    	iDbIncrOp.Close();

    	return;

    	}

    error = iDbIncrOp.Next( iSteps );

    iStatus = KRequestPending;

    SetActive();

    iOperation = EDbCompaction;

    iStatus = KRequestPending;

    TRequestStatus* status = &iStatus;

    User::RequestComplete(status, error);

    }

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

// DoCancel

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

//

TBool CLbtDbOperationAO::IsCompactionOngoing()

	{

	if( EDbCompaction == iOperation )

		{

		return ETrue;

		}

	return EFalse;

	}

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

// DoCancel

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

//

void CLbtDbOperationAO::DoCancel()

    {

    FUNC_ENTER("CLbtDbOperationAO::DoCancel");

    switch( iOperation )

        {

        case EDbSqlQuery:

            iView->Cancel();

            break;

        case EDbCompaction:

            // Nothing to do here since the step is already completed.

            break;

        default:

            break;

        }

    iOperation = EDbOperationNone;

    }

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

// RunL

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

//

void CLbtDbOperationAO::RunL()

    {

    FUNC_ENTER("CLbtDbOperationAO::RunL");

    switch( iOperation )

        {

        case EDbSqlQuery:

            if ( iStatus.Int() > 0 )

                {

                iView->Evaluate(iStatus);

                SetActive();

                }

            else

                {

                iOperation = EDbOperationNone;

                iObserver->DbSqlOperationCompletedL( iStatus.Int() );

                }

            break;

        case EDbCompaction:

            if ( iStatus.Int() == KErrNone && iSteps )

                {

                // If the steps till now have been successful and if there

                // are more steps to be executed

                TInt error = iDbIncrOp.Next( iSteps );

                iStatus = KRequestPending;

                SetActive();

                TRequestStatus* status = &iStatus;

                User::RequestComplete(status, error);

                }

            else

                {

                // Either the operation was fully completed or

                // there was an error during database compaction.

                // So just close the incremental operation and

                // return the error (in case of the error).

                iDbIncrOp.Close();

                iOperation = EDbOperationNone;

                iObserver->DbIncrementalOperationCompleted( iStatus.Int() );

                }

            break;

        default:

            // Nothing to do in this case

            break;

        }

    }

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

// RunError

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

//

TInt CLbtDbOperationAO::RunError(TInt /*aError*/)

    {

    FUNC_ENTER("CLbtDbOperationAO::RunError");

    // RunL doesn't have any Leaving calls. So no implementation here.

    return KErrNone;

    }

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

// Destructor

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

//

CLbtDbOperationAO::~CLbtDbOperationAO()

    {

    FUNC_ENTER("CLbtDbOperationAO::~CLbtDbOperationAO");

    }

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

// Constructor

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

//

CLbtDbOperationAO::CLbtDbOperationAO(

    RDbDatabase& aDb,

    CLbtDbTriggersManager* aObserver)

    :CActive(CActive::EPriorityStandard),

     iDb(aDb),

     iObserver(aObserver),

     iOperation(EDbOperationNone)

    {

    CActiveScheduler::Add(this);

    }

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

// The 2nd phase Symbian Constructor

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

//

void CLbtDbOperationAO::ConstructL()

    {

    }