/*

* 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:  Implementation of CLandmarksCategoriesEngine

*

*/

#include <EPos_CPosLandmarkDatabase.h>

#include <EPos_CPosLmCatNameCriteria.h>

#include <EPos_CPosLandmarkSearch.h>

#include <EPos_CPosLmCategoryManager.h>

#include "LandmarksCategoriesEngine.h"

#include "LandmarksLmOpWrapper.h"

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

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

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

//

CLandmarksCategoriesEngine::CLandmarksCategoriesEngine(

    CPosLandmarkDatabase& aDb)

:   CLandmarksEngineBase(aDb)

    {

    }

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

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

//

void CLandmarksCategoriesEngine::ConstructL()

    {

    CLandmarksEngineBase::ConstructL();

    iCatManager = CPosLmCategoryManager::NewL(iDb);

    }

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

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

//

CLandmarksCategoriesEngine* CLandmarksCategoriesEngine::NewL(

    CPosLandmarkDatabase& aDb)

    {

    CLandmarksCategoriesEngine* self = 

        new (ELeave) CLandmarksCategoriesEngine(aDb);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

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

//

CLandmarksCategoriesEngine::~CLandmarksCategoriesEngine()

    {

    Cancel();

    delete iCatManager;

    iSubSetOfIds.Close();

    iItemIds.Close();

    }

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

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

//

void CLandmarksCategoriesEngine::AddCategoryL(CPosLandmarkCategory& aCategory)

    {

    iCatManager->AddCategoryL(aCategory);

    }

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

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

//

void CLandmarksCategoriesEngine::UpdateCategoryL(const CPosLandmarkCategory& aCategory)

    {

    iCatManager->UpdateCategoryL(aCategory);

    }

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

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

//

void CLandmarksCategoriesEngine::DeleteCategoryL(TPosLmItemId aItemId)

    {

    ExecuteAndDeleteLD(iCatManager->RemoveCategoryL(aItemId));

    }

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

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

//

CPosLandmarkCategory* CLandmarksCategoriesEngine::CategoryLC(TPosLmItemId aItemId)

    {

    return iCatManager->ReadCategoryLC(aItemId);

    }

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

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

//

void CLandmarksCategoriesEngine::StartSearchingCategoriesL(

    MLandmarksOperationObserver* aObserver)

    {

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

    Cancel();

    iObserver = aObserver;

    iSearchResultExists = EFalse;

    iFilterSearch = EFalse;

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

    iStatus = KRequestPending;

    SetPriorityAndSetActive();

    iActiveOperation = ECategorySearch;

    TRequestStatus* status = &iStatus;

    User::RequestComplete(status, KErrNone);

    }

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

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

//

void CLandmarksCategoriesEngine::StartSearchingCategoriesL(

    const TDesC& aSearchPattern, 

    TBool aSearchOnlyInPreviousMatches,

    MLandmarksOperationObserver* aObserver)

    {

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

    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

    CPosLmCatNameCriteria* criteria = CPosLmCatNameCriteria::NewLC();

    criteria->SetSearchPatternL(aSearchPattern);

    // Create search operation

    CPosLmOperation* operation = iSearcher->StartCategorySearchL(

        *criteria, 

        CPosLmCategoryManager::ECategorySortOrderNameAscending, 

        aSearchOnlyInPreviousMatches);

    CleanupStack::PopAndDestroy(criteria);

    // Start search operation

    iObserver = aObserver;

    iStatus = KRequestPending;

    iLmOpWrapper->StartOperation(operation, iStatus);

    SetPriorityAndSetActive();

    iActiveOperation = ECategorySearch;

    }

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

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

//

RArray<TPosLmItemId>* CLandmarksCategoriesEngine::FetchSearchResult()

    {

    return &iItemIds;

    }

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

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

//

void CLandmarksCategoriesEngine::StartReadingCategoriesL(

    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 categories

    ReadSomeCategoriesL();

    iActiveOperation = ECategoryRead;

    }

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

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

//

CArrayPtr<CPosLandmarkCategory>* CLandmarksCategoriesEngine::FetchCategoriesLC()

    {

    TInt nrOfItems = iSubSetOfIds.Count();

    CArrayPtr<CPosLandmarkCategory>* categories = 

        new (ELeave) CArrayPtrFlat<CPosLandmarkCategory>(nrOfItems);

    CleanupStack::PushL(categories);

    // Start the actual read of landmarks. This is done synchronously since 

    // there is no asynchronous read method as there is for landmarks:

    // (Compare TakePreparedPartialLandmarksL()) 

    for (TInt i = 0; i < nrOfItems; i++)

        {

        CPosLandmarkCategory* category = 

            iCatManager->ReadCategoryLC(iSubSetOfIds[i]);

        categories->AppendL(category);

        CleanupStack::Pop(category);

        }

    return categories;

    }

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

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

//

CArrayPtr<CPosLandmarkCategory>* CLandmarksCategoriesEngine::CategoriesL()

    {

    const TInt KGranularity = 8;

    CArrayPtrFlat<CPosLandmarkCategory>* categories = 

        new (ELeave) CArrayPtrFlat<CPosLandmarkCategory>(KGranularity);

    CleanupStack::PushL(categories);

    // Get an iterator for all existing categories sorted ascending by name

    CPosLmItemIterator* itemIterator = iCatManager->CategoryIteratorL(

        CPosLmCategoryManager::ECategorySortOrderNameAscending);

    CleanupStack::PushL(itemIterator);

    // Read all categories and add them to an array

    TPosLmItemId catId = itemIterator->NextL();

    while (catId != KPosLmNullItemId)

        {

        CPosLandmarkCategory* category = iCatManager->ReadCategoryLC(catId);

        categories->AppendL(category);

        CleanupStack::Pop(category);

        catId = itemIterator->NextL();

        }

    CleanupStack::PopAndDestroy(itemIterator);

    CleanupStack::Pop(categories);

    return categories;

    }

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

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

//

void CLandmarksCategoriesEngine::RunL()

    {

    if (iStatus == KErrNone)

        {

        if (iActiveOperation == ECategorySearch)

            {

            // Fetch search result

            PopulateItemIdArrayL();

            }

        else if (iActiveOperation == ECategoryRead)

            {

            if (iCurrentItemId < iItemIds.Count())

                {

                // There are still found landmarks to read

                iObserver->NotifyOperationProgressL(

                    iActiveOperation, KOperationNotReady, KErrNone);

                ReadSomeCategoriesL();

                }

            else

                {

                // No more matches to read

                NotifyOperationReadyL(iActiveOperation, KErrNone);

                }

            }

        }

    else

        {

        // Operation failed. Forward error code

        NotifyOperationReadyL(iActiveOperation, iStatus.Int());

        }

    }

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

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

//

void CLandmarksCategoriesEngine::DoCancel()

    {

    iLmOpWrapper->Cancel();

    if (iActiveOperation == ECategorySearch)

        {

        iSearchResultExists = EFalse;

        }

    iActiveOperation = ENoOperation;

    }

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

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

//

TInt CLandmarksCategoriesEngine::RunError(TInt aError)

    {

    // Notify user and ignore error code

    TInt err;

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

    return KErrNone;

    }

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

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

//

void CLandmarksCategoriesEngine::ReadSomeCategoriesL()

    {

    // Create a subset of the found matches to read

    iSubSetOfIds.Reset();

    TInt nrOfMatches = iItemIds.Count();

    TInt i = 0;

    while (i < iNrOfItemsToRead && iCurrentItemId < nrOfMatches)

        {

        User::LeaveIfError(

            iSubSetOfIds.Append(iItemIds[iCurrentItemId]));

        iCurrentItemId++;

        i++;

        }

    // Simulate start reading found matches. There is no asynchronous search 

    // functionality for categories as there is for landmarks, 

    // (Compare PreparePartialLandmarksL())

    iStatus = KRequestPending;

    SetPriorityAndSetActive();

    TRequestStatus* status = &iStatus;

    User::RequestComplete(status, KErrNone);

    }

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

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

//

void CLandmarksCategoriesEngine::NotifyOperationReadyL(

    TOperation aOperation, 

    TInt aErrorCode)

    {

    iActiveOperation = ENoOperation;

    iObserver->NotifyOperationProgressL(

        aOperation, 

        KOperationReady, 

        aErrorCode);

    }

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

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

//

void CLandmarksCategoriesEngine::PopulateItemIdArrayL()

    {

    // Fetch itemIterator

    CPosLmItemIterator* itemIterator = NULL;

    if (iFilterSearch)

        {

        itemIterator = iSearcher->MatchIteratorL();

        iSearchResultExists = ETrue;

        }

    else

        {

        itemIterator = iCatManager->CategoryIteratorL(

            CPosLmCategoryManager::ECategorySortOrderNameAscending);

        }

    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);

    }