--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/locationlandmarksrefappfors60/Src/LandmarksCategoriesEngine.cpp Wed Sep 01 12:31:27 2010 +0100
@@ -0,0 +1,384 @@
+/*
+* 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);
+ }
+
+