FCL/sf/app/contacts: comparison predictivesearch/PcsAlgorithm/Algorithm2/src/CPcsAlgorithm2.cpp

equal deleted inserted replaced

-:6b5524b4f673
+:38bb213f60ba
 * Description: Predictive Contact Search Algorithm 1 main class
 *
 */
 // INCLUDES
-#include <vpbkeng.rsg>
+#include <VPbkEng.rsg>
 #include <PtiEngine.h>
 #include <centralrepository.h>
 #include <AknFepInternalCRKeys.h>
 #include "CPcsAlgorithm2.h"
 iCacheStatus = ECachingNotStarted; // Starting status
 iCacheError = KErrNone; // No error
 iCacheCount = 0; // No data
 iFindUtilECE = CFindUtilChineseECE::NewL(this);
+iFindUtil = CFindUtil::NewL();
 iPluginLauncher = CIdle::NewL( CActive::EPriorityStandard );
 // Define cache status property used to inform clients about the caching status.
 DefinePropertyL( EPsKeyCacheStatus );
 DefinePropertyL( EPsKeyContactModifiedCounter );
 DefinePropertyL( EPsKeyContactAddedCounter );
 // Initialize key map and pti engine
 TInt keyMapErr = KErrNone;
-TRAP( keyMapErr, iKeyMap = CPcsKeyMap::NewL( this ) );
+TRAP( keyMapErr, iKeyMap = CPcsKeyMap::NewL( this ));
 if (keyMapErr != KErrNone)
 {
 PRINT ( _L("**********************************************."));
 PRINT1 ( _L("CPcsAlgorithm2::ConstructL() KeyMap construction error. The keymap crashed with error code %d."), keyMapErr );
 PRINT ( _L("Please check the keypad/language for which keymap got crashed.") );
 PRINT ( _L("**********************************************."));
-User::Leave( keyMapErr ); // we can't go on without a key map; constructing cache needs it
 }
 // Initialize helpers
 iHelper = CPcsAlgorithm2Helper::NewL(this);
 iMultiSearchHelper = CPcsAlgorithm2MultiSearchHelper::NewL(this);
 // Cleanup helpers
 delete iHelper;
 delete iMultiSearchHelper;
 delete iFindUtilECE;
+delete iFindUtil;
 delete iPluginLauncher;
 PRINT ( _L("End CPcsAlgorithm2::~CPcsAlgorithm2") );
 }
 User::LeaveIfError(err);
 }
 }
 // ----------------------------------------------------------------------------
-// CPcsAlgorithm2::RemoveSpacesL
-// Remove leading and trailing spaces of search query
-// ----------------------------------------------------------------------------
-void  CPcsAlgorithm2::RemoveSpacesL(CPsQuery& aQuery)
-{
-PRINT ( _L("Enter CPcsAlgorithm2::RemoveSpacesL") );
-// Remove all leading " "
-while ( aQuery.Count() > 0 )
-{
-CPsQueryItem& item = aQuery.GetItemAtL(0); // First
-if ( !item.Character().IsSpace() )
-{
-break;
-}
-aQuery.Remove(0);
-}
-// Remove all trailing " "
-while ( aQuery.Count() > 0 )
-{
-CPsQueryItem& item = aQuery.GetItemAtL(aQuery.Count()-1); // Last
-if ( !item.Character().IsSpace() )
-{
-break;
-}
-aQuery.Remove(aQuery.Count()-1);
-}
-PRINT ( _L("End CPcsAlgorithm2::RemoveSpacesL") );
-}
-// ----------------------------------------------------------------------------
 // CPcsAlgorithm2::ReplaceZeroWithSpaceL
 // Replace first occurance of '0' in a sequence of '0's in ITU-T with space
 // ----------------------------------------------------------------------------
 TBool CPcsAlgorithm2::ReplaceZeroWithSpaceL(CPsQuery& aQuery)
 {
-PRINT ( _L("Enter CPcsAlgorithm2::ReplaceZeroWithSpaceL") );
+TChar space(KSpace); // ascii value for space
-//PRINTQUERY ( _L("CPcsAlgorithm2::ReplaceZeroWithSpaceL (BEFORE): "), aQuery );
+TBool queryModified = EFalse;
-TBool queryModified = EFalse;
+// Skip initial zeros in query
+TInt index = 0;
-/* In phones like E52 and E55, where the "0" and the " " characters are on
+for (index = 0; index < aQuery.Count()
-* the same key, the "0"s have to be considered as possible separators.
+&& aQuery.GetItemAtL(index).Character().GetNumericValue() == 0; ++index)
-*
+{
-* In phones like N97 and E72, where the "0" and the " " characters are on
+}
-* different keys, the "0"s must not be considered as possible separators.
-*/
+if (aQuery.KeyboardModeL() != EQwerty)
+{
-// Skip initial "0"s, they are not replaced into spaces
+for (TInt beg = index; beg < aQuery.Count(); ++beg)
-TInt skipIndex = 0;
+{
-while ( (skipIndex < aQuery.Count()) &&
+CPsQueryItem& item = aQuery.GetItemAtL(beg);
-(aQuery.GetItemAtL(skipIndex).Character().GetNumericValue() == 0) )
-{
+if (item.Character().GetNumericValue() == 0 && item.Mode()== EItut)
-skipIndex++;
+{
-}
+if (beg != 0)
+{
-// Replace remaining "0"s into spaces in case they are entered with a keyboard
+CPsQueryItem& item1 = aQuery.GetItemAtL(beg - 1);
-// that has "0" and " " on the same key.
+if (item1.Character().GetNumericValue() != 0
-const TInt queryCount = aQuery.Count();
+&& !item1.Character().IsSpace())
-for ( TInt index = skipIndex; index < queryCount; index++ )
+{
-{
+item.SetCharacter(space);
-CPsQueryItem& item = aQuery.GetItemAtL(index);
+queryModified = ETrue;
+}
-if ( iKeyMap->GetSpaceAndZeroOnSameKey( item.Mode() ) &&
+}
-item.Character().GetNumericValue() == 0 )
+else
 {
-item.SetCharacter(KSpace);
+item.SetCharacter(space);
 queryModified = ETrue;
 }
 }
+}
-//PRINTQUERY ( _L("CPcsAlgorithm2::ReplaceZeroWithSpaceL (AFTER): "), aQuery );
+}
-PRINT1 ( _L("CPcsAlgorithm2::ReplaceZeroWithSpaceL: Query modified (0=not, 1=yes): %d"), queryModified );
+return queryModified;
-PRINT ( _L("End CPcsAlgorithm2::ReplaceZeroWithSpaceL") );
-return  queryModified;
 }
 // ----------------------------------------------------------------------------
 // CPcsAlgorithm2::PerformSearchL
 // Search function for cache
 // ----------------------------------------------------------------------------
-void CPcsAlgorithm2::PerformSearchL(const CPsSettings& aSettings,
+void CPcsAlgorithm2::PerformSearchL(const CPsSettings& aSettings, CPsQuery& aQuery,
-CPsQuery& aQuery,
 RPointerArray<CPsClientData>& aSearchResults,
 RPointerArray<CPsPattern>& aSearchSeqs)
 {
 PRINT ( _L("Enter CPcsAlgorithm2::PerformSearchL") );
-//__LATENCY_MARK ( _L("CPcsAlgorithm2::PerformSearchL") );
+__LATENCY_MARK ( _L("CPcsAlgorithm2::PerformSearchL") );
-// Check aSettings
+// Get the current language
-RPointerArray<TDesC> searchUris;
+TLanguage lang = User::Language();
-CleanupResetAndDestroyPushL( searchUris );
-aSettings.SearchUrisL(searchUris);
+// Check if the language is supported and the keyboard mode is not qwerty.
-if ( searchUris.Count() <= 0)
-{
-PRINT ( _L("searchUris.Count() <= 0, Leave from CPcsAlgorithm2::PerformSearchL") );
-User::Leave(KErrArgument);
-}
-CleanupStack::PopAndDestroy( &searchUris ); // ResetAndDestroy
 // Local arrays to hold the search results
 RPointerArray<CPsData> tempSearchResults;
-CleanupClosePushL( tempSearchResults );
 RPointerArray<CPsData> tempSearchResults1;
-CleanupClosePushL( tempSearchResults1 );
 // -------------------- Perform the basic search --------------------------
-RemoveSpacesL(aQuery);
-PRINTQUERY ( _L("CPcsAlgorithm2::PerformSearchL: 1st search query: "), aQuery );
 DoSearchL(aSettings, aQuery, tempSearchResults, aSearchSeqs);
 // ------------------------------------------------------------------------
-// ---- Perform new search after "0" replacement if query is not empty ----
+// ------------------- Perform advanced search if needed ------------------
-/* Examples:
+// Substitute "0" with space
-* - If the original search string is "Abc0" then we will search again with "Abc".
-* - If the original search string is "00" then we will not search again.
-*/
 TBool queryModified = ReplaceZeroWithSpaceL(aQuery);
-RemoveSpacesL(aQuery);
-// Perform query again if query got modified.
+// If query got modified and the search query translated to more than 1 query
+// perform a multi search again
 if (queryModified)
 {
-PRINTQUERY ( _L("CPcsAlgorithm2::PerformSearchL: 2nd search query: "), aQuery );
+// Split query
-DoSearchL(aSettings, aQuery, tempSearchResults1, aSearchSeqs);
+RPointerArray<CPsQuery> queryList = iMultiSearchHelper->MultiQueryL(aQuery);
+//  Perform seach again
+if (queryList.Count() > 1)
+{
+DoSearchL(aSettings, aQuery, tempSearchResults1, aSearchSeqs);
+}
 // Sort rule
-TLinearOrder<CPsData> rule(CPcsAlgorithm2Utils::CompareDataBySortOrderL);
+TLinearOrder<CPsData> rule(CPcsAlgorithm2Utils::CompareDataBySortOrder);
 // Avoid duplicates and add new results
 TIdentityRelation<CPsData> identityRule(CPsData::CompareById);
-const TInt tempSearchResults1Count = tempSearchResults1.Count();
 if (aSettings.GetSortType() != EAlphabetical)
 {
 TInt insertPos = 0;
-for (TInt i = 0; i < tempSearchResults1Count; i++)
+for (int i = 0; i < tempSearchResults1.Count(); i++)
 {
 if (tempSearchResults.Find(tempSearchResults1[i],
 identityRule) == KErrNotFound)
 {
 tempSearchResults.Insert(tempSearchResults1[i], insertPos);
 insertPos++;
 }
 }
 }
 else
 {
-for (TInt i = 0; i < tempSearchResults1Count; i++)
+for (int i = 0; i < tempSearchResults1.Count(); i++)
 {
 if (tempSearchResults.Find(tempSearchResults1[i],
 identityRule) == KErrNotFound)
 {
 tempSearchResults.InsertInOrderAllowRepeats(tempSearchResults1[i],
 rule);
 }
 }
 }
+queryList.ResetAndDestroy();
 }
 // ------------------------------------------------------------------------
 // ---------------------- Write result objects to the stream --------------
 // Truncate the result set if required
-TInt maxNumToDisplay = aSettings.MaxResults();
+TInt numToDisplay = aSettings.MaxResults();
-TInt resultSetCount = tempSearchResults.Count();
+TInt resultSet = tempSearchResults.Count();
-TInt numToDisplay = 0;
-if ( maxNumToDisplay == -1 )
+if (resultSet > numToDisplay && numToDisplay != -1)
 {
-numToDisplay = resultSetCount;
+// Copy the top N contents from tempSearchResults to the results stream
+for (int i = 0; i < numToDisplay; i++)
+{
+aSearchResults.Append(WriteClientDataL(*(tempSearchResults[i])));
+}
 }
 else
 {
-numToDisplay = Min( maxNumToDisplay, resultSetCount );
+// Copy all the contents from tempSearchResults to the results stream
-}
+for (int i = 0; i < resultSet; i++)
+{
-// Copy desired number of results from tempSearchResults to the results stream
+aSearchResults.Append(WriteClientDataL(*(tempSearchResults[i])));
-for (TInt i = 0; i < numToDisplay; i++)
+}
-{
-aSearchResults.Append(WriteClientDataL(*(tempSearchResults[i])));
 }
 // ------------------------------------------------------------------------
 // Cleanup local results array
-CleanupStack::PopAndDestroy( &tempSearchResults1 ); // Close, don't destroy
+tempSearchResults.Reset(); // Don't destroy
-CleanupStack::PopAndDestroy( &tempSearchResults );  // Close, don't destroy
+tempSearchResults1.Reset(); // Don't destroy
-// __LATENCY_MARKEND ( _L("CPcsAlgorithm2::PerformSearchL") );
+__LATENCY_MARKEND ( _L("CPcsAlgorithm2::PerformSearchL") );
 PRINT ( _L("End CPcsAlgorithm2::PerformSearchL") );
 }
 // ----------------------------------------------------------------------------
 // CPcsAlgorithm2::SearchInputL
 // Search function for input string
 // ----------------------------------------------------------------------------
-void CPcsAlgorithm2::SearchInputL(CPsQuery& aQuery,
+void CPcsAlgorithm2::SearchInputL(CPsQuery& aQuery, TDesC& aData,
-TDesC& aData,
 RPointerArray<TDesC>& aMatchSet,
 RArray<TPsMatchLocation>& aMatchLocation)
 {
-// __LATENCY_MARK ( _L("CPcsAlgorithm2::SearchInputL: ") );
 PRINT ( _L("Enter CPcsAlgorithm2::SearchInputL") );
+// Get the current language
+TLanguage lang = User::Language();
+// Check if the language is supported and the keyboard mode is not qwerty.
 // Print input query for debug
-PRINTQUERY ( _L("CPcsAlgorithm2::SearchInputL: Search query: "), aQuery );
+aQuery.PrintQuery();
 // Print received search data
 PRINT1 ( _L("Search data received = %S"), &aData);
 // -------------------- Perform the basic search --------------------------
-RemoveSpacesL(aQuery);
 DoSearchInputL(aQuery, aData, aMatchSet, aMatchLocation);
 // ------------------------------------------------------------------------
-// ---- Perform new search after "0" replacement if query is not empty ----
+// ------------------- Perform advanced search if needed ------------------
-/* Examples:
+// Substitute "0" with space
-* - If the original search string is "Abc0" then we will search again with "Abc".
-* - If the original search string is "00" then we will not search again.
-*/
 TBool queryModified = ReplaceZeroWithSpaceL(aQuery);
-RemoveSpacesL(aQuery);
-// If query got modified and the search query still contains something
+// If query got modified and the search query translated to more than 1 query
 // perform a multi search again
-if (queryModified && aQuery.Count() > 0 && aMatchSet.Count() == 0  && aMatchLocation.Count() == 0 )
+if (queryModified)
 {
-DoSearchInputL(aQuery, aData, aMatchSet, aMatchLocation);
+RPointerArray<CPsQuery> queryList = iMultiSearchHelper->MultiQueryL(aQuery);
+if (queryList.Count() > 1)
+{
+DoSearchInputL(aQuery, aData, aMatchSet, aMatchLocation);
+}
+queryList.ResetAndDestroy();
 }
 // ------------------------------------------------------------------------
-// --- Remove overlapping items from aMatchLocation ---
-TInt i = 0;
-TBool incrementFirstCursor;
-while ( i < aMatchLocation.Count() )
-{
-incrementFirstCursor = ETrue;
-TInt j = i+1;
-while ( j < aMatchLocation.Count() )
-{
-if ( CPcsAlgorithm2Utils::MatchesOverlap( aMatchLocation[j], aMatchLocation[i] ) )
-{
-// Remove match location item with smallest length if 2 items have same index
-if ( aMatchLocation[j].length <= aMatchLocation[i].length )
-{
-aMatchLocation.Remove(j);
-continue; // Do not increment j
-}
-else
-{
-aMatchLocation.Remove(i);
-incrementFirstCursor = EFalse; // Do not increment i
-break;
-}
-}
-j++;
-}
-if ( incrementFirstCursor )
-{
-i++;
-}
-}
-// --- Remove from aMatchSet items which no longer have corresponding item in aMatchLocation ---
-HBufC* dataUpper = HBufC::NewLC(aData.Length());
-dataUpper->Des().Copy(aData);
-dataUpper->Des().UpperCase(); // Get uppercase, as aMatchSet is in upper case
-TInt k = 0;
-while ( k < aMatchSet.Count() )
-{
-TBool keepMatch = EFalse;
-TInt startCursor = -1;
-TInt offsetCursor;
-while ( KErrNotFound != (offsetCursor = dataUpper->Mid(startCursor + 1).Find(*aMatchSet[k])) )
-{
-// startCursor = index of match item *aMatchSet[k] into search string aData
-startCursor = offsetCursor + startCursor + 1;
-const TInt matchLocationCount = aMatchLocation.Count();
-for ( TInt i = 0; i < matchLocationCount; i++ )
-{
-// If match item was found in the location list, then keep it
-if ( (aMatchLocation[i].index == startCursor) &&
-(aMatchLocation[i].length == aMatchSet[k]->Length()) )
-{
-keepMatch = ETrue;
-break;
-}
-}
-}
-if ( keepMatch )
-{
-k++;
-}
-else
-{
-aMatchSet.Remove(k); // Do not increment k
-}
-}
-CleanupStack::PopAndDestroy( dataUpper );
-// --- Remove items End ---
 // Sort match set
 iHelper->SortSearchSeqsL(aMatchSet);
 PRINT ( _L("End CPcsAlgorithm2::SearchInputL") );
-//__LATENCY_MARKEND ( _L("CPcsAlgorithm2::SearchInputL") );
 }
 // ----------------------------------------------------------------------------
 // CPcsAlgorithm2::SearchMatchStringL
 // Search function for input string, result also as string
 // ----------------------------------------------------------------------------
-void CPcsAlgorithm2::SearchMatchStringL( CPsQuery& aSearchQuery,
+void CPcsAlgorithm2::SearchMatchStringL( CPsQuery& /*aSearchQuery*/,
-TDesC& aSearchData,
+TDesC& /*aSearchData*/,
-TDes& aMatch )
+TDes& /*aMatch*/ )
 {
-PRINT ( _L("Enter CPcsAlgorithm2::SearchMatchStringL") );
+//NOT IMPLEMENTED YET
-__LATENCY_MARK ( _L("CPcsAlgorithm2::SearchMatchStringL") );
-RemoveSpacesL(aSearchQuery);
-// ---------------------- Perform the initial search ----------------------
-iMultiSearchHelper->LookupMatchL( aSearchQuery, aSearchData, aMatch );
-PRINTQUERY ( _L("CPcsAlgorithm2::SearchMatchStringL: 1st search: "), aSearchQuery );
-PRINT1     ( _L("CPcsAlgorithm2::SearchMatchStringL: 1st search: Search Data: %S"), &aSearchData );
-PRINT1     ( _L("CPcsAlgorithm2::SearchMatchStringL: 1st search: Result: %S"), &aMatch );
-// ------------------------------------------------------------------------
-// ---- Perform new search after "0" replacement if query is not empty ----
-/* Examples:
-* - If the original search string is "Abc0" then we will search again with "Abc".
-* - If the original search string is "00" then we will not search again.
-*/
-if ( aMatch.Length() <= 0 )
-{
-TBool isQueryModified = ReplaceZeroWithSpaceL(aSearchQuery);
-RemoveSpacesL(aSearchQuery);
-if ( isQueryModified && (aSearchQuery.Count() > 0) )
-{
-iMultiSearchHelper->LookupMatchL( aSearchQuery, aSearchData, aMatch );
-PRINTQUERY ( _L("CPcsAlgorithm2::SearchMatchStringL: 2nd search: "), aSearchQuery );
-PRINT1     ( _L("CPcsAlgorithm2::SearchMatchStringL: 2nd search: Search Data: %S"), &aSearchData );
-PRINT1     ( _L("CPcsAlgorithm2::SearchMatchStringL: 2nd search: Result: %S"), &aMatch );
-}
-}
-__LATENCY_MARKEND ( _L("CPcsAlgorithm2::SearchMatchStringL") );
-PRINT ( _L("End CPcsAlgorithm2::SearchMatchStringL") );
 }
 // ----------------------------------------------------------------------------
 // CPcsAlgorithm2::DoSearchL
 // Search function helper
 // ----------------------------------------------------------------------------
-void CPcsAlgorithm2::DoSearchL( const CPsSettings& aSettings,
+void CPcsAlgorithm2::DoSearchL(const CPsSettings& aSettings, CPsQuery& aQuery,
-CPsQuery& aQuery,
+RPointerArray<CPsData>& searchResults,
-RPointerArray<CPsData>& aSearchResults,
+RPointerArray<CPsPattern>& searchSeqs)
-RPointerArray<CPsPattern>& aSearchSeqs )
 {
 PRINT ( _L("Enter CPcsAlgorithm2::DoSearchL") );
-//__LATENCY_MARK ( _L("CPcsAlgorithm2::DoSearchL") );
+// Print query for debug
+aQuery.PrintQuery();
 // -(0)----------------- Check if group search is required ---------------
 RArray<TInt> contactsInGroup;
-CleanupClosePushL( contactsInGroup );
 RArray<TInt> groupIdArray;
-CleanupClosePushL( groupIdArray );
 // Create a new settings instance
-CPsSettings* tempSettings = aSettings.CloneL();
+CPsSettings *tempSettings = aSettings.CloneL();
-CleanupStack::PushL( tempSettings );
 TBool isGroupSearch = IsGroupSearchL(*tempSettings, groupIdArray);
 if (isGroupSearch)
 {
 // List of contacts in this group
 GetContactsInGroupL(groupIdArray[0], contactsInGroup);
 }
+groupIdArray.Close();
 // -----------------------------------------------------------------------
 // Extract query list.
 RPointerArray<CPsQuery> queryList = iMultiSearchHelper->MultiQueryL(aQuery);
-CleanupResetAndDestroyPushL( queryList );
+// -(1)--------------------- No query return all contacts ----------------
-// (1)-------------------- No query return all contacts -------------------
 if (queryList.Count() == 0)
 {
-GetAllContentsL(*tempSettings, aSearchResults);
+GetAllContentsL(*tempSettings, searchResults);
 if (isGroupSearch)
 {
-FilterSearchResultsForGroupsL(contactsInGroup, aSearchResults);
+FilterSearchResultsForGroupsL(contactsInGroup, searchResults);
 }
 }
 // ------------------------------------------------------------------------
-// (2)-------------------- Perform a single query search ------------------
-else if (queryList.Count() == 1)
+// -(2)------------------------ Perform a single query search -------------
-{
+if (queryList.Count() == 1)
+{
+TInt mode = aQuery.KeyboardModeL();
 CPsQuery* query = queryList[0];
-// Search results
+iFindUtilECE->SetKeyboardMode(mode);
-iHelper->SearchSingleL(*tempSettings, *query, isGroupSearch,
-contactsInGroup, aSearchResults, aSearchSeqs);
+switch (mode)
+{
+case EItut:
+PRINT ( _L("Query received is in ITU-T mode") );
+// Search results
+iHelper->SearchITUL(*tempSettings, *query, isGroupSearch,
+contactsInGroup, searchResults, searchSeqs);
+break;
+case EQwerty:
+PRINT ( _L("Query received is in QWERTY mode") );
+// Search results
+iHelper->SearchQWERTYL(*tempSettings, *query, isGroupSearch,
+contactsInGroup, searchResults, searchSeqs);
+break;
+case EModeUndefined:
+PRINT ( _L("Query received is in Mixed mode. Keyboard swap happened.") );
+// Search results
+iHelper->SearchMixedL(*tempSettings, *query, isGroupSearch,
+contactsInGroup, searchResults, searchSeqs);
+break;
+}
 }
 // ------------------------------------------------------------------------
-// (3)-------------------- Perform a multi query search -------------------
-else // multiple query
+// -(3)---------------------------- Perform a multi query search ----------
+if (queryList.Count() > 1) // multiple query
 {
 PRINT ( _L("Query received is in multiple. Performing a multi search.") );
+TInt mode = aQuery.KeyboardModeL();
+iFindUtilECE->SetKeyboardMode(mode);
+for (int i = 0; i < queryList.Count(); i++)
+{
+TPtrC queryPtr = queryList[i]->QueryAsStringLC();
+PRINT2 ( _L("Received Query, index = %d; value = %S"), i, &queryPtr );
+CleanupStack::PopAndDestroy();
+}
 // Search results
 iMultiSearchHelper->SearchMultiL(*tempSettings, queryList, isGroupSearch,
-contactsInGroup, aSearchResults, aSearchSeqs);
+contactsInGroup, searchResults, searchSeqs,
+mode);
 }
 // -------------------------------------------------------------------------
 // Cleanup
+delete tempSettings;
-CleanupStack::PopAndDestroy( &queryList ); // ResetAndDestroy
+tempSettings = NULL;
-CleanupStack::PopAndDestroy( tempSettings );
-CleanupStack::PopAndDestroy( &groupIdArray ); // Close
+groupIdArray.Close();
-CleanupStack::PopAndDestroy( &contactsInGroup ); // Close
+contactsInGroup.Close();
+queryList.ResetAndDestroy();
-	//__LATENCY_MARKEND ( _L("CPcsAlgorithm2::DoSearchL") );
 PRINT ( _L("End CPcsAlgorithm2::DoSearchL") );
 }
 // ----------------------------------------------------------------------------
 // CPcsAlgorithm2::DoSearchInputL
 // Search function helper
 // ----------------------------------------------------------------------------
-void CPcsAlgorithm2::DoSearchInputL(CPsQuery& aQuery,
+void CPcsAlgorithm2::DoSearchInputL(CPsQuery& aQuery, TDesC& aData,
-const TDesC& aData,
 RPointerArray<TDesC>& aMatchSet,
 RArray<TPsMatchLocation>& aMatchLocation)
 {
-//__LATENCY_MARK ( _L("CPcsAlgorithm2::SearchInputL: ") );
 PRINT ( _L("Enter CPcsAlgorithm2::DoSearchInputL") );
 // Check if any seperator is there in the query
 RPointerArray<CPsQuery> queryList = iMultiSearchHelper->MultiQueryL(aQuery);
-CleanupResetAndDestroyPushL( queryList );
 // No query
 if (queryList.Count() == 0)
 {
 PRINT ( _L("Query received is empty") );
-CleanupStack::PopAndDestroy( &queryList ); // ResetAndDestroy
+return;
-return;
+}
-}
+RPointerArray<HBufC> convertedQuery;
+iMultiSearchHelper->ConvertQueryToListL(queryList, convertedQuery);
 // Single query
 if (queryList.Count() == 1)
 {
-iHelper->SearchMatchSeqL(aQuery, aData, aMatchSet, aMatchLocation);
+iHelper->SearchMatchSeqL(convertedQuery[0], aData, aMatchSet, aQuery,
+aMatchLocation);
 }
 if (queryList.Count() > 1) // multiple query
 {
 PRINT ( _L("Query received is in multiple. Performing a multi search.") );
+for (int i = 0; i < queryList.Count(); i++)
+{
+TPtrC queryPtr = queryList[i]->QueryAsStringLC();
+PRINT2 ( _L("Rceived Query, index = %d; value = %S"), i, &queryPtr );
+CleanupStack::PopAndDestroy();
+}
 // Search results
-iMultiSearchHelper->SearchMatchSeqMultiL(queryList,
+iMultiSearchHelper->SearchMatchSeqMultiL(queryList, aData, aMatchSet,
-aData,
-aMatchSet,
 aMatchLocation);
 }
 // Delete all the query elements
-CleanupStack::PopAndDestroy( &queryList ); // ResetAndDestroy
+queryList.ResetAndDestroy();
+convertedQuery.ResetAndDestroy();
 PRINT ( _L("End CPcsAlgorithm2::DoSearchInputL") );
-//__LATENCY_MARKEND ( _L("CPcsAlgorithm2::SearchInputL") );
 }
 // ----------------------------------------------------------------------------
 // CPcsAlgorithm2::AddData
 // Add a data element to the pool
 if (dataStoreIndex < 0)
 return;
 CPcsCache* cache = iPcsCache[dataStoreIndex];
-cache->RemoveAllFromCache();
+TRAPD(err, cache->RemoveAllFromCacheL());
+if (err != KErrNone)
+{
+SetCachingError(aDataStore, err);
+}
 }
 // ----------------------------------------------------------------------------
 // CPcsAlgorithm2::GetCacheIndex
 // Return the cache index for a data store
 // ----------------------------------------------------------------------------
-TInt CPcsAlgorithm2::GetCacheIndex(const TDesC& aDataStore)
+TInt CPcsAlgorithm2::GetCacheIndex(TDesC& aDataStore)
 {
-const TInt pcsCacheCount = iPcsCache.Count();
+for (int i = 0; i < iPcsCache.Count(); i++)
-for (int i = 0; i <pcsCacheCount; i++)
 {
 CPcsCache* cache = iPcsCache[i];
 if (cache->GetURI().CompareC(aDataStore) == 0)
 return i;
 // CPcsAlgorithm2::RemoveDataStore
 // Removes an existing data store
 // ----------------------------------------------------------------------------
 void CPcsAlgorithm2::RemoveDataStore(TDesC& aDataStore)
 {
 for (int i = 0; i < iPcsCache.Count(); i++)
 {
 CPcsCache* cache = iPcsCache[i];
 if (cache->GetURI().CompareC(aDataStore) == 0)
 // ----------------------------------------------------------------------------
 // CPcsAlgorithm2::GetUriForIdL
 // Get the URI string for this internal id
 // ----------------------------------------------------------------------------
-const TDesC& CPcsAlgorithm2::GetUriForIdL(TUint8 aUriId)
+TDesC& CPcsAlgorithm2::GetUriForIdL(TUint8 aUriId)
 {
 TBool found = EFalse;
 TInt i = 0;
-const TInt pcsCacheCount = iPcsCache.Count();
-for (i = 0; i < pcsCacheCount; i++)
+for (i = 0; i < iPcsCache.Count(); i++)
 {
 if (iPcsCache[i]->GetUriId() == aUriId)
 {
 found = ETrue;
 break;
 // ----------------------------------------------------------------------------
 // CPcsAlgorithm2::FindStoreUri
 // Checks if this store exists
 // ----------------------------------------------------------------------------
-TInt CPcsAlgorithm2::FindStoreUri(const TDesC& aDataStore)
+TInt CPcsAlgorithm2::FindStoreUri(TDesC& aDataStore)
 {
-const TInt pcsCacheCount = iPcsCache.Count();
+for (int i = 0; i < iPcsCache.Count(); i++)
-for ( TInt i = 0; i < pcsCacheCount; i++ )
+{
-{
+if (aDataStore.CompareC(*(iPcsCache[i]->GetUri())) == 0)
-if ( aDataStore.CompareC(*(iPcsCache[i]->GetUri())) == 0 )
 {
 return i;
 }
 }
-return KErrNotFound;
+return -1;
 }
 // ----------------------------------------------------------------------------
 // CPcsAlgorithm2::UpdateCachingStatus
 // Update caching status
 // ----------------------------------------------------------------------------
 void CPcsAlgorithm2::UpdateCachingStatus(TDesC& aDataStore, TInt aStatus)
 {
 PRINT ( _L("Enter CPcsAlgorithm2::UpdateCachingStatus") );
-PRINT2 ( _L("CPcsAlgorithm2::UpdateCachingStatus: Request received for URI=%S with status=%d"),
-&aDataStore, aStatus );
 // Handle data store update events
 if ( aStatus == ECacheUpdateContactRemoved ||
 aStatus == ECacheUpdateContactModified ||
 aStatus == ECacheUpdateContactAdded )
 return;
 }
 // If not a cache update event, then this event is related to the initial
 // cache construction.
+TInt index = FindStoreUri(aDataStore);
-// Check if any error occurred and update the cache error
+iPcsCache[index]->UpdateCacheStatus(aStatus);
-if ( aStatus < 0 )
-{
+// Check if any error occurred
+// If so, update the cache status, Set the property and return
+if (aStatus < 0)
+{
 SetCachingError(aDataStore, aStatus);
-}
+//return;
-else
+}
-{
-TInt index = FindStoreUri(aDataStore);
+//store the index for firstname and lastname
-iPcsCache[index]->UpdateCacheStatus(aStatus);
+if (aStatus == ECachingComplete)
-}
+{
+RArray<TInt> dataFields;
-TCachingStatus status = ECachingNotStarted;
+iPcsCache[index]->GetDataFields(dataFields);
-TUint countNotStarted = 0;
-TUint countInProgress = 0;
+for (int i = 0; i < dataFields.Count(); i++)
-TUint countCompleted = 0;
+{
-TUint countCompletedWithErrors = 0;
+if (dataFields[i] == R_VPBK_FIELD_TYPE_FIRSTNAME)
-TInt cacheCount = iPcsCache.Count();
+{
-for ( TInt i = 0; i < cacheCount; i++ )
+iFirstNameIndex = i;
-{
+}
-PRINT3 ( _L("CPcsAlgorithm2::UpdateCachingStatus: URI[%d]=%S, cache status=%d"),
+else if (dataFields[i] == R_VPBK_FIELD_TYPE_LASTNAME)
-i, &iPcsCache[i]->GetURI(), iPcsCache[i]->GetCacheStatus() );
+{
+iLastNameIndex = i;
-switch ( iPcsCache[i]->GetCacheStatus() )
+}
-{
+}
-case ECachingNotStarted:
+}
-{
-countNotStarted++;
+// No error occurred
-break;
+TCachingStatus status = ECachingComplete;
-}
+TBool atLeastOneStoreCachingCompleteWithErrors(EFalse);
-case ECachingInProgress:
+for (TInt i = 0; i < iPcsCache.Count(); i++)
 {
-countInProgress++;
+if (iPcsCache[i]->GetCacheStatus() == ECachingComplete)
-break;
+{
-}
+continue;
-case ECachingComplete:
+}
-{
+else if (iPcsCache[i]->GetCacheStatus() == ECachingCompleteWithErrors)
-countCompleted++;
+{
-break;
+atLeastOneStoreCachingCompleteWithErrors = ETrue;
-}
+continue;
-case ECachingCompleteWithErrors:
+}
-{
+else
-countCompletedWithErrors++;
+{
-break;
+status = ECachingInProgress;
-}
+break;
-default:
+}
-{
+}
-// Default completed state
-countCompleted++;
+if (status == ECachingComplete)
-break;
+{
-}
+// See if any error occurred while caching
-}
+// If so, change the status to ECachingCompleteWithErrors
-}
+if ((iCacheError != KErrNone) || (atLeastOneStoreCachingCompleteWithErrors))
+{
-// Calculate cumulative status according to single caches statuses
+status = ECachingCompleteWithErrors;
-if ( countCompleted > 0 && ( countCompleted + countNotStarted ) == cacheCount )
+}
-{
+}
-// If at least one caching is finished
-// set status to ECachingComplete or ECachingCompleteWithErrors
-// according to iCacheError
-status = ( iCacheError == KErrNone ) ? ECachingComplete : ECachingCompleteWithErrors;
-}
-else if ( countInProgress > 0 )
-{
-// Else if at least one caching is in progress,
-// set status to ECachingInProgress
-status = ECachingInProgress;
-}
-else if ( countCompletedWithErrors > 0 )
-{
-// Else if at least one caching is completed with errors,
-//set status to ECachingCompleteWithErrors
-status = ECachingCompleteWithErrors;
-}
-else
-{
-// countNotStarted == cacheCount
-// status is set to default ECachingNotStarted
-}
-PRINT1 ( _L("CPcsAlgorithm2::UpdateCachingStatus: Cumulative caching status is %d"),
-status );
 // Check if status changed
-if ( status != iCacheStatus )
+if (status != iCacheStatus)
 {
-PRINT2 ( _L("CPcsAlgorithm2::UpdateCachingStatus: Cumulative caching changed: %d -> %d"),
-iCacheStatus, status );
 iCacheStatus = status;
 RProperty::Set(KPcsInternalUidCacheStatus, EPsKeyCacheStatus, iCacheStatus );
 }
-PRINT( _L("End CPcsAlgorithm2::UpdateCachingStatus") );
+PRINT ( _L("End CPcsAlgorithm2::UpdateCachingStatus") );
 }
 // ----------------------------------------------------------------------------
 // CPcsAlgorithm2::SetCachingError
 // Updates cachinge error
 // ----------------------------------------------------------------------------
-void CPcsAlgorithm2::SetCachingError(const TDesC& aDataStore, TInt aError)
+void CPcsAlgorithm2::SetCachingError(TDesC& aDataStore, TInt aError)
 {
 PRINT2 ( _L("SetCachingError::URI %S ERROR %d"), &aDataStore, aError );
 iCacheError = aError;
 RProperty::Set( KPcsInternalUidCacheStatus, EPsKeyCacheError, iCacheError );
 // Returns all the contents of a store
 // ----------------------------------------------------------------------------
 void CPcsAlgorithm2::GetAllContentsL(const CPsSettings& aSettings,
 RPointerArray<CPsData>& aResults)
 {
-//__LATENCY_MARK ( _L("CPcsAlgorithm2::GetAllContentsL") );
+__LATENCY_MARK ( _L("CPcsAlgorithm2::GetAllContentsL") );
 PRINT ( _L("Enter CPcsAlgorithm2::GetAllContentsL") );
+// Get the data stores
+RPointerArray<TDesC> aDataStores;
+aSettings.SearchUrisL(aDataStores);
 // To hold array of results from different data stores
 typedef RPointerArray<CPsData> CPSDATA_R_PTR_ARRAY;
-RPointerArray<CPSDATA_R_PTR_ARRAY> searchResultsArr;
+RPointerArray<CPSDATA_R_PTR_ARRAY> iSearchResultsArr;
-CleanupResetAndDestroyPushL( searchResultsArr );
-// TODO: Here's still a potential memory leak if a leave happens. The child
-// arrays of searchResultsArr are not Reset in that case. The CPsData objects
-// may leak as well. Handling this safely is somewhat complicated because some of
-// the CPsData objects may already be transferred to ownership of aResults array
-// at the time the leave happens, and those items must not be deleted.
-// Get the data stores
-RPointerArray<TDesC> dataStores;
-CleanupResetAndDestroyPushL( dataStores );
-aSettings.SearchUrisL(dataStores);
 // Get all contacts for each data store
-const TInt dataStoresCount = dataStores.Count();
+for (int dsIndex = 0; dsIndex < aDataStores.Count(); dsIndex++)
-for (TInt dsIndex = 0; dsIndex < dataStoresCount; dsIndex++)
 {
 RPointerArray<CPsData> *temp = new (ELeave) RPointerArray<CPsData> ();
-searchResultsArr.Append(temp);
+iSearchResultsArr.Append(temp);
-TInt arrayIndex = GetCacheIndex(*(dataStores[dsIndex]));
+TInt arrayIndex = GetCacheIndex(*(aDataStores[dsIndex]));
 if (arrayIndex < 0)
 {
 continue;
 }
 CPcsCache* cache = GetCache(arrayIndex);
-cache->GetAllContentsL(*(searchResultsArr[dsIndex]));
+cache->GetAllContentsL(*(iSearchResultsArr[dsIndex]));
 }
-CleanupStack::PopAndDestroy( &dataStores ); // ResetAndDestroy
+aDataStores.ResetAndDestroy();
 // Merge the results from different data stores
-CPcsAlgorithm2Utils::FormCompleteSearchResultsL(searchResultsArr, aResults);
+CPcsAlgorithm2Utils::FormCompleteSearchResultsL(iSearchResultsArr, aResults);
 // Cleanup the local arrays
-const TInt seaerchResultsArrCount = searchResultsArr.Count();
+for (TInt i = 0; i < iSearchResultsArr.Count(); i++)
-for (TInt i = 0; i < seaerchResultsArrCount; i++)
+{
-{
+iSearchResultsArr[i]->Reset();
-searchResultsArr[i]->Reset();
+delete iSearchResultsArr[i];
-}
+iSearchResultsArr[i] = NULL;
+}
-CleanupStack::PopAndDestroy( &searchResultsArr ); // ResetAndDestroy
+iSearchResultsArr.Reset();
 PRINT1 ( _L("Number of results = %d"), aResults.Count() );
 PRINT ( _L("End CPcsAlgorithm2::GetAllContentsL") );
-//__LATENCY_MARKEND ( _L("CPcsAlgorithm2::GetAllContentsL") );
+__LATENCY_MARKEND ( _L("CPcsAlgorithm2::GetAllContentsL") );
 }
 // ----------------------------------------------------------------------------
 // CPcsAlgorithm2::IsGroupSearchL
 // Checks if a group search is required
 // Get the groupIds in the seach settings
 aSettings.GetGroupIdsL(aGroupIdArray);
 // Get the current URIs defined in settings
 RPointerArray<TDesC> searchUris;
-CleanupResetAndDestroyPushL( searchUris );
 aSettings.SearchUrisL(searchUris);
 if (aGroupIdArray.Count() && (searchUris.Count() > aGroupIdArray.Count()))
 {
 // There is an error, either there are more than one groups
 // or the settings contain a combination of group/non-group Uris
+searchUris.ResetAndDestroy();
 aGroupIdArray.Close();
 User::Leave(KErrArgument);
 }
-CleanupStack::PopAndDestroy( &searchUris ); // ResetAndDestroy
+searchUris.ResetAndDestroy();
 PRINT ( _L("End CPcsAlgorithm2::IsGroupSearchL") );
 if (aGroupIdArray.Count() == 1)
 return ETrue;
 // Replace groups uri to contacts uri
 // ----------------------------------------------------------------------------
 void CPcsAlgorithm2::ReplaceGroupsUriL(CPsSettings& aSettings)
 {
 RPointerArray<TDesC> uri;
-CleanupResetAndDestroyPushL( uri );
 // Set contacts db uri
-HBufC* cntdb = KVPbkDefaultCntDbURI().AllocLC();
+HBufC* cntdb = HBufC::NewL(KBufferMaxLen);
-uri.AppendL(cntdb);
+cntdb->Des().Copy(KVPbkDefaultCntDbURI);
-CleanupStack::Pop( cntdb ); // ownership transferred
+uri.Append(cntdb);
 aSettings.SetSearchUrisL(uri);
 // Cleanup
-CleanupStack::PopAndDestroy( &uri ); // ResetAndDestroy
+uri.ResetAndDestroy();
 }
 // ----------------------------------------------------------------------------
 // CPcsAlgorithm2::FilterSearchResultsForGroupsL
 // Filters the results that belong to a group
 // ----------------------------------------------------------------------------
 void CPcsAlgorithm2::GetContactsInGroupL(TInt aGroupId, RArray<TInt>& aGroupContactIds)
 {
 // Clear results array
 aGroupContactIds.Reset();
-// Cache Index for group database
+// Groups URI
-TInt cacheIndex = GetCacheIndex(KVPbkDefaultGrpDbURI);
+HBufC* groupURI = HBufC::NewL(50);
+groupURI->Des().Copy(KVPbkDefaultGrpDbURI);
+// Cache Index
+TInt cacheIndex = GetCacheIndex(*groupURI);
+// Cleanup
+delete groupURI;
+groupURI = NULL;
 // Get the groups contact ids
 if (cacheIndex != -1)
 {
 RPointerArray<CPsData> groups;
-CleanupClosePushL( groups );
 // Get all groups
 iPcsCache[cacheIndex]->GetAllContentsL(groups);
 // Get all contacts in group
-const TInt groupsCount = groups.Count();
+for (TInt i = 0; i < groups.Count(); i++)
-for (TInt i = 0; i < groupsCount; i++)
 {
 if (groups[i]->Id() == aGroupId)
 {
 groups[i]->IntDataExt(aGroupContactIds); // All contacts in group
 break;
 }
 }
-CleanupStack::PopAndDestroy( &groups ); // Close
+groups.Reset();
 }
 }
 // ----------------------------------------------------------------------------
 // CPcsAlgorithm2::GetDataOrderL
 TInt arrayIndex = -1;
 if (CPcsAlgorithm2Utils::IsGroupUri(aURI))
 {
 // If search in a group uri, use contacts db
-arrayIndex = GetCacheIndex(KVPbkDefaultCntDbURI);
+TBuf<255> cntdb(KVPbkDefaultCntDbURI);
+arrayIndex = GetCacheIndex(cntdb);
 }
 else
 {
 arrayIndex = GetCacheIndex(aURI);
 }
 TInt arrayIndex = -1;
 if (CPcsAlgorithm2Utils::IsGroupUri(aURI))
 {
 // If search in a group uri, use contacts db
-arrayIndex = GetCacheIndex(KVPbkDefaultCntDbURI);
+TBuf<255> cntdb(KVPbkDefaultCntDbURI);
+arrayIndex = GetCacheIndex(cntdb);
 }
 else
 {
 arrayIndex = GetCacheIndex(aURI);
 }
 cache->GetSortOrder(mySortOrder);
 if (aSortOrder.Count() == mySortOrder.Count())
 {
 TBool same = ETrue;
-const TInt mySourtOrderCount = mySortOrder.Count();
+for (int i = 0; i < mySortOrder.Count(); i++)
-for ( TInt i = 0; i < mySourtOrderCount ; i++ )
 {
 if (mySortOrder[i] != aSortOrder[i])
 {
 same = EFalse;
 break;
 // Request for data again
 TInt err = KErrNone;
 TRAP(err, cache->ResortdataInPoolsL());
 if (err != KErrNone)
 {
-PRINT ( _L("CPcsAlgorithm2::ChangeSortOrderL() Set Caching Error ") );
+PRINT ( _L("CPcsAlgorithm1::ChangeSortOrderL() Set Caching Error ") );
 SetCachingError(aURI, err);
 UpdateCachingStatus(aURI, ECachingCompleteWithErrors);
 return;
 }
 PRINT ( _L("End CPcsAlgorithm2::ChangeSortOrderL.") );
+}
+// ----------------------------------------------------------------------------
+// CPcsAlgorithm2::GetAdaptiveGridL
+//
+// ----------------------------------------------------------------------------
+void CPcsAlgorithm2::GetAdaptiveGridL( const MDesCArray& /*aURIs*/,
+const TBool /*aCompanyName*/,
+TDes& /*aAdaptiveGrid*/ )
+{
+//NOT IMPLEMENTED YET
 }
 // ---------------------------------------------------------------------------------
 // Read the persisted sort order from the central repository
 // Persisted sort order is of form URI Field1 Field2 Field3 .. FieldN (space delimited)
 // ---------------------------------------------------------------------------------
-void CPcsAlgorithm2::ReadSortOrderFromCenRepL(const TDesC& aURI, RArray<TInt>& aSortOrder)
+void CPcsAlgorithm2::ReadSortOrderFromCenRepL(TDesC& aURI, RArray<TInt>& aSortOrder)
 {
 PRINT ( _L("Enter CPcsAlgorithm2::ReadSortOrderFromCenRepL.") );
 aSortOrder.Reset();
 CRepository *repository = CRepository::NewL(KCRUidPSSortOrder);
 // Read the sort order from cenrep
 TBuf<KCRMaxLen> str;
-for ( TInt i(KCenrepFieldsStartKey);
+for (TInt i(KCenrepFieldsStartKey); i < KCenrepFieldsStartKey
-i < KCenrepFieldsStartKey + KCenrepNumberOfFieldsCount;
++ KCenrepNumberOfFieldsCount; i++)
-i++ )
 {
 TInt err = repository->Get(i, str);
 if (KErrNone != err)
 {
 // ---------------------------------------------------------------------------------
 // Write the sort order into the central repository
 // Persisted sort order is of form URI Field1 Field2 Field3 .. FieldN (space delimited)
 // ---------------------------------------------------------------------------------
-void CPcsAlgorithm2::WriteSortOrderToCenRepL(const TDesC& aURI, RArray<TInt>& aSortOrder)
+void CPcsAlgorithm2::WriteSortOrderToCenRepL(TDesC& aURI, RArray<TInt>& aSortOrder)
 {
 PRINT ( _L("Enter CPcsAlgorithm2::WriteSortOrderToCenRepL.") );
-CRepository* repository = CRepository::NewLC(KCRUidPSSortOrder);
+CRepository *repository = CRepository::NewL(KCRUidPSSortOrder);
 // Check if there an entry for this URI in cenrep
 TBuf<KCRMaxLen> str;
 TInt keyIndex = -1;
-for ( TInt i(KCenrepFieldsStartKey);
+for (TInt i(KCenrepFieldsStartKey); i < KCenrepFieldsStartKey
-i < KCenrepFieldsStartKey + KCenrepNumberOfFieldsCount;
++ KCenrepNumberOfFieldsCount; i++)
-i++ )
 {
 TInt err = repository->Get(i, str);
 if (KErrNone != err)
 {
 // No entry for this URI in cenrep
 // Find the next free location in cenrep
 if (keyIndex == -1)
 {
 // Find the next free key index
-for ( TInt i(KCenrepFieldsStartKey);
+for (TInt i(KCenrepFieldsStartKey); i < KCenrepFieldsStartKey
-i < KCenrepFieldsStartKey + KCenrepNumberOfFieldsCount;
++ KCenrepNumberOfFieldsCount; i++)
-i++ )
 {
 TInt err = repository->Get(i, str);
 if (KErrNone != err)
 {
 PRINT ( _L("CPcsAlgorithm2::WriteSortOrderToCenRepL. Persist limit violated.") );
 return;
 }
 // Persist the sort order
-HBufC* str1 = HBufC::NewLC(KCRMaxLen);
+HBufC* str1 = HBufC::NewL(KCRMaxLen);
 TPtr ptr(str1->Des());
 // Append the URI
 ptr.Append(aURI);
 ptr.Append(KSpace);
 // Append the sort order fields
-const TInt sortOrderCount =  aSortOrder.Count();
+for (int j = 0; j < aSortOrder.Count(); j++)
-for (TInt j = 0; j < sortOrderCount; j++)
 {
 ptr.AppendNum(aSortOrder[j]);
 ptr.Append(KSpace);
 }
 // Write to persistent store
 TInt err = repository->Set(keyIndex, ptr);
 User::LeaveIfError(err);
-CleanupStack::PopAndDestroy( str1 );
+delete str1;
-CleanupStack::PopAndDestroy( repository );
+delete repository;
 PRINT ( _L("End CPcsAlgorithm2::WriteSortOrderToCenRepL.") );
 }
 // ---------------------------------------------------------------------------------
 // set Uri
 clientData->SetUriL(GetUriForIdL(aPsData.UriId()));
 // set pointer to the each data element
-const TInt dataElementCount = aPsData.DataElementCount();
+for (TInt i = 0; i < aPsData.DataElementCount(); i++)
-for (TInt i = 0; i <dataElementCount; i++)
 {
 clientData->SetDataL(i, *(aPsData.Data(i)));
 }
 // set data extension
 break;
 default:
 break;
 }
-// Increment the relevant counter in P&S by one to signal the clients about
+if ( psKey != KErrNotFound )
-// the cache update.
+{
-if( psKey != KErrNotFound )
+// Increment the relevant counter in P&S by one to signal the clients about
-{
+// the cache update.
 TInt counter( KErrNotFound );
 TInt err = RProperty::Get( KPcsInternalUidCacheStatus, psKey, counter );
 if ( !err )
 {
 counter++;
 if (err != KErrNone)
 {
 PRINT1 ( _L("keyMap ReconstructKeymapL, err =%d"),err );
 }
-for (TInt index = 0; index < iCacheCount; index++)
+for (int index = 0; index < iCacheCount; index++)
 {
 CPcsCache* cache = iPcsCache[index];
-HBufC* uri = cache->GetUri();
+HBufC * uri = cache->GetUri();
 // Clear the cache
-cache->RemoveAllFromCache();
+TRAP(err, cache->RemoveAllFromCacheL());
+PRINT1 ( _L("cache RemoveAllFromCacheL, err =%d"),err );
 if (err != KErrNone)
 {
 SetCachingError(*uri, err);
 }
 //Update the caching status as ECachingInProgress, since now the caching
-// would be started again
+// would be strated again
 UpdateCachingStatus(*uri, ECachingInProgress);
 // Request for data again
 TRAP(err, iPsDataPluginInterface->RequestForDataL(*uri));
 PRINT1 ( _L("iPsDataPluginInterface->RequestForDataL, err =%d"),err );
 if (err != KErrNone)
 {
 SetCachingError(*uri, err);
 }
+}
+}
+void CPcsAlgorithm2::Converter(const TDesC& aSourStr, TDes& aDestStr)
+{
+if (iKeyMap)
+{
+iKeyMap->GetNumericKeyString(aSourStr, aDestStr);
 }
 }
 // ---------------------------------------------------------------------------------
 // DoLaunchPluginsL.
 // to see how this is being used.
 User::LeaveIfError(Dll::SetTls(&iPcsCache));
 // Initialize cache
 RPointerArray<TDesC> dataStores;
-CleanupClosePushL( dataStores );
 iPsDataPluginInterface->GetAllSupportedDataStoresL(dataStores);
-const TInt dataStoresCount = dataStores.Count();
+for (int dIndex = 0; dIndex < dataStores.Count(); dIndex++)
-for (TInt dIndex = 0; dIndex < dataStoresCount; dIndex++)
 {
 AddDataStore(*(dataStores[dIndex]));
 }
-CleanupStack::PopAndDestroy( &dataStores ); // Close
+dataStores.Reset();
-}
-/**
-* Returns the Adaptive Grid for one or more URI
-*
-*/
-void CPcsAlgorithm2::GetAdaptiveGridL( const MDesCArray& /*aURIs*/,
-const TBool /*aCompanyName*/,
-TDes& /*aAdaptiveGrid*/ )
-{
-PRINT ( _L("Enter CPcsAlgorithm2::GetAdaptiveGridL") );
-PRINT ( _L("End CPcsAlgorithm2::GetAdaptiveGridL") );
 }
 // End of file

branch	RCL_3
changeset 85	38bb213f60ba
parent 74	6b5524b4f673