#include <PbkGlobalSettingFactory.h>

    iMaxCount = 0;

    iKeyMap = iAlgorithm->GetKeyMap();

    iPbkSettings = PbkGlobalSettingFactory::CreatePersistentSettingL();

    iPbkSettings->ConnectL( MPbkGlobalSetting::EGeneralSettingCategory );

    iPbkSettings->RegisterObserverL( this );

    UpdateNameOrderL();

// CPcsAlgorithm2Helper::~CPcsAlgorithm2Helper

// CPcsAlgorithm2Helper::SearchSingleL

void CPcsAlgorithm2Helper::SearchSingleL(const CPsSettings& aSettings,

                                         CPsQuery& aPsQuery, 

                                         TBool aIsSearchInGroup,

                                         const RArray<TInt>& aContactsInGroup,

                                         RPointerArray<CPsData>& aSearchResults,

                                         RPointerArray<CPsPattern>& aSearchSeqs)

    PRINT ( _L("Enter CPcsAlgorithm2Helper::SearchSingleL") );

    //__LATENCY_MARK ( _L("CPcsAlgorithm2Helper::SearchSingleL") );

    iMaxCount = aSettings.MaxResults();

    CleanupStack::PushL( filterHelper );

    // Search from cache based on first character

    const CPsQueryItem& firstCharItem = aPsQuery.GetItemAtL(0);

    TInt cachePoolId = iKeyMap->PoolIdForCharacter( firstCharItem.Character(), firstCharItem.Mode() );

    RPointerArray<TDesC> dataStores;

    CleanupResetAndDestroyPushL( dataStores );

    aSettings.SearchUrisL(dataStores);

    CleanupClosePushL( requiredDataFields );

    CleanupClosePushL( elements );

    const TInt dataStoresCount = dataStores.Count();

    for (TInt dsIndex = 0; dsIndex < dataStoresCount; dsIndex++)

        RPointerArray<CPsData>* temp = new (ELeave) RPointerArray<CPsData> ();

        CleanupStack::PushL( temp );

        iSearchResultsArr.AppendL( temp );

        CleanupStack::Pop( temp );

        TInt arrayIndex = iAlgorithm->GetCacheIndex(*(dataStores[dsIndex]));

        cache->GetContactsForKeyL(cachePoolId, elements);

        // Get the supported data fields for this data store

        RArray<TInt> supportedDataFields;

        CleanupClosePushL( supportedDataFields );

        cache->GetDataFields(supportedDataFields);

        // Get the filtered data fields for this data store

        TUint8 filteredDataMatch = CPcsAlgorithm2Utils::FilterDataFieldsL(requiredDataFields,

                                                                          supportedDataFields);

        FilterResultsSingleL(filterHelper,

                             elements,

                             aPsQuery,

                             filteredDataMatch,

                             aIsSearchInGroup,

                             aContactsInGroup);

        // If alphabetical sorting, get the results for this datastore

        CleanupStack::PopAndDestroy( &supportedDataFields ); // Close

    CleanupStack::PopAndDestroy( &elements );           // Close

    CleanupStack::PopAndDestroy( &requiredDataFields ); // Close

    CleanupStack::PopAndDestroy( &dataStores );         // ResetAndDestroy

                                                        aSearchResults);

        filterHelper->GetResults(aSearchResults);

    filterHelper->GetPatternsL(aSearchSeqs);

    PRINT1 ( _L("Number of search results = %d"), aSearchResults.Count() );

    // Cleanup

    const TInt searchResultsArrCount = iSearchResultsArr.Count();

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

    iSearchResultsArr.ResetAndDestroy();

    CleanupStack::PopAndDestroy( filterHelper );

    //__LATENCY_MARKEND ( _L("CPcsAlgorithm2Helper::SearchSingleL") );

    PRINT ( _L("End CPcsAlgorithm2Helper::SearchSingleL") );

// Function to search matching sequences in the input text

void CPcsAlgorithm2Helper::SearchMatchSeqL(CPsQuery& aPsQuery,

                                           const TDesC& aData,

                                           RPointerArray<TDesC>& aMatchSet,

                                           RArray<TPsMatchLocation>& aMatchLocation )

    RArray<TInt> matchPos;

    CleanupClosePushL( matchPos );

    RArray<TInt> matchLen;

    CleanupClosePushL( matchLen );

    if ( iAlgorithm->FindUtilECE()->MatchRefineL( aData, aPsQuery, matchPos, matchLen, ETrue ) )

        ASSERT( matchPos.Count() == matchLen.Count() );

        const TInt matchPosCount = matchPos.Count();

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

            {

            TPsMatchLocation tempLocation;

            // check for directionality of the text

            TBool found(EFalse);

            TPtrC matchingPart = aData.Mid( matchPos[i], matchLen[i] );

            TBidiText::TDirectionality dir = TBidiText::TextDirectionality(matchingPart, &found);

            tempLocation.index = matchPos[i];

            tempLocation.length = matchLen[i];

            tempLocation.direction = dir;

            // Add the match location to the data structure array

            aMatchLocation.Append(tempLocation);

            // Add the matched sequence to set, not allowing duplicates

            CPcsAlgorithm2Utils::AppendMatchToSeqL( aMatchSet, matchingPart );

            }

    CleanupStack::PopAndDestroy( &matchLen );

    CleanupStack::PopAndDestroy( &matchPos );

// CPcsAlgorithm2Helper::FilterResultsSingleL

void CPcsAlgorithm2Helper::FilterResultsSingleL(CPcsAlgorithm2FilterHelper* aAlgorithmFilterHelper,

                                                RPointerArray<CPcsPoolElement>& aSearchSet,

                                                CPsQuery& aSearchQuery,

                                                TUint8 aFilteredDataMatch,

                                                TBool aIsSearchInGroup,

                                                const RArray<TInt>& aContactsInGroup)

    PRINT ( _L("Enter CPcsAlgorithm2::FilterResultsSingleL") );

    TInt maxcount = 0;

    CFindUtilChineseECE* pFindUtilEce = iAlgorithm->FindUtilECE();

    // Assume that all the elements is aSearchSet are from the same database.

    // Get firstname index and lastname index for that database.

    // If both are found, then name fields are matched a bit differently compared

    // to rest of the fields.

    TInt fnIndex( KErrNotFound );

    TInt lnIndex( KErrNotFound );

    TBool fullNameSearch( EFalse );

    if ( aSearchSet.Count() )

        {

        TInt dbUriId = aSearchSet[0]->GetPsData()->UriId();

        CPcsCache* cache = iAlgorithm->GetCache( dbUriId );

        fnIndex = cache->GetFirstNameIndex();

        lnIndex = cache->GetLastNameIndex();

        // Ensure that firstname and lastname are among the fields to be searched

        TUint8 fnBitmask = 1 << fnIndex;

        TUint8 lnBitmask = 1 << lnIndex;

        if ( (aFilteredDataMatch & fnBitmask) && 

             (aFilteredDataMatch & lnBitmask) )

            {

            fullNameSearch = ETrue;

            // Remove firstname and lastname from the set of fields to search

            // so that they will not be searched twice.

            aFilteredDataMatch &= ~fnBitmask;

            aFilteredDataMatch &= ~lnBitmask;

            }

        }

    const TInt searchSetCount = aSearchSet.Count();

    for (TInt index = 0; index < searchSetCount; index++)

        CPcsPoolElement* poolElement = static_cast<CPcsPoolElement*> (aSearchSet[index]);

        // Skip the contact if we are doing a group search and contact doesn't belong to the group

        if ( aIsSearchInGroup && 

             aContactsInGroup.Find( psData->Id() ) == KErrNotFound )

            {

            continue;

            }

        // Buffer for matched character sequence. Currently, we don't return

        // accurate pattern but just first character from the matching point.

        // Current clients don't actually use this data for anything.

        TBuf<1> matchingData;

        TBool matched = EFalse;

        // Parse thru each data field and filter the results

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

        // Name fields are handled separately to enable searching with query like

        // "LastnameFirstname". Searching fullname by query string 

        // only for the pool elements matching with the firstname or lastname

        if ( fullNameSearch && ( poolElement->IsDataMatch(fnIndex) || 

            poolElement->IsDataMatch(lnIndex) ))

            {

            HBufC* fullName = CreateNameBufLC( *psData, fnIndex, lnIndex );

            // FindUtil can take care of matching queries like "Firstname", "Lastname", 

            // and "LastnameFirstname".

            matched = pFindUtilEce->MatchRefineL( *fullName, aSearchQuery );

            if (matched)

                matchingData = fullName->Left(1);

                psData->SetDataMatch( fnIndex );

                psData->SetDataMatch( lnIndex );

                }

            CleanupStack::PopAndDestroy( fullName );

            }

        // Find from the rest of the fields if no match found so far. 

        // Name fields are already removed from aFilteredDataMatch if we did separate full name search.

        const TInt dataElementCount = psData->DataElementCount();

        for ( TInt dataIndex = 0; dataIndex < dataElementCount && !matched ; dataIndex++ )

            {

            // Filter off data fields not required in search

            TUint8 bitIndex = 1 << dataIndex;

            TUint8 filter = bitIndex & aFilteredDataMatch;

            if ( filter == 0x0 )

                {

                // Move to next data

                continue;

            if ( poolElement->IsDataMatch(dataIndex) )

                TPtrC fieldData( *psData->Data(dataIndex) );

                matched = pFindUtilEce->MatchRefineL( fieldData, aSearchQuery );

                    matchingData = fieldData.Left(1);

                    psData->SetDataMatch( dataIndex );

        // Add to results if match is found

        if ( matched )

            RPointerArray<TDesC> tempMatchSeq;

            CleanupClosePushL( tempMatchSeq );

            // Wrap matched character sequence to array.

            matchingData.UpperCase();

            tempMatchSeq.AppendL(&matchingData);

            // Add the result

            aAlgorithmFilterHelper->AddL( psData, tempMatchSeq );

            maxcount++;

            // Cleanup the match sequence array as 

            // they are stored in pattern details structure

            CleanupStack::PopAndDestroy( &tempMatchSeq ); // Close

            // TODO: Match seqs could be extracted from actual

            //       match locations by using the other overload of

            //       CFindUtilChineseECE::MatchRefineL().

            //       Currently, match seq data is not used by clients.

          if ( iMaxCount != -1 && maxcount > iMaxCount )

              {

              return;

              }

    PRINT ( _L("End CPcsAlgorithm2Helper::FilterResultsSingleL") );

    TLinearOrder<TDesC> rule( CPcsAlgorithm2Utils::MyCompareC );

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

// CPcsAlgorithm2Helper::CreteNameBufLC

// Update name order according to Phonebook setting

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

HBufC* CPcsAlgorithm2Helper::CreateNameBufLC( const CPsData& aContactData, 

        TInt aFirstNameIndex, TInt aLastNameIndex ) const

    const TDesC& firstName( *aContactData.Data(aFirstNameIndex) );

    const TDesC& lastName( *aContactData.Data(aLastNameIndex) );

    CFindUtilChineseECE* pFindUtilEce = iAlgorithm->FindUtilECE();

    HBufC* fullName = NULL;

    if ( pFindUtilEce->IsChineseWordIncluded( lastName ) || 

        pFindUtilEce->IsChineseWordIncluded( firstName ) )

        fullName = HBufC::NewLC( lastName.Length() + firstName.Length()  + 1 );

        TPtr fullNamePtr = fullName->Des();

        // Form the full name according the Phonebook name order setting. Typically,

        // the order is always lastname-firstname in Chinese variants. However, at least

        // currently it is possible to change this from Contacts app if UI language has

        // been set to English.

        if ( iNameOrder == ELastnameFirstname )

            fullNamePtr.Append( lastName );

            //Holds the first char of first name of a contact

            TBuf<10> firstChar;   

            firstChar.Zero();

            if(firstName.Length())

                {

                firstChar.Append(firstName[0]);   

                // There is no space between LastName and FirstName in Chinese Name

                // except that the firstChar of FirstName isn't Chinese character

                if ( !pFindUtilEce->IsChineseWordIncluded( firstChar ) )

                    {

                    fullNamePtr.Append( KSpace );

                    }

                fullNamePtr.Append( firstName ); 

                }

            fullNamePtr.Append( firstName );

            //Holds the first char of last name of a contact

            TBuf<10> firstChar;   

            firstChar.Zero();

            if(lastName.Length())

                {

                firstChar.Append(lastName[0]);

                // There is no space between LastName and FirstName in Chinese Name

                // except that the firstChar of Lastname isn't Chinese character  

                if ( !pFindUtilEce->IsChineseWordIncluded( firstChar ) )

                    {

                    fullNamePtr.Append( KSpace );

                    }

                fullNamePtr.Append( lastName ); 

                }

            }

        }

    else

        {

        fullName = HBufC::NewLC( lastName.Length() + firstName.Length() + 1 );

        TPtr fullNamePtr = fullName->Des();

        // Form the full name according the Phonebook name order setting. Typically,

        // the order is always lastname-firstname in Chinese variants. However, at least

        // currently it is possible to change this from Contacts app if UI language has

        // been set to English.

        if ( iNameOrder == ELastnameFirstname )

            {

            fullNamePtr.Append( lastName );

            fullNamePtr.Append( KSpace );

            fullNamePtr.Append( firstName );

            }