1 /*

     2 * Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  This is the client side interface for the predictive search

    15 *                server.

    16 *

    17 */

    18 

    19 // SYSTEM INCLUDES

    20 #include <MPsResultsObserver.h>

    21 #include <CPsRequestHandler.h>

    22 #include <RPsSession.h>

    23 

    24 // USER INCLUDE

    25 #include "CPsPropertyHandler.h"

    26 #include "CPcsDebug.h"

    27 #include "CPsPattern.h"

    28 

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

    30 

    31 // -----------------------------------------------------------------------------

    32 // CPSRequestHandler::NewL()

    33 // Two-phased constructor.

    34 // -----------------------------------------------------------------------------

    35 EXPORT_C CPSRequestHandler* CPSRequestHandler::NewL()

    36     {

    37     PRINT ( _L("Enter CPSRequestHandler::NewL") );

    38 

    39     CPSRequestHandler* self = NewLC();

    40     CleanupStack::Pop(self);

    41 

    42     PRINT ( _L("End CPSRequestHandler::NewL") );

    43 

    44     return (self);

    45     }

    46 

    47 // -----------------------------------------------------------------------------

    48 // CPSRequestHandler::NewLC()

    49 // Two-phased constructor.

    50 // -----------------------------------------------------------------------------

    51 EXPORT_C CPSRequestHandler* CPSRequestHandler::NewLC()

    52     {

    53     PRINT ( _L("Enter CPSRequestHandler::NewLC") );

    54 

    55     CPSRequestHandler* self = new (ELeave) CPSRequestHandler();

    56     CleanupStack::PushL(self);

    57     self->ConstructL();

    58 

    59     PRINT ( _L("End CPSRequestHandler::NewLC") );

    60 

    61     return self;

    62     }

    63 

    64 // -----------------------------------------------------------------------------

    65 // CPSRequestHandler::ConstructL()

    66 // Symbian 2nd phase constructor can leave.

    67 // -----------------------------------------------------------------------------

    68 void CPSRequestHandler::ConstructL()

    69     {

    70     PRINT ( _L("Enter CPSRequestHandler::ConstructL") );

    71 

    72     User::LeaveIfError(iSession.Connect());

    73 

    74     // Initiate the property handler

    75     iPropertyHandler = CPsPropertyHandler::NewL(this);

    76 

    77     // Initialize the contact id converter

    78     iConverter = NULL;

    79 

    80     PRINT ( _L("End CPSRequestHandler::ConstructL") );

    81     }

    82 

    83 // -----------------------------------------------------------------------------

    84 // CPSRequestHandler::CCSAsyncRequestHandler()

    85 // C++ default constructor can NOT contain any code, that might leave.

    86 // -----------------------------------------------------------------------------

    87 CPSRequestHandler::CPSRequestHandler() :

    88     CActive(EPriorityStandard)

    89     {

    90     PRINT ( _L("Enter CPSRequestHandler::CPSRequestHandler") );

    91 

    92     CActiveScheduler::Add(this);

    93 

    94     PRINT ( _L("End CPSRequestHandler::CPSRequestHandler") );

    95     }

    96 

    97 // -----------------------------------------------------------------------------

    98 // CPSRequestHandler::~CPSRequestHandler()

    99 // Destructor.

   100 // -----------------------------------------------------------------------------

   101 CPSRequestHandler::~CPSRequestHandler()

   102     {

   103     PRINT ( _L("Enter CPSRequestHandler::~CPSRequestHandler") );

   104 

   105     Cancel(); // Causes call to DoCancel()

   106 

   107     // Close the session

   108     iSession.Close();

   109 

   110     // Cleanup

   111     if (iSearchQueryBuffer)

   112         {

   113         delete iSearchQueryBuffer;

   114         }

   115 

   116     if (iPendingSearchQueryBuffer)

   117         {

   118         delete iPendingSearchQueryBuffer;

   119         }

   120 

   121     if (iSearchDataBuffer)

   122         {

   123         delete iSearchDataBuffer;

   124         }

   125 

   126     if (iSearchResultsBuffer)

   127         {

   128         delete iSearchResultsBuffer;

   129         iSearchResultsBuffer = NULL;

   130         }

   131 

   132     if (iPropertyHandler)

   133         {

   134         delete iPropertyHandler;

   135         iPropertyHandler = NULL;

   136         }

   137 

   138     if (iConverter)

   139         {

   140         delete iConverter;

   141         iConverter = NULL;

   142         }

   143 

   144     iObservers.Reset();

   145     iObservers.Close();

   146 

   147     PRINT ( _L("End CPSRequestHandler::~CPSRequestHandler") );

   148     }

   149 

   150 // -----------------------------------------------------------------------------

   151 // CPSRequestHandler::AddObserverL()

   152 // 

   153 // -----------------------------------------------------------------------------

   154 EXPORT_C void CPSRequestHandler::AddObserverL(MPsResultsObserver* aObserver)

   155     {

   156     iObservers.InsertInAddressOrderL(aObserver);

   157     }

   158 

   159 // -----------------------------------------------------------------------------

   160 // CPSRequestHandler::RemoveObserver()

   161 // 

   162 // -----------------------------------------------------------------------------

   163 EXPORT_C TInt CPSRequestHandler::RemoveObserver(MPsResultsObserver* aObserver)

   164     {

   165     TInt index = iObservers.FindInAddressOrder(aObserver);

   166     if (index != KErrNotFound)

   167         {

   168         iObservers.Remove(index);

   169         return KErrNone;

   170         }

   171     else

   172         {

   173         return KErrNotFound;

   174         }

   175     }

   176 

   177 // -----------------------------------------------------------------------------

   178 // CPSRequestHandler::SetSearchSettingsL()

   179 // Send the search settings to the predictive search engine

   180 // -----------------------------------------------------------------------------

   181 EXPORT_C void CPSRequestHandler::SetSearchSettingsL(const CPsSettings& aSettings)

   182     {

   183     PRINT ( _L("Enter CPSRequestHandler::SetSearchSettingsL") );

   184 

   185     // Tmp buffer        

   186     CBufFlat *buf = CBufFlat::NewL(KBufferMaxLen);

   187     CleanupStack::PushL(buf);

   188 

   189     // Stream over the temp buffer

   190     RBufWriteStream stream(*buf);

   191     stream.PushL();

   192 

   193     // Write the search query to the stream

   194     aSettings.ExternalizeL(stream);

   195     stream.CommitL();

   196 

   197     // Create a HBufC8 for IPC

   198     HBufC8* settingsBuffer = HBufC8::NewLC(buf->Size());

   199     TPtr8 ptr(settingsBuffer->Des());

   200     buf->Read(0, ptr, buf->Size());

   201 

   202     // Send the settings to the server

   203     iSession.SetSearchSettingsL(settingsBuffer->Des());

   204 

   205     CleanupStack::PopAndDestroy(3, buf); // buf, stream, settingsBuffer	                 

   206 

   207     PRINT ( _L("End CPSRequestHandler::SetSearchSettingsL") );

   208     }

   209 

   210 // -----------------------------------------------------------------------------

   211 // CPSRequestHandler::SearchL()

   212 // Sends a request to the predictive search engine to perform a search.

   213 // -----------------------------------------------------------------------------

   214 EXPORT_C void CPSRequestHandler::SearchL(const CPsQuery& aSearchQuery)

   215     {

   216     // __LATENCY_MARK ( _L("CPSRequestHandler::SearchL  <--- INITIATE SEARCH") );

   217     PRINT ( _L("Enter CPSRequestHandler::SearchL") );

   218 

   219     // ----------------------- Search Query ----------------------

   220     iSearchRequestCancelled = EFalse;

   221     

   222     // Tmp buffer        

   223     CBufFlat *buf = CBufFlat::NewL(KBufferMaxLen);

   224     CleanupStack::PushL(buf);

   225 

   226     // Stream over the temp buffer

   227     RBufWriteStream stream(*buf);

   228     stream.PushL();

   229 

   230     // Write the search query to the stream

   231     aSearchQuery.ExternalizeL(stream);

   232     stream.CommitL();

   233 

   234     // If there is no submitted request, then submits the new coming search request     

   235     if (!IsActive())

   236         {

   237         // Create a HBufC8 for IPC

   238         if (iSearchQueryBuffer)

   239             {

   240             delete iSearchQueryBuffer;

   241             iSearchQueryBuffer = NULL;

   242             }

   243         iSearchQueryBuffer = HBufC8::NewLC(buf->Size());

   244         CleanupStack::Pop(); // iSearchQueryBuffer

   245         TPtr8 ptr(iSearchQueryBuffer->Des());

   246         buf->Read(0, ptr, buf->Size());

   247 

   248         // Clear pending search query buffer

   249         if (iPendingSearchQueryBuffer)

   250             {

   251             delete iPendingSearchQueryBuffer;

   252             iPendingSearchQueryBuffer = NULL;

   253             }

   254 

   255         // ------------------------- Results Buffer ---------------------

   256 

   257         // Create a buffer to store the search results.    

   258         if (iSearchResultsBuffer)

   259             {

   260             delete iSearchResultsBuffer;

   261             iSearchResultsBuffer = NULL;

   262             }

   263         iSearchResultsBuffer = HBufC8::NewL(KSearchResultsBufferLen);

   264 

   265         // --------------------------------------------------------------      

   266 

   267         // Initiate the search

   268         iSession.SearchL(iSearchQueryBuffer->Des(), iSearchResultsBuffer->Des(), iStatus);

   269         SetActive();

   270         }

   271     else // else holds it in iPendingSearchQueryBuffer( which will be submitted in HandleSearchResults() )

   272         {

   273         CancelSearch();

   274         iPendingSearchQueryBuffer = HBufC8::NewLC(buf->Size());

   275         CleanupStack::Pop();

   276         TPtr8 ptr(iPendingSearchQueryBuffer->Des());

   277         buf->Read(0, ptr, buf->Size());

   278         }

   279 

   280     CleanupStack::PopAndDestroy(2, buf); // buf, stream   

   281 

   282     PRINT ( _L("End CPSRequestHandler::SearchL") );

   283     }

   284 

   285 // -----------------------------------------------------------------------------

   286 // CPSRequestHandler::LookupL()

   287 // Sends a request to the predictive search engine to perform a search.

   288 // -----------------------------------------------------------------------------

   289 EXPORT_C void CPSRequestHandler::LookupL(const CPsQuery& aSearchQuery, 

   290                                          const TDesC& aSearchData,

   291                                          CDesCArray& aMatchSet, 

   292                                          RArray<TPsMatchLocation>& aMatchLocation)

   293     {

   294     PRINT ( _L("Enter CPSRequestHandler::LookupL") );

   295 

   296     // ----------------------- Search Query ----------------------

   297 

   298     // Tmp buffer        

   299     CBufFlat *buf = CBufFlat::NewL(KBufferMaxLen);

   300     CleanupStack::PushL(buf);

   301 

   302     // Stream over the temp buffer

   303     RBufWriteStream stream(*buf);

   304     stream.PushL();

   305 

   306     // Write the search query to the stream

   307     aSearchQuery.ExternalizeL(stream);

   308     stream.CommitL();

   309 

   310     // Create a HBufC8 for IPC

   311     HBufC8* searchQueryBuffer = HBufC8::NewL(buf->Size());

   312     TPtr8 ptr(searchQueryBuffer->Des());

   313     buf->Read(0, ptr, buf->Size());

   314     

   315     CleanupStack::PopAndDestroy(2, buf); // buf, stream

   316     CleanupStack::PushL(searchQueryBuffer);

   317 

   318     // ----------------------- Search Data ----------------------

   319 

   320     // Tmp buffer        

   321     CBufFlat* dataBuf = CBufFlat::NewL(KBufferMaxLen);

   322     CleanupStack::PushL(dataBuf);

   323 

   324     // Stream over the temp buffer

   325     RBufWriteStream dataStream(*dataBuf);

   326     dataStream.PushL();

   327 

   328     // Write the search data to the stream

   329     dataStream.WriteUint16L(aSearchData.Size());

   330     dataStream << aSearchData;

   331 

   332     // Create a HBufC8 for IPC

   333     HBufC8* searchDataBuffer = HBufC8::NewL(dataBuf->Size());

   334     TPtr8 dataPtr(searchDataBuffer->Des());

   335     dataBuf->Read(0, dataPtr, dataBuf->Size());

   336 

   337     CleanupStack::PopAndDestroy(2, dataBuf); // dataBuf, dataStream

   338     CleanupStack::PushL(searchDataBuffer);

   339     

   340     // ------------------------- Results Buffer ---------------------

   341 

   342     // Create a buffer to store the search results.    

   343     HBufC8* searchResultsBuffer = HBufC8::NewLC(KBufferMaxLen);

   344 

   345     // --------------------------------------------------------------      

   346 

   347     // Initiate the search

   348     iSession.SearchL(searchQueryBuffer->Des(), searchDataBuffer->Des(),

   349                      searchResultsBuffer->Des());

   350 

   351     // Parse the results

   352     RDesReadStream resultStream(searchResultsBuffer->Des());

   353     resultStream.PushL();

   354 

   355     // Number of results

   356     TInt seqCount = resultStream.ReadUint16L();

   357 

   358     PRINT1 ( _L("CPSRequestHandler::LookupL: Number of search seqs received = %d"), seqCount );

   359 

   360     // Internalize each char seq

   361     for (int i = 0; i < seqCount; i++)

   362         {

   363         // Size of sequence

   364         TInt szSeq = resultStream.ReadUint16L();

   365 

   366         // Character sequence

   367         HBufC* seq = HBufC::NewLC(resultStream, szSeq);

   368 

   369         aMatchSet.AppendL(seq->Des());

   370 

   371         CleanupStack::PopAndDestroy();

   372         }

   373 

   374     // --------- match sequence location ------------------    

   375     // number of results

   376     TInt count = resultStream.ReadUint16L();

   377 

   378     // read each data struct

   379     for (TInt k = 0; k < count; k++)

   380         {

   381         TPsMatchLocation matchLoc;

   382 

   383         matchLoc.index = resultStream.ReadUint16L();

   384         matchLoc.length = resultStream.ReadUint16L();

   385         matchLoc.direction  = (TBidiText::TDirectionality) (resultStream.ReadUint16L());

   386 

   387         aMatchLocation.Append(matchLoc);

   388         }

   389 

   390     //cleanup

   391     CleanupStack::PopAndDestroy(4, searchQueryBuffer); 

   392     // resultStream, searchResultsBuffer, searchDataBuffer, searchQueryBuffer

   393 	

   394     PRINT1        ( _L("CPSRequestHandler::LookupL: Search Data: %S"), &aSearchData );

   395     PRINTMATCHSET ( _L("CPSRequestHandler::LookupL: "), aMatchSet );

   396     PRINTMATCHLOC ( _L("CPSRequestHandler::LookupL: "), aMatchLocation );

   397     PRINT ( _L("End CPSRequestHandler::LookupL") );

   398     }

   399 

   400 // -----------------------------------------------------------------------------

   401 // CPSRequestHandler::LookupMatchL()

   402 // Sends a request to the predictive search engine to perform a search.

   403 // -----------------------------------------------------------------------------

   404 EXPORT_C void CPSRequestHandler::LookupMatchL(const CPsQuery& aSearchQuery, 

   405                                          const TDesC& aSearchData,

   406                                          TDes& aMatch )

   407     {

   408     PRINT ( _L("Enter CPSRequestHandler::LookupMatchL") );

   409 

   410     // ----------------------- Search Query ----------------------

   411 

   412     // Tmp buffer        

   413     CBufFlat *buf = CBufFlat::NewL(KBufferMaxLen);

   414     CleanupStack::PushL(buf);

   415 

   416     // Stream over the temp buffer

   417     RBufWriteStream stream(*buf);

   418     stream.PushL();

   419 

   420     // Write the search query to the stream

   421     aSearchQuery.ExternalizeL(stream);

   422     stream.CommitL();

   423 

   424     // Create a HBufC8 for IPC

   425     HBufC8* searchQueryBuffer = HBufC8::NewL(buf->Size());

   426     TPtr8 ptr(searchQueryBuffer->Des());

   427     buf->Read(0, ptr, buf->Size());

   428     

   429     CleanupStack::PopAndDestroy(2, buf); // buf, stream

   430     CleanupStack::PushL(searchQueryBuffer);

   431 

   432     // ----------------------- Search Data ----------------------

   433 

   434     // Tmp buffer        

   435     CBufFlat* dataBuf = CBufFlat::NewL(KBufferMaxLen);

   436     CleanupStack::PushL(dataBuf);

   437 

   438     // Stream over the temp buffer

   439     RBufWriteStream dataStream(*dataBuf);

   440     dataStream.PushL();

   441 

   442     // Write the search data to the stream

   443     dataStream.WriteUint16L(aSearchData.Size());

   444     dataStream << aSearchData;

   445 

   446     // Create a HBufC8 for IPC

   447     HBufC8* searchDataBuffer = HBufC8::NewL(dataBuf->Size());

   448     TPtr8 dataPtr(searchDataBuffer->Des());

   449     dataBuf->Read(0, dataPtr, dataBuf->Size());

   450 

   451     CleanupStack::PopAndDestroy(2, dataBuf); // dataBuf, dataStream

   452     CleanupStack::PushL(searchDataBuffer);      

   453 

   454     // Initiate the search

   455     iSession.SearchMatchStringL( 

   456             searchQueryBuffer->Des(), searchDataBuffer->Des(), aMatch );

   457 

   458     //cleanup

   459     CleanupStack::PopAndDestroy(searchDataBuffer);

   460     CleanupStack::PopAndDestroy(searchQueryBuffer); 

   461     

   462     PRINT1 ( _L("CPSRequestHandler::LookupMatchL: Search Data: %S"), &aSearchData );

   463     PRINT1 ( _L("CPSRequestHandler::LookupMatchL: Result Match: %S"), &aMatch );

   464     PRINT  ( _L("End CPSRequestHandler::LookupMatchL") );

   465     }

   466 

   467 // -----------------------------------------------------------------------------

   468 // CPSRequestHandler::SearchL()

   469 // Sends a request to the predictive search engine to perform a search.

   470 // -----------------------------------------------------------------------------

   471 EXPORT_C void CPSRequestHandler::SearchL(const CPsQuery& aSearchQuery,

   472                                          RPointerArray<CPsClientData>& aMarkedContacts,

   473                                          CVPbkContactManager* aContactManager)

   474     {

   475     PRINT ( _L("Enter CPSRequestHandler::SearchL") );

   476 

   477     // Fire the normal search with the input search query

   478     SearchL(aSearchQuery);

   479 

   480     // Clear the bookmarked contacts if any

   481     iMarkedContacts.Reset();

   482 

   483     // Copy the contact manager

   484     iBookMarkContactManager = aContactManager;

   485 

   486     // Copy the bookmarked contacts

   487     for (TInt i = 0; i < aMarkedContacts.Count(); i++)

   488         {

   489         iMarkedContacts.Append(aMarkedContacts[i]);

   490         }

   491 

   492     PRINT ( _L("End CPSRequestHandler::SearchL") );

   493     }

   494 

   495 // -----------------------------------------------------------------------------

   496 // CPSRequestHandler::CancelSearch()

   497 // Cancels ongoing search.

   498 // -----------------------------------------------------------------------------

   499 EXPORT_C void CPSRequestHandler::CancelSearch()

   500     {

   501     if( IsActive() )

   502         {

   503         iSearchRequestCancelled = ETrue;

   504         }

   505     

   506     if( iPendingSearchQueryBuffer )

   507         {

   508         delete iPendingSearchQueryBuffer;

   509         iPendingSearchQueryBuffer = NULL;

   510         }

   511     

   512     iSession.CancelSearch();

   513     }

   514 

   515 // -----------------------------------------------------------------------------

   516 // CPSRequestHandler::HandleSearchResultsL()

   517 // Search is complete. Parse and send the results to the client.

   518 // -----------------------------------------------------------------------------

   519 void CPSRequestHandler::HandleSearchResultsL()

   520     {

   521     PRINT ( _L("Enter CPSRequestHandler::HandleSearchResultsL") );

   522 

   523     // No pending search query, process the search result

   524     RPointerArray<CPsClientData> searchResults;

   525     RPointerArray<CPsPattern> searchSeqs;

   526 

   527     if( !iSearchResultsBuffer )

   528         {

   529         return;

   530         }

   531     RDesReadStream stream(iSearchResultsBuffer->Des());

   532     stream.PushL();

   533 

   534     // Number of results

   535     TInt count = stream.ReadInt32L();

   536 

   537     PRINT1 ( _L("CPSRequestHandler::HandleSearchResultsL: Number of search results received = %d"), count );

   538 

   539     // Internalize each data element

   540     for (int i = 0; i < count; i++)

   541         {

   542         CPsClientData* data = CPsClientData::NewL();

   543         CleanupStack::PushL(data);

   544 

   545         data->InternalizeL(stream);

   546 

   547         CleanupStack::Pop(data);

   548         searchResults.Append(data);

   549         }

   550 

   551     // Check if book marked contacts are there

   552     TInt nBookmark = 0;

   553     if (iMarkedContacts.Count() != 0)

   554         {

   555         nBookmark = AddMarkedContactsL(searchResults);

   556         }

   557     

   558 #ifdef _DEBUG

   559     for ( TInt i = 0; i < searchResults.Count(); i++ )

   560         {

   561         for ( TInt j = 0; j < searchResults[i]->DataElementCount(); j++ )

   562             {

   563             if ( searchResults[i]->Data(j) )

   564                 {

   565                 PRINT3 ( _L("CPSRequestHandler::HandleSearchResultsL: Results[%d,%d] = %S"),

   566                          i, j, &searchResults[i]->Data(j)->Des() );

   567                 }       

   568             }

   569         }    

   570 #endif // _DEBUG

   571 

   572     // Read number of character sequences

   573     TInt seqCount = stream.ReadInt32L();

   574 

   575     PRINT1 ( _L("CPSRequestHandler::HandleSearchResultsL: Number of match sequences received = %d"), seqCount );

   576 

   577     // Internalize each char seq

   578     for (int i = 0; i < seqCount; i++)

   579         {

   580         CPsPattern* pattern = CPsPattern::NewL();

   581         CleanupStack::PushL(pattern);

   582 

   583         pattern->InternalizeL(stream);

   584 

   585         CleanupStack::Pop();

   586         if (pattern->FirstIndex() >= 0) // -1 means that is a Alphabetical sort

   587             {

   588             pattern->SetFirstIndex(pattern->FirstIndex() + nBookmark);

   589             }

   590         searchSeqs.Append(pattern);

   591         }

   592 

   593     CleanupStack::PopAndDestroy(); // stream

   594 

   595     // Pass the results to the observer

   596     for (int i = 0; i < iObservers.Count(); i++)

   597         {

   598         iObservers[i]->HandlePsResultsUpdate(searchResults, searchSeqs);

   599         }

   600 

   601     // Clear all the internal buffers

   602     if (iSearchQueryBuffer)

   603         {

   604         delete iSearchQueryBuffer;

   605         iSearchQueryBuffer = NULL;

   606         }

   607 

   608     if (searchResults.Count())

   609         {

   610         searchResults.ResetAndDestroy();

   611         }

   612 

   613     if (searchSeqs.Count())

   614         {

   615         searchSeqs.ResetAndDestroy();

   616         }

   617 

   618     if (iSearchResultsBuffer)

   619         {

   620         delete iSearchResultsBuffer;

   621         iSearchResultsBuffer = NULL;

   622         }

   623 

   624     PRINT ( _L("End CPSRequestHandler::HandleSearchResultsL") );

   625 

   626     // __LATENCY_MARKEND ( _L("CPSRequestHandler::HandleSearchResultsL  <--- SEARCH COMPLETE") );

   627     }

   628 

   629 // -----------------------------------------------------------------------------

   630 // CPSRequestHandler::RunSearchFromBufferL()

   631 // Runs search if search query buffer ( iPendingSearchQueryBuffer ) is not empty

   632 // -----------------------------------------------------------------------------

   633 void CPSRequestHandler::RunSearchFromBufferL()

   634     {

   635     PRINT ( _L("Enter CPSRequestHandler::RunSearchFromBufferL") );

   636 

   637     if( iPendingSearchQueryBuffer )

   638         {

   639         if (iSearchQueryBuffer)

   640             {

   641             delete iSearchQueryBuffer;

   642             iSearchQueryBuffer = NULL;

   643             }

   644         iSearchQueryBuffer = HBufC8::NewLC(iPendingSearchQueryBuffer->Size());

   645         CleanupStack::Pop();

   646         iSearchQueryBuffer->Des().Copy(iPendingSearchQueryBuffer->Des());

   647 

   648         delete iPendingSearchQueryBuffer;

   649         iPendingSearchQueryBuffer = NULL;

   650 

   651         // ------------------------- Results Buffer ---------------------

   652 

   653         // Create a buffer to store the search results.    

   654         if (iSearchResultsBuffer)

   655             {

   656             delete iSearchResultsBuffer;

   657             iSearchResultsBuffer = NULL;

   658             }

   659         iSearchResultsBuffer = HBufC8::NewL(KSearchResultsBufferLen);

   660 

   661         // --------------------------------------------------------------      

   662 

   663         // Initiate the search

   664         iSession.SearchL(iSearchQueryBuffer->Des(), iSearchResultsBuffer->Des(), iStatus);

   665 

   666         SetActive();

   667         }

   668    

   669     

   670     PRINT ( _L("End CPSRequestHandler::RunSearchFromBufferL") );

   671     }

   672 

   673 // -----------------------------------------------------------------------------

   674 // CPSRequestHandler::AddBookMarkedContacts()

   675 // Adds the necessary bookmark contacts to the search result set

   676 // -----------------------------------------------------------------------------

   677 TInt CPSRequestHandler::AddMarkedContactsL(RPointerArray<CPsClientData>& searchResults)

   678     {

   679     __LATENCY_MARK ( _L(" CPSRequestHandler::AddMarkedContactsL") );

   680     PRINT ( _L("Enter CPSRequestHandler::AddMarkedContactsL") );

   681 

   682     RPointerArray<CPsClientData> filteredBookMarkList; // Local array to store the filtered bookmark contacts

   683     TInt nBookmark = 0;

   684 

   685     for (TInt i = 0; i < iMarkedContacts.Count(); i++)

   686         {

   687         MVPbkContactLink* bookMarkLink = NULL;

   688 

   689         // See if this contact is already in the result set

   690         TInt id = iMarkedContacts[i]->Id();

   691 

   692         TInt j = 0;

   693         for (; j < searchResults.Count(); j++)

   694             {

   695             if (id > 0)

   696                 {

   697                 if (id == searchResults[j]->Id())

   698                     {

   699                     searchResults[j]->SetMark(); // Set the bookmark

   700                     break; // Found, go to the next bookmark contact

   701                     }

   702                 else

   703                     {

   704                     continue;

   705                     }

   706                 }

   707             else

   708                 {

   709                 if (searchResults[j]->Id() > 0)

   710                     {

   711                     continue;

   712                     }

   713                 else

   714                     {

   715                     if (!bookMarkLink)

   716                         {

   717                         bookMarkLink = ConvertToVpbkLinkLC(*(iMarkedContacts[i]),

   718                                                            *iBookMarkContactManager);

   719                         CleanupStack::Pop(); //  bookMarkLink  

   720                         }

   721 

   722                     MVPbkContactLink* searchContactLink = ConvertToVpbkLinkLC(*(searchResults[j]),

   723                                                                               *iBookMarkContactManager);

   724                     CleanupStack::Pop(); // searchContactLink

   725 

   726                     if (bookMarkLink->IsSame(*searchContactLink))

   727                         {

   728                         searchResults[j]->SetMark(); // Set the bookmark

   729                         break; // Found, go to the next bookmark contact

   730                         }

   731                     else

   732                         continue;

   733                     }

   734                 }

   735             }

   736         if (j == searchResults.Count()) // Not found in the result set, Add it

   737             {

   738             filteredBookMarkList.Append(iMarkedContacts[i]);

   739             }

   740         }

   741 

   742     // Create the new CPsClientData objects for each filtered results 

   743     // and prepend them to the actual result set

   744     // in reverse order so that they will be in sorted order among themselves

   745 

   746     nBookmark = filteredBookMarkList.Count();

   747     for (TInt i = filteredBookMarkList.Count() - 1; i >= 0; i--)

   748         {

   749         CPsClientData* temp = CPsClientData::NewL();

   750         temp->SetId(filteredBookMarkList[i]->Id());

   751         temp->SetUriL(filteredBookMarkList[i]->Uri()->Des());

   752 

   753         // Add the data fields

   754         for (TInt j = 0; j < filteredBookMarkList[i]->DataElementCount(); j++)

   755             {

   756             temp->SetDataL(j, filteredBookMarkList[i]->Data(j)->Des());

   757             }

   758 

   759         temp->SetDataExtensionL(filteredBookMarkList[i]->DataExtension());

   760         temp->SetMark(); // Set the bookmark

   761 

   762         searchResults.Insert(temp, 0);

   763         }

   764 

   765     // Free the bookmark arrays

   766     iMarkedContacts.Reset();

   767     filteredBookMarkList.Reset();

   768 

   769     PRINT ( _L("END CPSRequestHandler::AddMarkedContactsL") );

   770     __LATENCY_MARKEND ( _L(" CPSRequestHandler::AddMarkedContactsL") );

   771     return nBookmark;

   772     }

   773 

   774 // -----------------------------------------------------------------------------

   775 // CPSRequestHandler::HandleBufferOverFlowL()

   776 // Handle the buffer overflow error

   777 // -----------------------------------------------------------------------------

   778 void CPSRequestHandler::HandleBufferOverFlowL()

   779     {

   780     PRINT ( _L("Enter CPSRequestHandler::HandleBufferOverFlowL") );

   781 

   782     // New buffer size is now stored in results buffer

   783     RDesReadStream stream(iSearchResultsBuffer->Des());

   784     stream.PushL();

   785 

   786     // Read the buffer size and create a new buffer

   787     TInt bufferSize = stream.ReadInt32L();

   788 

   789     CleanupStack::PopAndDestroy(); // stream

   790 

   791     // Delete and recreate the results buffer

   792     if (iSearchResultsBuffer)

   793         {

   794         delete iSearchResultsBuffer;

   795         iSearchResultsBuffer = NULL;

   796         }

   797 

   798     // Buffer created for the new size

   799     iSearchResultsBuffer = HBufC8::NewL(bufferSize);

   800 

   801     // Recover the search results 

   802     iSession.SendNewBufferL(iSearchResultsBuffer->Des(), iStatus);

   803 

   804     SetActive();

   805 

   806     PRINT ( _L("End CPSRequestHandler::HandleBufferOverFlowL") );

   807     }

   808 

   809 // -----------------------------------------------------------------------------

   810 // CPSRequestHandler::RunL()

   811 // Invoked to handle responses from the server.

   812 // -----------------------------------------------------------------------------

   813 void CPSRequestHandler::RunL()

   814     {

   815     switch (iStatus.Int())

   816         {

   817         case ESearchComplete:

   818             // The server has completed the request, signalled the client

   819             // thread and the clients active scheduler runs the active object.

   820             // Now send the search results over the observer interface.

   821             // If request was canceled we will do search from buffer.

   822             if( iSearchRequestCancelled )

   823                 {

   824                 RunSearchFromBufferL();

   825                 }

   826             else

   827                 {

   828                 HandleSearchResultsL();

   829                 }

   830             break;

   831         

   832         case KErrOverflow:

   833             // Internal buffer used for IPC is in-adequate as the match results

   834             // are more. Send a new buffer to recover the results.

   835             // If request was canceled we will do search from buffer.

   836             if( iSearchRequestCancelled )

   837                 {

   838                 RunSearchFromBufferL();

   839                 }

   840             else

   841                 {

   842                 HandleBufferOverFlowL();

   843                 }

   844             break;

   845         

   846         case ECancelComplete:

   847         case KErrCancel:

   848             // The search request was canceled

   849             if( iPendingSearchQueryBuffer )

   850                 {

   851                 RunSearchFromBufferL();

   852                 }

   853             break;

   854 

   855         default:

   856             // Errors

   857             HandleErrorL(iStatus.Int());

   858         }

   859     iSearchRequestCancelled = EFalse;

   860     }

   861 

   862 // -----------------------------------------------------------------------------

   863 // CPSRequestHandler::HandleErrorL()

   864 // Send the error code to the client.

   865 // -----------------------------------------------------------------------------

   866 void CPSRequestHandler::HandleErrorL(TInt aErrorCode)

   867     {

   868     for (int i = 0; i < iObservers.Count(); i++)

   869         {

   870         iObservers[i]->HandlePsError(aErrorCode);

   871         }

   872     }

   873 

   874 // -----------------------------------------------------------------------------

   875 // CPSRequestHandler::DoCancel()

   876 // Cancels any outstanding operation.

   877 // -----------------------------------------------------------------------------

   878 void CPSRequestHandler::DoCancel()

   879     {

   880     iSession.CancelSearch();

   881     }

   882 

   883 // -----------------------------------------------------------------------------

   884 // CPSRequestHandler::Version()

   885 // Recovers the predictive search server version.

   886 // -----------------------------------------------------------------------------

   887 EXPORT_C TVersion CPSRequestHandler::Version() const

   888     {

   889     return (iSession.Version());

   890     }

   891 

   892 // -----------------------------------------------------------------------------

   893 // CPSRequestHandler::ShutdownServerL()

   894 // Shuts down the predictive search engine.

   895 // -----------------------------------------------------------------------------

   896 EXPORT_C void CPSRequestHandler::ShutdownServerL()

   897     {

   898     return (iSession.ShutdownServerL());

   899     }

   900 

   901 // -----------------------------------------------------------------------------

   902 // CPSRequestHandler::IsLanguageSupportedL()

   903 // Checks if the language variant is supported by 

   904 // the predictive search engine.

   905 // -----------------------------------------------------------------------------

   906 EXPORT_C TBool CPSRequestHandler::IsLanguageSupportedL(const TLanguage aLanguage)

   907     {

   908     PRINT ( _L("Enter CPSRequestHandler::IsLanguageSupportedL") );

   909 

   910     // ----------------------- language id----------------------

   911 

   912     // Tmp buffer        

   913     CBufFlat* dataBuf = CBufFlat::NewL(KBufferMaxLen);

   914     CleanupStack::PushL(dataBuf);

   915 

   916     // Stream over the temp buffer

   917     RBufWriteStream dataStream(*dataBuf);

   918     dataStream.PushL();

   919 

   920     // Write the language id to the stream

   921     dataStream.WriteUint32L(aLanguage);

   922 

   923     // Create a HBufC8 for IPC

   924     if (iSearchDataBuffer)

   925         {

   926         delete iSearchDataBuffer;

   927         iSearchDataBuffer = NULL;

   928         }

   929 

   930     iSearchDataBuffer = HBufC8::NewLC(dataBuf->Size());

   931     CleanupStack::Pop(); // iSearchDataBuffer

   932     TPtr8 dataPtr(iSearchDataBuffer->Des());

   933     dataBuf->Read(0, dataPtr, dataBuf->Size());

   934 

   935     CleanupStack::PopAndDestroy(2, dataBuf); // dataBuf, dataStream

   936 

   937     // ------------------------- Results Buffer ---------------------

   938 

   939     // Create a buffer to store the search results.    

   940     if (iSearchResultsBuffer)

   941         {

   942         delete iSearchResultsBuffer;

   943         iSearchResultsBuffer = NULL;

   944         }

   945     iSearchResultsBuffer = HBufC8::NewL(KBufferMaxLen);

   946 

   947     // -------------------------------------------------------------- 

   948     // Send the request

   949     iSession.IsLanguageSupportedL(iSearchDataBuffer->Des(), iSearchResultsBuffer->Des());

   950 

   951     // parse the result

   952     RDesReadStream resultStream(iSearchResultsBuffer->Des());

   953     resultStream.PushL();

   954 

   955     // result ETrue or EFalse

   956     TBool flag = resultStream.ReadUint8L();

   957 

   958     CleanupStack::PopAndDestroy(); // resultStream

   959 

   960     PRINT ( _L("End CPSRequestHandler::IsLanguageSupportedL") );

   961     return flag;

   962     }

   963 

   964 // -----------------------------------------------------------------------------

   965 // CPSRequestHandler::GetCachingStatusL()

   966 // Gets the status of the caching synchronously

   967 // -----------------------------------------------------------------------------

   968 EXPORT_C TInt CPSRequestHandler::GetCachingStatusL(TCachingStatus& aStatus)

   969     {

   970     PRINT ( _L("Enter CPSRequestHandler::GetCachingStatusL") );

   971 

   972     // Get the status from property handler

   973     // No need to send the request to engine

   974     TInt cacheError = iPropertyHandler->GetCachingStatusL(aStatus);

   975 

   976     PRINT ( _L("End CPSRequestHandler::GetCachingStatusL") );

   977     return cacheError;

   978     }

   979 

   980 // -----------------------------------------------------------------------------

   981 // CPSRequestHandler::ConvertToVpbkLinkLC()

   982 // Get the contact link associated with the search result

   983 // -----------------------------------------------------------------------------

   984 EXPORT_C MVPbkContactLink* CPSRequestHandler::ConvertToVpbkLinkLC(const CPsClientData& aPsData, 

   985                                                                   CVPbkContactManager& aContactManager)

   986     {

   987     PRINT ( _L("Enter CPSRequestHandler::ConvertToVpbkLinkLC") );

   988 

   989     MVPbkContactLink* contactLink = NULL;

   990 

   991     // Get the originating uri for this result    

   992     HBufC* URI = aPsData.Uri();

   993 

   994     // Leave if not in contacts domain

   995     if (URI->CompareC(KVPbkDefaultCntDbURI) != 0 && URI->CompareC(KVPbkSimGlobalAdnURI) != 0 \

   996             && URI->CompareC(KVPbkSimGlobalFdnURI) != 0 && URI->CompareC(KVPbkSimGlobalSdnURI) != 0

   997             && URI->CompareC(KVPbkDefaultGrpDbURI) != 0)

   998         {

   999         User::Leave(KErrNotSupported);

  1000         }

  1001 

  1002     // Create converter instance if not already available	

  1003     if (iConverter == NULL)

  1004         {

  1005         // Get the store corresponding to the URI

  1006         MVPbkContactStoreList& storeList = aContactManager.ContactStoresL();

  1007         TVPbkContactStoreUriPtr uriPtr(KVPbkDefaultCntDbURI);

  1008         MVPbkContactStore* store = storeList.Find(uriPtr);

  1009 

  1010         // Create converter 			

  1011         if (store)

  1012             {

  1013             iConverter = CVPbkContactIdConverter::NewL(*store);

  1014             }

  1015         }

  1016 

  1017     if (aPsData.Id() < 0) // ID is negative for contacts in SIM domain

  1018         {

  1019         // Contact link is already packed for SIM contacts in CPsClientData

  1020         HBufC8* linkBuf = (HBufC8*) aPsData.DataExtension();

  1021 

  1022         // ---------------- Convert HBufC8* to contact link ---------------------------	   	   				

  1023 

  1024         if (linkBuf->Length())

  1025             {

  1026             // Get the store corresponding to the URI

  1027             MVPbkContactStoreList& storeList = aContactManager.ContactStoresL();

  1028 

  1029             // Link array

  1030             CVPbkContactLinkArray* array = CVPbkContactLinkArray::NewLC(*(linkBuf), storeList);

  1031 

  1032             TInt count = array->Count();

  1033 

  1034             if (count == 1) // should contain only single contact link

  1035                 {

  1036                 const MVPbkContactLink& link = array->At(0);

  1037                 contactLink = link.CloneLC();

  1038                 CleanupStack::Pop(); // contactLink

  1039                 }

  1040 

  1041             CleanupStack::PopAndDestroy(); // array	

  1042             }

  1043 

  1044         // ---------------- End convert HBufC8* to contact link -----------------------

  1045         }

  1046     else

  1047         {

  1048         // cntdb domain

  1049         if (iConverter)

  1050             {

  1051             contactLink = iConverter->IdentifierToLinkLC(aPsData.Id());

  1052             CleanupStack::Pop();

  1053             }

  1054         }

  1055 

  1056     // Add to cleanup stack

  1057     CleanupDeletePushL(contactLink);

  1058 

  1059     PRINT ( _L("End CPSRequestHandler::ConvertToVpbkLinkLC") );

  1060 

  1061     return contactLink;

  1062 

  1063     }

  1064 

  1065 // -----------------------------------------------------------------------------

  1066 // CPSRequestHandler::GetAllContentsL()

  1067 // Sends a request to the predictive search server to get all cached contents.

  1068 // -----------------------------------------------------------------------------

  1069 EXPORT_C void CPSRequestHandler::GetAllContentsL()

  1070     {

  1071     PRINT ( _L("Enter CPSRequestHandler::GetAllContentsL") );

  1072 

  1073     // Create a empty CPsQuery

  1074     CPsQuery* query = CPsQuery::NewL();

  1075 

  1076     // Perform a search

  1077     SearchL(*query);

  1078 

  1079     // Cleanup

  1080     delete query;

  1081 

  1082     PRINT ( _L("Enter CPSRequestHandler::GetAllContentsL") );

  1083     }

  1084 

  1085 // -----------------------------------------------------------------------------

  1086 // CPSRequestHandler::GetDataOrderL()

  1087 // 

  1088 // -----------------------------------------------------------------------------

  1089 EXPORT_C void CPSRequestHandler::GetDataOrderL(const TDesC& aURI,

  1090         RArray<TInt>& aDataOrder)

  1091     {

  1092     PRINT ( _L("Enter CPSRequestHandler::GetDataOrderL") );

  1093 

  1094     // ----------------------- URI ----------------------

  1095 

  1096     // Tmp buffer        

  1097     CBufFlat* dataBuf = CBufFlat::NewL(KBufferMaxLen);

  1098     CleanupStack::PushL(dataBuf);

  1099 

  1100     // Stream over the temp buffer

  1101     RBufWriteStream dataStream(*dataBuf);

  1102     dataStream.PushL();

  1103 

  1104     // Write the URI details in the stream

  1105     TInt length = aURI.Length();

  1106     dataStream.WriteUint16L(length);

  1107     dataStream << aURI;

  1108 

  1109     // Create a HBufC8 for IPC

  1110     if (iSearchDataBuffer)

  1111         {

  1112         delete iSearchDataBuffer;

  1113         iSearchDataBuffer = NULL;

  1114         }

  1115 

  1116     iSearchDataBuffer = HBufC8::NewL(dataBuf->Size());

  1117     TPtr8 dataPtr(iSearchDataBuffer->Des());

  1118     dataBuf->Read(0, dataPtr, dataBuf->Size());

  1119 

  1120     // ------------------------- Results Buffer ---------------------

  1121 

  1122     // Create a buffer to store the search results.    

  1123     if (iSearchResultsBuffer)

  1124         {

  1125         delete iSearchResultsBuffer;

  1126         iSearchResultsBuffer = NULL;

  1127         }

  1128     iSearchResultsBuffer = HBufC8::NewL(KBufferMaxLen);

  1129 

  1130     // --------------------------------------------------------------      

  1131 

  1132     // Send the request

  1133     iSession.GetDataOrderL(iSearchDataBuffer->Des(), iSearchResultsBuffer->Des());

  1134