/*

* Copyright (c) 2004-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:  Implements the CLandmarksEngine class

*

*/

#include <aknview.h>

#include <EPos_CPosLandmarkDatabase.h>

#include <EPos_CPosLmPartialReadParameters.h>

#include <EPos_CPosLandmarkSearch.h>

#include <EPos_CPosLmTextCriteria.h>

#include "LandmarksEngine.h"

#include "LandmarksLmOpWrapper.h"

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

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

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

//

CLandmarksEngine::CLandmarksEngine(

    CPosLandmarkDatabase& aDb) 

:   CLandmarksEngineBase(aDb),

    iSortPref(CPosLandmark::ELandmarkName, TPosLmSortPref::EAscending)

    {

    }

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

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

//

void CLandmarksEngine::ConstructL()

    {

    CLandmarksEngineBase::ConstructL();

    // Set partial read parameters

    CPosLmPartialReadParameters* partialReadParams = 

        CPosLmPartialReadParameters::NewLC();

    partialReadParams->SetRequestedAttributes(

        CPosLandmark::ELandmarkName | CPosLandmark::EIcon);

    iDb.SetPartialReadParametersL(*partialReadParams);

    CleanupStack::PopAndDestroy(partialReadParams);

    }

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

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

//

CLandmarksEngine* CLandmarksEngine::NewL(

    CPosLandmarkDatabase& aDb)

    {

    CLandmarksEngine* self = new (ELeave) CLandmarksEngine(aDb);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

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

//

CLandmarksEngine::~CLandmarksEngine()

    {

    Cancel();

    iItemIds.Close();

    }

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

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

//

TBool CLandmarksEngine::StartInitializeDbIfNecessaryL(

    MLandmarksOperationObserver* aObserver)

    {

    if (iDb.IsInitializingNeeded())

        {

        // Create initialize operation

        CPosLmOperation* operation = iDb.InitializeL();

        iObserver = aObserver;

        iActiveOperation = EInitializeDb;

        iStatus = KRequestPending;

        SetPriorityAndSetActive();

        // Start asynchronous initialization

        TBool reportProgress = ETrue;

        iLmOpWrapper->StartOperation(operation, iStatus, reportProgress);

        return ETrue;

        }

    else

        {

        return EFalse;

        }

    }

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

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

//

void CLandmarksEngine::AddLandmarkL(CPosLandmark& aLandmark)

    {

    iDb.AddLandmarkL(aLandmark);

    }

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

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

//

void CLandmarksEngine::CommitLandmarkL(const CPosLandmark& aLandmark)

    {

    iDb.UpdateLandmarkL(aLandmark);

    }

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

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

//

void CLandmarksEngine::DeleteLandmarkL(TPosLmItemId aItemId)

    {

    iDb.RemoveLandmarkL(aItemId);

    }

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

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

//

CPosLandmark* CLandmarksEngine::LandmarkLC(TPosLmItemId aItemId)

    {

    return iDb.ReadLandmarkLC(aItemId);

    }

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

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

//

void CLandmarksEngine::StartSearchingLandmarksL(

    MLandmarksOperationObserver* aObserver)

    {

    // We need to cancel if we are searching/reading landmarks.

    Cancel(); 

    iObserver = aObserver;

    iSearchResultExists = EFalse;

    iFilterSearch = EFalse;

    // Complete ourselves and start search for all landmarks in db in RunL().

    iStatus = KRequestPending;

    SetPriorityAndSetActive();

    iActiveOperation = ELandmarkSearch;

    TRequestStatus* status = &iStatus;

    User::RequestComplete(status, KErrNone);

    }

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

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

//

void CLandmarksEngine::StartSearchingLandmarksL(

    const TDesC& aSearchPattern, 

    TBool aSearchOnlyInPreviousMatches,

    MLandmarksOperationObserver* aObserver)

    {

    // We need to cancel if we are searching/reading landmarks.

    Cancel();

    if (!iSearchResultExists)

        {

        // There are no previous results or previous search did not complete.

        // We cannot use the result from it.

        aSearchOnlyInPreviousMatches = EFalse;

        }

    iSearchResultExists = EFalse;

    iFilterSearch = ETrue;

    // Set search criteria

    CPosLmTextCriteria* criteria = CPosLmTextCriteria::NewLC();

    criteria->SetTextL(aSearchPattern);

    criteria->SetAttributesToSearch(CPosLandmark::ELandmarkName);

    // Create search operation

    CPosLmOperation* operation = iSearcher->StartLandmarkSearchL(

        *criteria, iSortPref, aSearchOnlyInPreviousMatches);

    CleanupStack::PopAndDestroy(criteria);

    // Start search operation

    iObserver = aObserver;

    iStatus = KRequestPending;

    iLmOpWrapper->StartOperation(operation, iStatus);

    SetPriorityAndSetActive();

    iActiveOperation = ELandmarkSearch;

    }

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

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

//

RArray<TPosLmItemId>* CLandmarksEngine::FetchSearchResult()

    {

    return &iItemIds;

    }

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

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

//

void CLandmarksEngine::StartReadingLandmarksL(

    TInt aNrOfItemsToReadPerBundle,

    MLandmarksOperationObserver* aObserver)

    {

    // We need to cancel if we are searching/reading landmarks.

    Cancel();

    iNrOfItemsToRead = aNrOfItemsToReadPerBundle;

    iObserver = aObserver;

    iCurrentItemId = 0;

    // Start reading a bundle of landmarks

    ReadSomeLandmarksL();

    iActiveOperation = ELandmarkRead;

    }

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

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

//

CArrayPtr<CPosLandmark>* CLandmarksEngine::FetchLandmarksLC()

    {

    // Fetch the partially read landmarks.

    CArrayPtr<CPosLandmark>* result = 

        iDb.TakePreparedPartialLandmarksL(iLmOpWrapper->LmOperationPtr());

    CleanupStack::PushL(result);

    return result;

    }

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

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

//

void CLandmarksEngine::RunL()

    {

    if (iActiveOperation == EInitializeDb)

        {

        // Report progress

        iObserver->NotifyOperationProgressL(

            iActiveOperation, iLmOpWrapper->Progress(), iStatus.Int());

        if (iStatus == KPosLmOperationNotComplete)

            {

            // Continue initializing database until finished

            iStatus = KRequestPending;

            SetPriorityAndSetActive();

            iLmOpWrapper->ExecuteNextStep(iStatus);

            }

        }

    else if (iStatus != KErrNone)

        {

        // Operation failed. Report error code

        NotifyOperationReadyL(iActiveOperation, iStatus.Int());

        }

    else if (iActiveOperation == ELandmarkSearch)

        {

        // Fetch search result

        PopulateItemIdArrayL();

        }

    else if (iActiveOperation == ELandmarkRead)

        {

        if (iCurrentItemId < iItemIds.Count())

            {

            // There are still found landmarks to read

            iObserver->NotifyOperationProgressL(iActiveOperation, KOperationNotReady, KErrNone);

            ReadSomeLandmarksL();

            }

        else

            {

            // No more matches to read

            NotifyOperationReadyL(iActiveOperation, KErrNone);

            }

        }

    }

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

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

//

void CLandmarksEngine::DoCancel()

    {

    iLmOpWrapper->Cancel();

    if (iActiveOperation == ELandmarkSearch)

        {

        iSearchResultExists = EFalse;

        }

    iActiveOperation = ENoOperation;

    }

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

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

//

TInt CLandmarksEngine::RunError(TInt aError)

    {

    // Notify user and ignore error code

    TInt err;

    TRAP(err, NotifyOperationReadyL(iActiveOperation, aError));

    return KErrNone;

    }

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

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

//

void CLandmarksEngine::ReadSomeLandmarksL()

    {

    RArray<TPosLmItemId> subSetOfIds;

    CleanupClosePushL(subSetOfIds);

    // Create a subset of the found matches to read

    TInt nrOfMatches = iItemIds.Count();

    TInt i = 0;

    while (i < iNrOfItemsToRead && iCurrentItemId < nrOfMatches)

        {

        User::LeaveIfError(subSetOfIds.Append(iItemIds[iCurrentItemId]));

        iCurrentItemId++;

        i++;

        }

    // Start reading subset of found matches

    iStatus = KRequestPending;

    CPosLmOperation* operation = iDb.PreparePartialLandmarksL(subSetOfIds);

    iLmOpWrapper->StartOperation(operation, iStatus);

    SetPriorityAndSetActive();

    CleanupStack::PopAndDestroy(&subSetOfIds);

    }

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

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

//

void CLandmarksEngine::NotifyOperationReadyL(

    TOperation aOperation, 

    TInt aErrorCode)

    {

    iActiveOperation = ENoOperation;

    iObserver->NotifyOperationProgressL(

        aOperation, 

        KOperationReady, 

        aErrorCode);

    }

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

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

//

void CLandmarksEngine::PopulateItemIdArrayL()

    {

    // Fetch itemIterator

    CPosLmItemIterator* itemIterator = NULL;

    if (iFilterSearch)

        {

        itemIterator = iSearcher->MatchIteratorL();

        iSearchResultExists = ETrue;

        }

    else

        {

        itemIterator = iDb.LandmarkIteratorL(iSortPref);

        }

    CleanupStack::PushL(itemIterator);

    itemIterator->Reset();

    // Fetch iItemIds

    TUint nrOfItems = itemIterator->NumOfItemsL();

    if (nrOfItems > 0)

        {

        TInt startIndex = 0;

        iItemIds.Reset();

        itemIterator->GetItemIdsL(iItemIds, startIndex, nrOfItems);

        NotifyOperationReadyL(iActiveOperation, KErrNone);

        }

    else

        {

        // No matches found

        NotifyOperationReadyL(iActiveOperation, KErrNotFound);

        }

    CleanupStack::PopAndDestroy(itemIterator);

    }