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 "CPsUpdateHandler.h"

    27 #include "CPcsDebug.h"

    28 #include "CPsPattern.h"

    29 

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

    31 

    32 // -----------------------------------------------------------------------------

    33 // CPSRequestHandler::NewL()

    34 // Two-phased constructor.

    35 // -----------------------------------------------------------------------------

    36 EXPORT_C CPSRequestHandler* CPSRequestHandler::NewL()

    37     {

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

    39 

    40     CPSRequestHandler* self = NewLC();

    41     CleanupStack::Pop(self);

    42 

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

    44 

    45     return self;

    46     }

    47 

    48 // -----------------------------------------------------------------------------

    49 // CPSRequestHandler::NewLC()

    50 // Two-phased constructor.

    51 // -----------------------------------------------------------------------------

    52 EXPORT_C CPSRequestHandler* CPSRequestHandler::NewLC()

    53     {

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

    55 

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

    57     CleanupStack::PushL(self);

    58     self->ConstructL();

    59 

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

    61 

    62     return self;

    63     }

    64 

    65 // -----------------------------------------------------------------------------

    66 // CPSRequestHandler::ConstructL()

    67 // Symbian 2nd phase constructor can leave.

    68 // -----------------------------------------------------------------------------

    69 void CPSRequestHandler::ConstructL()

    70     {

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

    72 

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

    74 

    75     // Initiate the property handler

    76     iPropertyHandler = CPsPropertyHandler::NewL(this);

    77 

    78     // Initiate handlers for cache updating

    79     iContactAddedHandler = CPsUpdateHandler::NewL( *this, EPsKeyContactAddedCounter );

    80     iContactModifiedHandler = CPsUpdateHandler::NewL( *this, EPsKeyContactModifiedCounter );

    81     iContactRemovedHandler = CPsUpdateHandler::NewL( *this, EPsKeyContactRemovedCounter );

    82     

    83     // Initialize the contact id converter

    84     iConverter = NULL;

    85 

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

    87     }

    88 

    89 // -----------------------------------------------------------------------------

    90 // CPSRequestHandler::CCSAsyncRequestHandler()

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

    92 // -----------------------------------------------------------------------------

    93 CPSRequestHandler::CPSRequestHandler() :

    94     CActive(EPriorityStandard)

    95     {

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

    97 

    98     CActiveScheduler::Add(this);

    99 

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

   101     }

   102 

   103 // -----------------------------------------------------------------------------

   104 // CPSRequestHandler::~CPSRequestHandler()

   105 // Destructor.

   106 // -----------------------------------------------------------------------------

   107 CPSRequestHandler::~CPSRequestHandler()

   108     {

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

   110 

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

   112 

   113     // Close the session

   114     iSession.Close();

   115 

   116     delete iSearchQueryBuffer;

   117     delete iPendingSearchQueryBuffer;

   118     delete iSearchDataBuffer;

   119     delete iSearchResultsBuffer;

   120     delete iPropertyHandler;

   121     delete iContactAddedHandler;

   122     delete iContactModifiedHandler;

   123     delete iContactRemovedHandler;

   124     delete iConverter;

   125 

   126     iObservers.Reset();

   127     iObservers.Close();

   128 

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

   130     }

   131 

   132 // -----------------------------------------------------------------------------

   133 // CPSRequestHandler::AddObserverL()

   134 // 

   135 // -----------------------------------------------------------------------------

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

   137     {

   138     iObservers.InsertInAddressOrderL(aObserver);

   139     }

   140 

   141 // -----------------------------------------------------------------------------

   142 // CPSRequestHandler::RemoveObserver()

   143 // 

   144 // -----------------------------------------------------------------------------

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

   146     {

   147     TInt index = iObservers.FindInAddressOrder(aObserver);

   148     if (index != KErrNotFound)

   149         {

   150         iObservers.Remove(index);

   151         return KErrNone;

   152         }

   153     else

   154         {

   155         return KErrNotFound;

   156         }

   157     }

   158 

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

   160 // CPSRequestHandler::SetSearchSettingsL()

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

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

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

   164     {

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

   166 

   167     // Tmp buffer        

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

   169     CleanupStack::PushL(buf);

   170 

   171     // Stream over the temp buffer

   172     RBufWriteStream stream(*buf);

   173     stream.PushL();

   174 

   175     // Write the search query to the stream

   176     aSettings.ExternalizeL(stream);

   177     stream.CommitL();

   178 

   179     // Create a HBufC8 for IPC

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

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

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

   183 

   184     // Send the settings to the server

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

   186 

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

   188 

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

   190     }

   191 

   192 // -----------------------------------------------------------------------------

   193 // CPSRequestHandler::SearchL()

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

   195 // -----------------------------------------------------------------------------

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

   197     {

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

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

   200 

   201     // ----------------------- Search Query ----------------------

   202     iSearchRequestCancelled = EFalse;

   203     

   204     // Tmp buffer        

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

   206     CleanupStack::PushL(buf);

   207 

   208     // Stream over the temp buffer

   209     RBufWriteStream stream(*buf);

   210     stream.PushL();

   211 

   212     // Write the search query to the stream

   213     aSearchQuery.ExternalizeL(stream);

   214     stream.CommitL();

   215 

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

   217     if (!IsActive())

   218         {

   219         // Create a HBufC8 for IPC

   220         if (iSearchQueryBuffer)

   221             {

   222             delete iSearchQueryBuffer;

   223             iSearchQueryBuffer = NULL;

   224             }

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

   226         CleanupStack::Pop(); // iSearchQueryBuffer

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

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

   229 

   230         // Clear pending search query buffer

   231         if (iPendingSearchQueryBuffer)

   232             {

   233             delete iPendingSearchQueryBuffer;

   234             iPendingSearchQueryBuffer = NULL;

   235             }

   236 

   237         // ------------------------- Results Buffer ---------------------

   238 

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

   240         if (iSearchResultsBuffer)

   241             {

   242             delete iSearchResultsBuffer;

   243             iSearchResultsBuffer = NULL;

   244             }

   245         iSearchResultsBuffer = HBufC8::NewL(KSearchResultsBufferLen);

   246 

   247         // --------------------------------------------------------------      

   248 

   249         // Initiate the search

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

   251         SetActive();

   252         }

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

   254         {

   255         CancelSearch();

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

   257         CleanupStack::Pop();

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

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

   260         }

   261 

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

   263 

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

   265     }

   266 

   267 // -----------------------------------------------------------------------------

   268 // CPSRequestHandler::LookupL()

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

   270 // -----------------------------------------------------------------------------

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

   272                                          const TDesC& aSearchData,

   273                                          CDesCArray& aMatchSet, 

   274                                          RArray<TPsMatchLocation>& aMatchLocation)

   275     {

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

   277 

   278     // ----------------------- Search Query ----------------------

   279 

   280     // Tmp buffer        

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

   282     CleanupStack::PushL(buf);

   283 

   284     // Stream over the temp buffer

   285     RBufWriteStream stream(*buf);

   286     stream.PushL();

   287 

   288     // Write the search query to the stream

   289     aSearchQuery.ExternalizeL(stream);

   290     stream.CommitL();

   291 

   292     // Create a HBufC8 for IPC

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

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

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

   296     

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

   298     CleanupStack::PushL(searchQueryBuffer);

   299 

   300     // ----------------------- Search Data ----------------------

   301 

   302     // Tmp buffer        

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

   304     CleanupStack::PushL(dataBuf);

   305 

   306     // Stream over the temp buffer

   307     RBufWriteStream dataStream(*dataBuf);

   308     dataStream.PushL();

   309 

   310     // Write the search data to the stream

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

   312     dataStream << aSearchData;

   313 

   314     // Create a HBufC8 for IPC

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

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

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

   318 

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

   320     CleanupStack::PushL(searchDataBuffer);

   321     

   322     // ------------------------- Results Buffer ---------------------

   323 

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

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

   326 

   327     // --------------------------------------------------------------      

   328 

   329     // Initiate the search

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

   331                      searchResultsBuffer->Des());

   332 

   333     // Parse the results

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

   335     resultStream.PushL();

   336 

   337     // Number of results

   338     TInt seqCount = resultStream.ReadUint16L();

   339 

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

   341 

   342     // Internalize each char seq

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

   344         {

   345         // Size of sequence

   346         TInt szSeq = resultStream.ReadUint16L();

   347 

   348         // Character sequence

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

   350 

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

   352 

   353         CleanupStack::PopAndDestroy();

   354         }

   355 

   356     // --------- match sequence location ------------------    

   357     // number of results

   358     TInt count = resultStream.ReadUint16L();

   359 

   360     // read each data struct

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

   362         {

   363         TPsMatchLocation matchLoc;

   364 

   365         matchLoc.index = resultStream.ReadUint16L();

   366         matchLoc.length = resultStream.ReadUint16L();

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

   368 

   369         aMatchLocation.Append(matchLoc);

   370         }

   371 

   372     //cleanup

   373     CleanupStack::PopAndDestroy(4, searchQueryBuffer); 

   374     // resultStream, searchResultsBuffer, searchDataBuffer, searchQueryBuffer

   375 	

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

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

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

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

   380     }

   381 

   382 // -----------------------------------------------------------------------------

   383 // CPSRequestHandler::LookupMatchL()

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

   385 // -----------------------------------------------------------------------------

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

   387                                                const TDesC& aSearchData,

   388                                                TDes& aMatch )

   389     {

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

   391 

   392     // ----------------------- Search Query ----------------------

   393 

   394     // Tmp buffer        

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

   396     CleanupStack::PushL(buf);

   397 

   398     // Stream over the temp buffer

   399     RBufWriteStream stream(*buf);

   400     stream.PushL();

   401 

   402     // Write the search query to the stream

   403     aSearchQuery.ExternalizeL(stream);

   404     stream.CommitL();

   405 

   406     // Create a HBufC8 for IPC

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

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

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

   410     

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

   412     CleanupStack::PushL(searchQueryBuffer);

   413 

   414     // ----------------------- Search Data ----------------------

   415 

   416     // Tmp buffer        

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

   418     CleanupStack::PushL(dataBuf);

   419 

   420     // Stream over the temp buffer

   421     RBufWriteStream dataStream(*dataBuf);

   422     dataStream.PushL();

   423 

   424     // Write the search data to the stream

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

   426     dataStream << aSearchData;

   427 

   428     // Create a HBufC8 for IPC

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

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

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

   432 

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

   434     CleanupStack::PushL(searchDataBuffer);      

   435 

   436     // Initiate the search

   437     iSession.SearchMatchStringL( 

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

   439 

   440     //cleanup

   441     CleanupStack::PopAndDestroy(searchDataBuffer);

   442     CleanupStack::PopAndDestroy(searchQueryBuffer); 

   443     

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

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

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

   447     }

   448 

   449 // -----------------------------------------------------------------------------

   450 // CPSRequestHandler::SearchL()

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

   452 // -----------------------------------------------------------------------------

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

   454                                          RPointerArray<CPsClientData>& aMarkedContacts,

   455                                          CVPbkContactManager* aContactManager)

   456     {

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

   458 

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

   460     SearchL(aSearchQuery);

   461 

   462     // Clear the bookmarked contacts if any

   463     iMarkedContacts.Reset();

   464 

   465     // Copy the contact manager

   466     iBookMarkContactManager = aContactManager;

   467 

   468     // Copy the bookmarked contacts

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

   470         {

   471         iMarkedContacts.Append(aMarkedContacts[i]);

   472         }

   473 

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

   475     }

   476 

   477 // -----------------------------------------------------------------------------

   478 // CPSRequestHandler::CancelSearch()

   479 // Cancels ongoing search.

   480 // -----------------------------------------------------------------------------

   481 EXPORT_C void CPSRequestHandler::CancelSearch()

   482     {

   483     if( IsActive() )

   484         {

   485         iSearchRequestCancelled = ETrue;

   486         }

   487     

   488     if( iPendingSearchQueryBuffer )

   489         {

   490         delete iPendingSearchQueryBuffer;

   491         iPendingSearchQueryBuffer = NULL;

   492         }

   493     

   494     iSession.CancelSearch();

   495     }

   496 

   497 // -----------------------------------------------------------------------------

   498 // CPSRequestHandler::HandleSearchResultsL()

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

   500 // -----------------------------------------------------------------------------

   501 void CPSRequestHandler::HandleSearchResultsL()

   502     {

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

   504 

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

   506     RPointerArray<CPsClientData> searchResults;

   507     RPointerArray<CPsPattern> searchSeqs;

   508 

   509     if( !iSearchResultsBuffer )

   510         {

   511         return;

   512         }

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

   514     stream.PushL();

   515 

   516     // Number of results

   517     TInt count = stream.ReadInt32L();

   518 

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

   520 

   521     // Internalize each data element

   522     for (TInt i = 0; i < count; i++)

   523         {

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

   525         CleanupStack::PushL(data);

   526 

   527         data->InternalizeL(stream);

   528 

   529         CleanupStack::Pop(data);

   530         searchResults.Append(data);

   531         }

   532 

   533     // Check if book marked contacts are there

   534     TInt nBookmark = 0;

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

   536         {

   537         nBookmark = AddMarkedContactsL(searchResults);

   538         }

   539     

   540 #ifdef _DEBUG

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

   542         {

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

   544             {

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

   546                 {

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

   548                          i, j, &*(searchResults[i]->Data(j)) );

   549                 }       

   550             }

   551         }    

   552 #endif // _DEBUG

   553 

   554     // Read number of character sequences

   555     TInt seqCount = stream.ReadInt32L();

   556 

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

   558 

   559     // Internalize each char seq

   560     for (TInt i = 0; i < seqCount; i++)

   561         {

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

   563         CleanupStack::PushL(pattern);

   564 

   565         pattern->InternalizeL(stream);

   566 

   567         CleanupStack::Pop();

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

   569             {

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

   571             }

   572         searchSeqs.Append(pattern);

   573         }

   574 

   575     CleanupStack::PopAndDestroy( &stream );

   576 

   577     // Pass the results to the observer

   578     for (TInt i = 0; i < iObservers.Count(); i++)

   579         {

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

   581         }

   582 

   583     // Clear all the internal buffers

   584     searchResults.ResetAndDestroy();

   585     searchSeqs.ResetAndDestroy();

   586     delete iSearchQueryBuffer;

   587     iSearchQueryBuffer = NULL;

   588     delete iSearchResultsBuffer;

   589     iSearchResultsBuffer = NULL;

   590 

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

   592 

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

   594     }

   595 

   596 // -----------------------------------------------------------------------------

   597 // CPSRequestHandler::RunSearchFromBufferL()

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

   599 // -----------------------------------------------------------------------------

   600 void CPSRequestHandler::RunSearchFromBufferL()

   601     {

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

   603 

   604     if( iPendingSearchQueryBuffer )

   605         {

   606         if (iSearchQueryBuffer)

   607             {

   608             delete iSearchQueryBuffer;

   609             iSearchQueryBuffer = NULL;

   610             }

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

   612         CleanupStack::Pop();

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

   614 

   615         delete iPendingSearchQueryBuffer;

   616         iPendingSearchQueryBuffer = NULL;

   617 

   618         // ------------------------- Results Buffer ---------------------

   619 

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

   621         if (iSearchResultsBuffer)

   622             {

   623             delete iSearchResultsBuffer;

   624             iSearchResultsBuffer = NULL;

   625             }

   626         iSearchResultsBuffer = HBufC8::NewL(KSearchResultsBufferLen);

   627 

   628         // --------------------------------------------------------------      

   629 

   630         // Initiate the search

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

   632 

   633         SetActive();

   634         }

   635    

   636     

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

   638     }

   639 

   640 // -----------------------------------------------------------------------------

   641 // CPSRequestHandler::AddBookMarkedContacts()

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

   643 // -----------------------------------------------------------------------------

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

   645     {

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

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

   648 

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

   650     TInt nBookmark = 0;

   651 

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

   653         {

   654         MVPbkContactLink* bookMarkLink = NULL;

   655 

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

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

   658 

   659         TInt j = 0;

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

   661             {

   662             if (id > 0)

   663                 {

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

   665                     {

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

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

   668                     }

   669                 else

   670                     {

   671                     continue;

   672                     }

   673                 }

   674             else

   675                 {

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

   677                     {

   678                     continue;

   679                     }

   680                 else

   681                     {

   682                     if (!bookMarkLink)

   683                         {

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

   685                                                            *iBookMarkContactManager);

   686                         CleanupStack::Pop(); //  bookMarkLink  

   687                         }

   688 

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

   690                                                                               *iBookMarkContactManager);

   691                     CleanupStack::Pop(); // searchContactLink

   692 

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

   694                         {

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

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

   697                         }

   698                     else

   699                         continue;

   700                     }

   701                 }

   702             }

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

   704             {

   705             filteredBookMarkList.Append(iMarkedContacts[i]);

   706             }

   707         }

   708 

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

   710     // and prepend them to the actual result set

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

   712 

   713     nBookmark = filteredBookMarkList.Count();

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

   715         {

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

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

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

   719 

   720         // Add the data fields

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

   722             {

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

   724             }

   725 

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

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

   728 

   729         searchResults.Insert(temp, 0);

   730         }

   731 

   732     // Free the bookmark arrays

   733     iMarkedContacts.Reset();

   734     filteredBookMarkList.Reset();

   735 

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

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

   738     return nBookmark;

   739     }

   740 

   741 // -----------------------------------------------------------------------------

   742 // CPSRequestHandler::HandleBufferOverFlowL()

   743 // Handle the buffer overflow error

   744 // -----------------------------------------------------------------------------

   745 void CPSRequestHandler::HandleBufferOverFlowL()

   746     {

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

   748 

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

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

   751     stream.PushL();

   752 

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

   754     TInt bufferSize = stream.ReadInt32L();

   755 

   756     CleanupStack::PopAndDestroy(); // stream

   757 

   758     // Delete and recreate the results buffer

   759     if (iSearchResultsBuffer)

   760         {

   761         delete iSearchResultsBuffer;

   762         iSearchResultsBuffer = NULL;

   763         }

   764 

   765     // Buffer created for the new size

   766     iSearchResultsBuffer = HBufC8::NewL(bufferSize);

   767 

   768     // Recover the search results 

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

   770 

   771     SetActive();

   772 

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

   774     }

   775 

   776 // -----------------------------------------------------------------------------

   777 // CPSRequestHandler::RunL()

   778 // Invoked to handle responses from the server.

   779 // -----------------------------------------------------------------------------

   780 void CPSRequestHandler::RunL()

   781     {

   782     switch (iStatus.Int())

   783         {

   784         case ESearchComplete:

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

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

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

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

   789             if( iSearchRequestCancelled )

   790                 {

   791                 RunSearchFromBufferL();

   792                 }

   793             else

   794                 {

   795                 HandleSearchResultsL();

   796                 }

   797             break;

   798         

   799         case KErrOverflow:

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

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

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

   803             if( iSearchRequestCancelled )

   804                 {

   805                 RunSearchFromBufferL();

   806                 }

   807             else

   808                 {

   809                 HandleBufferOverFlowL();

   810                 }

   811             break;

   812         

   813         case ECancelComplete:

   814         case KErrCancel:

   815             // The search request was canceled

   816             if( iPendingSearchQueryBuffer )

   817                 {

   818                 RunSearchFromBufferL();

   819                 }

   820             break;

   821 

   822         default:

   823             // Errors

   824             HandleErrorL(iStatus.Int());

   825         }

   826     iSearchRequestCancelled = EFalse;

   827     }

   828 

   829 // -----------------------------------------------------------------------------

   830 // CPSRequestHandler::HandleErrorL()

   831 // Send the error code to the client.

   832 // -----------------------------------------------------------------------------

   833 void CPSRequestHandler::HandleErrorL(TInt aErrorCode)

   834     {

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

   836         {

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

   838         }

   839     }

   840 

   841 // -----------------------------------------------------------------------------

   842 // CPSRequestHandler::DoCancel()

   843 // Cancels any outstanding operation.

   844 // -----------------------------------------------------------------------------

   845 void CPSRequestHandler::DoCancel()

   846     {

   847     iSession.CancelSearch();

   848     }

   849 

   850 // -----------------------------------------------------------------------------

   851 // CPSRequestHandler::Version()

   852 // Recovers the predictive search server version.

   853 // -----------------------------------------------------------------------------

   854 EXPORT_C TVersion CPSRequestHandler::Version() const

   855     {

   856     return (iSession.Version());

   857     }

   858 

   859 // -----------------------------------------------------------------------------

   860 // CPSRequestHandler::ShutdownServerL()

   861 // Shuts down the predictive search engine.

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

   863 EXPORT_C void CPSRequestHandler::ShutdownServerL()

   864     {

   865     return (iSession.ShutdownServerL());

   866     }

   867 

   868 // -----------------------------------------------------------------------------

   869 // CPSRequestHandler::IsLanguageSupportedL()

   870 // Checks if the language variant is supported by 

   871 // the predictive search engine.

   872 // -----------------------------------------------------------------------------

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

   874     {

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

   876 

   877     // ----------------------- language id----------------------

   878 

   879     // Tmp buffer        

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

   881     CleanupStack::PushL(dataBuf);

   882 

   883     // Stream over the temp buffer

   884     RBufWriteStream dataStream(*dataBuf);

   885     dataStream.PushL();

   886 

   887     // Write the language id to the stream

   888     dataStream.WriteUint32L(aLanguage);

   889 

   890     // Create a HBufC8 for IPC

   891     if (iSearchDataBuffer)

   892         {

   893         delete iSearchDataBuffer;

   894         iSearchDataBuffer = NULL;

   895         }

   896 

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

   898     CleanupStack::Pop(); // iSearchDataBuffer

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

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

   901 

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

   903 

   904     // ------------------------- Results Buffer ---------------------

   905 

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

   907     if (iSearchResultsBuffer)

   908         {

   909         delete iSearchResultsBuffer;

   910         iSearchResultsBuffer = NULL;

   911         }

   912     iSearchResultsBuffer = HBufC8::NewL(KBufferMaxLen);

   913 

   914     // -------------------------------------------------------------- 

   915     // Send the request

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

   917 

   918     // parse the result

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

   920     resultStream.PushL();

   921 

   922     // result ETrue or EFalse

   923     TBool flag = resultStream.ReadUint8L();

   924 

   925     CleanupStack::PopAndDestroy(); // resultStream

   926 

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

   928     return flag;

   929     }

   930 

   931 // -----------------------------------------------------------------------------

   932 // CPSRequestHandler::GetCachingStatusL()

   933 // Gets the status of the caching synchronously

   934 // -----------------------------------------------------------------------------

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

   936     {

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

   938 

   939     // Get the status from property handler

   940     // No need to send the request to engine

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

   942 

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

   944     return cacheError;

   945     }

   946 

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

   948 // CPSRequestHandler::ConvertToVpbkLinkLC()

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

   950 // -----------------------------------------------------------------------------

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

   952                                                                   CVPbkContactManager& aContactManager)

   953     {

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

   955 

   956     MVPbkContactLink* contactLink = NULL;

   957 

   958     // Get the originating uri for this result    

   959     HBufC* URI = aPsData.Uri();

   960 

   961     // Leave if not in contacts domain

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

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

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

   965         {

   966         User::Leave(KErrNotSupported);

   967         }

   968 

   969     // Create converter instance if not already available	

   970     if (iConverter == NULL)

   971         {

   972         // Get the store corresponding to the URI

   973         MVPbkContactStoreList& storeList = aContactManager.ContactStoresL();

   974         TVPbkContactStoreUriPtr uriPtr(KVPbkDefaultCntDbURI);

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

   976 

   977         // Create converter 			

   978         if (store)

   979             {

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

   981             }

   982         }

   983 

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

   985         {

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

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

   988 

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

   990 

   991         if (linkBuf->Length())

   992             {

   993             // Get the store corresponding to the URI

   994             MVPbkContactStoreList& storeList = aContactManager.ContactStoresL();

   995 

   996             // Link array

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

   998 

   999             TInt count = array->Count();

  1000 

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

  1002                 {

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

  1004                 contactLink = link.CloneLC();

  1005                 CleanupStack::Pop(); // contactLink

  1006                 }

  1007 

  1008             CleanupStack::PopAndDestroy(); // array	

  1009             }

  1010 

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

  1012         }

  1013     else

  1014         {

  1015         // cntdb domain

  1016         if (iConverter)

  1017             {

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

  1019             CleanupStack::Pop();

  1020             }

  1021         }

  1022 

  1023     // Add to cleanup stack

  1024     CleanupDeletePushL(contactLink);

  1025 

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

  1027 

  1028     return contactLink;

  1029 

  1030     }

  1031 

  1032 // -----------------------------------------------------------------------------

  1033 // CPSRequestHandler::GetAllContentsL()

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

  1035 // -----------------------------------------------------------------------------

  1036 EXPORT_C void CPSRequestHandler::GetAllContentsL()

  1037     {

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

  1039 

  1040     // Create a empty CPsQuery

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

  1042 

  1043     // Perform a search

  1044     SearchL(*query);

  1045 

  1046     // Cleanup

  1047     delete query;

  1048 

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

  1050     }

  1051 

  1052 // -----------------------------------------------------------------------------

  1053 // CPSRequestHandler::GetDataOrderL()

  1054 // 

  1055 // -----------------------------------------------------------------------------

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

  1057         RArray<TInt>& aDataOrder)

  1058     {

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

  1060 

  1061     // ----------------------- URI ----------------------

  1062 

  1063     // Tmp buffer        

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

  1065     CleanupStack::PushL(dataBuf);

  1066 

  1067     // Stream over the temp buffer

  1068     RBufWriteStream dataStream(*dataBuf);

  1069     dataStream.PushL();

  1070 

  1071     // Write the URI details in the stream

  1072     TInt length = aURI.Length();

  1073     dataStream.WriteUint16L(length);

  1074     dataStream << aURI;

  1075 

  1076     // Create a HBufC8 for IPC

  1077     if (iSearchDataBuffer)

  1078         {

  1079         delete iSearchDataBuffer;

  1080         iSearchDataBuffer = NULL;

  1081         }

  1082 

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

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

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

  1086 

  1087     // ------------------------- Results Buffer ---------------------

  1088 

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

  1090     if (iSearchResultsBuffer)

  1091         {

  1092         delete iSearchResultsBuffer;

  1093         iSearchResultsBuffer = NULL;

  1094         }

  1095     iSearchResultsBuffer = HBufC8::NewL(KBufferMaxLen);

  1096 

  1097     // --------------------------------------------------------------      

  1098 

  1099     // Send the request

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

  1101 

  1102     // Parse the results

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

  1104     resultStream.PushL();

  1105 

  1106     // Number of fields

  1107     TInt fieldCount = resultStream.ReadUint16L();

  1108 

  1109     // Fields

  1110     for (TInt i = 0; i < fieldCount; i++)

  1111         {

  1112         TInt fieldId = resultStream.ReadUint16L();

  1113         aDataOrder.Append(fieldId);

  1114         }

  1115 

  1116     // Cleanup

  1117     delete iSearchResultsBuffer;

  1118     delete iSearchDataBuffer;

  1119     CleanupStack::PopAndDestroy(3, dataBuf); // resultStream, dataStream, dataBuf

  1120     iSearchResultsBuffer = NULL;

  1121     iSearchDataBuffer = NULL;

  1122 

  1123     PRINT ( _L("End CPSRequestHandler::GetDataOrderL") );

  1124 

  1125     }

  1126 

  1127 // -----------------------------------------------------------------------------

  1128 // CPSRequestHandler::GetSortOrderL()

  1129 // 

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

  1131 EXPORT_C void CPSRequestHandler::GetSortOrderL(const TDesC& aURI, RArray<TInt>& aDataOrder)

  1132     {

  1133     PRINT ( _L("Enter CPSRequestHandler::GetSortOrderL") );

  1134