/*

* Copyright (c) 2005 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: Operation to search for landmarks or landmark categories from 

*							 multiple databases

*

*

*/

// INCLUDE FILES

#include    <e32std.h>

#include    <e32debug.h>

#include    <EPos_Landmarks.h>

#include    <EPos_LandmarksErrors.h>

#include    <EPos_CPosLandmarkSearch.h>

#include    <EPos_CPosLmSearchCriteria.h>

#include    <EPos_CPosLmMultiDbSearch.h>

#include    "EPos_CPosLmMultiDbSearchOperation.h"

#include    "EPos_CPosLmActiveOperation.h"

#include    "EPos_PosLmCriteriaHelper.h"

// CONSTANTS

const TReal32 KPosProgressShareOpenDbs          = 0.05;

const TReal32 KPosProgressShareInitDbs          = 0.10;

const TReal32 KPosProgressShareCreateSearchOps  = 0.05;

const TReal32 KPosProgressShareSearchDbs        = 0.80;

const TReal32 KPosProgressComplete              = 1.0;

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

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

// CPosLmMultiDbSearchOperation::CPosLmMultiDbSearchOperation

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

// might leave.

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

//

CPosLmMultiDbSearchOperation::CPosLmMultiDbSearchOperation(

    CPosLmMultiDbSearch* aMultiDbSearch,

    TBool aSearchOnlyPreviousMatches)

    : iMultiDbSearch(aMultiDbSearch),

    iSearchOnlyPreviousMatches(aSearchOnlyPreviousMatches),

    iOperationStatus(EOperationNotStarted),

    iSearchStatus(ESearchNotStarted)

    {

    }

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

// CPosLmMultiDbSearchOperation::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CPosLmMultiDbSearchOperation::ConstructL(

    const CPosLmSearchCriteria& aCriteria,

    CPosLmMultiDbSortPref* aSortPref)

    {

    TBool isLmSearch =

        aSortPref->SortType() != CPosLmMultiDbSortPref::ECategorySorting;

    TBool useDistanceSorting;

    iCriteria = PosLmCriteriaHelper::ValidateAndCopyL(

        aCriteria, isLmSearch, useDistanceSorting);

    if (useDistanceSorting &&

        aSortPref->SortType() == CPosLmMultiDbSortPref::ELandmarkNoSorting)

        {

        aSortPref->SetDistanceSorting();

        }

    iSortPref = aSortPref;

    }

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

// CPosLmMultiDbSearchOperation::NewL

// Two-phased constructor.

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

//

CPosLmMultiDbSearchOperation* CPosLmMultiDbSearchOperation::NewL(

    CPosLmMultiDbSearch* aMultiDbSearch,

    const CPosLmSearchCriteria& aCriteria,

    CPosLmMultiDbSortPref* aSortPref,

    TBool aSearchOnlyPreviousMatches)

    {

    CPosLmMultiDbSearchOperation* self = new (ELeave)

        CPosLmMultiDbSearchOperation(aMultiDbSearch,

            aSearchOnlyPreviousMatches);

    CleanupStack::PushL(self);

    self->ConstructL(aCriteria, aSortPref);

    CleanupStack::Pop(self);

    return self;

    }

// Destructor

CPosLmMultiDbSearchOperation::~CPosLmMultiDbSearchOperation()

    {

    if (iClientStatus)

        {

        User::RequestComplete(iClientStatus, KErrCancel);

        }

    if (iMultiDbSearch)

        {

        iMultiDbSearch->HandleSearchOperationCompleted();

        }

    delete iCriteria;

    delete iSortPref;

    iActiveOperations.ResetAndDestroy();

    }

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

// CPosLmMultiDbSearchOperation::HandleMultiDbSearchDeleted

//

// (other items were commented in a header).

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

//

void CPosLmMultiDbSearchOperation::HandleMultiDbSearchDeleted()

    {

    iMultiDbSearch = NULL;

    }

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

// CPosLmMultiDbSearchOperation::OperationCallBack

//

// (other items were commented in a header).

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

//

TInt CPosLmMultiDbSearchOperation::OperationCallBack(TAny* aPtr)

    {

    CPosLmActiveOperation* activeOp = static_cast<CPosLmActiveOperation*>(aPtr);

    CPosLmMultiDbSearchOperation* thisOp =

        static_cast<CPosLmMultiDbSearchOperation*>(activeOp->Owner());

    return thisOp->DoOperationCallBack(activeOp);

    }

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

// CPosLmMultiDbSearchOperation::NextStep

//

// (other items were commented in a header).

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

//

void CPosLmMultiDbSearchOperation::NextStep(

    TRequestStatus& aStatus,

    TReal32& aProgress)

    {

    if (iOperationStatus == ESyncStarted ||

        iOperationStatus == EOperationCompleted ||

        iClientStatus)

        {

        Panic(KPosLandmarksClientPanic, EPosInvalidOperationMode);

        }

    iOperationStatus = EAsyncStarted;

    aStatus = KRequestPending;

    aProgress = iProgress;

    iClientStatus = &aStatus;

    iClientProgress = &aProgress;

    // We can't continue if client has deleted iMultiDbSearch.

    if (!iMultiDbSearch)

        {

        CompleteClientRequest();

        return;

        }

    if (iSearchStatus == ESearchNotStarted)

        {

        IncrementSearchStep();

        }

    if (iSearchStatus == EInitDbs || iSearchStatus == ESearchDbs)

        {

        ExecuteAsyncStep();

        }

    else

        {

        ExecuteSyncStep();

        IncrementSearchStep();

        CompleteClientRequest();

        }

    }

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

// CPosLmMultiDbSearchOperation::ExecuteL

//

// (other items were commented in a header).

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

//

void CPosLmMultiDbSearchOperation::ExecuteL()

    {

    if (iOperationStatus != EOperationNotStarted)

        {

        Panic(KPosLandmarksClientPanic, EPosInvalidOperationMode);

        }

    iOperationStatus = ESyncStarted;

    // We can't continue if client has deleted iMultiDbSearch.

    if (!iMultiDbSearch)

        {

        return;

        }

    while (iCurrentDbIndex < iMultiDbSearch->NumOfDatabasesToSearch())

        {

        if (iMultiDbSearch->ToBeSearched(iCurrentDbIndex))

            {

            ExecuteSyncStep();

            }

        iCurrentDbIndex++;

        }

    iOperationStatus = EOperationCompleted;

    HandleOperationCompleted();

    }

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

// CPosLmMultiDbSearchOperation::HandleOperationCompleted

//

// (other items were commented in a header).

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

//

void CPosLmMultiDbSearchOperation::HandleOperationCompleted()

    {

    if (iMultiDbSearch)

        {

        iMultiDbSearch->HandleSearchOperationCompleted();

        iMultiDbSearch = NULL;

        }

    }

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

// CPosLmMultiDbSearchOperation::CompleteClientRequest

//

// (other items were commented in a header).

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

//

void CPosLmMultiDbSearchOperation::CompleteClientRequest()

    {

    if (!iClientStatus)

        {

        return;

        }

    if (!iMultiDbSearch)

        {

        iSearchStatus = ESearchCompleted;

        }

    TInt status = KPosLmOperationNotComplete;

    if (iSearchStatus == ESearchCompleted)

        {

        status = KErrNone;

        iOperationStatus = EOperationCompleted;

        HandleOperationCompleted();

        }

    CalculateProgress();

    *iClientProgress = iProgress;

    User::RequestComplete(iClientStatus, status);

    }

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

// CPosLmMultiDbSearchOperation::IncrementSearchStep

//

// (other items were commented in a header).

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

//

void CPosLmMultiDbSearchOperation::IncrementSearchStep()

    {

    IncrementIndexAndSearchStatus();

    while (((iSearchStatus == EOpenDbs || iSearchStatus == ECreateSearchOps) &&

            !iMultiDbSearch->ToBeSearched(iCurrentDbIndex)) ||

           ((iSearchStatus == EInitDbs || iSearchStatus == ESearchDbs) &&

            iActiveOperations.Count() == 0))

        {

        IncrementIndexAndSearchStatus();

        }

    }

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

// CPosLmMultiDbSearchOperation::IncrementIndexAndSearchStatus

//

// (other items were commented in a header).

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

//

void CPosLmMultiDbSearchOperation::IncrementIndexAndSearchStatus()

    {

    switch (iSearchStatus)

        {

        case ESearchNotStarted:

        case EInitDbs:

        case ESearchDbs:

            iCurrentDbIndex = 0;

            IncrementSearchStatus();

            break;

        case EOpenDbs:

        case ECreateSearchOps:

            iCurrentDbIndex++;

            if (iCurrentDbIndex == iMultiDbSearch->NumOfDatabasesToSearch())

                {

                iCurrentDbIndex = 0;

                IncrementSearchStatus();

                }

            break;

        }

    }

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

// CPosLmMultiDbSearchOperation::IncrementSearchStatus

//

// (other items were commented in a header).

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

//

void CPosLmMultiDbSearchOperation::IncrementSearchStatus()

    {

    switch (iSearchStatus)

        {

        case ESearchNotStarted:

            iSearchStatus = EOpenDbs;

            break;

        case EOpenDbs:

            iSearchStatus = EInitDbs;

            break;

        case EInitDbs:

            iSearchStatus = ECreateSearchOps;

            break;

        case ECreateSearchOps:

            iSearchStatus = ESearchDbs;

            break;

        case ESearchDbs:

            iSearchStatus = ESearchCompleted;

            break;

        }

    }

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

// CPosLmMultiDbSearchOperation::ExecuteSyncStep

//

// (other items were commented in a header).

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

//

void CPosLmMultiDbSearchOperation::ExecuteSyncStep()

    {

    TRAPD(error, ExecuteSyncStepL());

    if (error != KErrNone)

        {

        iMultiDbSearch->AddSearchError(iCurrentDbIndex, error);

        }

    }

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

// CPosLmMultiDbSearchOperation::ExecuteSyncStepL

//

// (other items were commented in a header).

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

//

void CPosLmMultiDbSearchOperation::ExecuteSyncStepL()

    {

    CPosLmOperation* initOp;

    if (iOperationStatus == ESyncStarted)

        {

        initOp = OpenDbAndCreateInitOpL();

        if (initOp)

            {

            ExecuteAndDeleteLD(initOp);

            }

        ExecuteAndDeleteLD(CreateSearchOpL());

        iMultiDbSearch->SearchExecutedL(iCurrentDbIndex, *iSortPref);

        }

    else

        {

        switch (iSearchStatus)

            {

            case EOpenDbs:

                initOp = OpenDbAndCreateInitOpL();

                if (initOp)

                    {

                    AppendAsActiveOperationL(initOp);

                    }

                break;

            case ECreateSearchOps:

                AppendAsActiveOperationL(CreateSearchOpL());

                break;

            default:

                break;

            }

        }

    }

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

// CPosLmMultiDbSearchOperation::OpenDbAndCreateInitOpL

//

// (other items were commented in a header).

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

//

CPosLmOperation* CPosLmMultiDbSearchOperation::OpenDbAndCreateInitOpL()

    {

    CPosLandmarkDatabase* db = iMultiDbSearch->DatabaseL(iCurrentDbIndex);

    CPosLmOperation* initOp = NULL;

    if (db->IsInitializingNeeded())

        {

        initOp = db->InitializeL();

        }

    return initOp;

    }

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

// CPosLmMultiDbSearchOperation::CreateSearchOpL

//

// (other items were commented in a header).

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

//

CPosLmOperation* CPosLmMultiDbSearchOperation::CreateSearchOpL()

    {

    CPosLandmarkSearch* searcher = iMultiDbSearch->SearcherL(iCurrentDbIndex);

    CPosLmOperation* searchOp;

    if (iSortPref->SortType() == CPosLmMultiDbSortPref::ECategorySorting)

        {

        searchOp = searcher->StartCategorySearchL(

            *iCriteria, iSortPref->CategorySortPref(),

            iSearchOnlyPreviousMatches);

        }

    else if (iSortPref->SortType() == CPosLmMultiDbSortPref::ELandmarkSorting)

        {

        searchOp = searcher->StartLandmarkSearchL(

            *iCriteria, iSortPref->LandmarkSortPref(),

            iSearchOnlyPreviousMatches);

        }

    else

        {

        searchOp = searcher->StartLandmarkSearchL(

            *iCriteria, iSearchOnlyPreviousMatches);

        }

    iMultiDbSearch->SearchStarted(iCurrentDbIndex);

    return searchOp;

    }

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

// CPosLmMultiDbSearchOperation::AppendAsActiveOperationL

//

// (other items were commented in a header).

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

//

void CPosLmMultiDbSearchOperation::AppendAsActiveOperationL(

    CPosLmOperation* aOperation)

    {

    CleanupStack::PushL(aOperation);

    CPosLmActiveOperation* activeOp =

        CPosLmActiveOperation::NewL(aOperation, iCurrentDbIndex, this);

    CleanupStack::Pop(aOperation);

    CleanupStack::PushL(activeOp);

    iActiveOperations.AppendL(activeOp);

    CleanupStack::Pop(activeOp);

    }

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

// CPosLmMultiDbSearchOperation::ExecuteAsyncStep

//

// (other items were commented in a header).

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

//

void CPosLmMultiDbSearchOperation::ExecuteAsyncStep()

    {

    for (TInt i = 0; i < iActiveOperations.Count(); i++)

        {

        CPosLmActiveOperation* activeOp = iActiveOperations[i];

        if (!activeOp->IsActive())

            {

            TCallBack callback(OperationCallBack, activeOp);

            activeOp->ExecuteStep(callback);

            }

        }

    }

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

// CPosLmMultiDbSearchOperation::DoOperationCallBack

//

// (other items were commented in a header).

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

//

TInt CPosLmMultiDbSearchOperation::DoOperationCallBack(

    CPosLmActiveOperation* aActiveOp)

    {

    // We can't continue if client has deleted iMultiDbSearch.

    if (!iMultiDbSearch)

        {

        CompleteClientRequest();

        return 0;

        }

    TInt status = aActiveOp->Status();

    if (status != KErrNone && status != KPosLmOperationNotComplete)

        {