contacts_plat/predictivesearch_client_api/inc/CPsRequestHandler.h
branchRCL_3
changeset 39 a6539d1e8e43
parent 35 4ae315f230bc
child 64 c1e8ba0c2b16
equal deleted inserted replaced
35:4ae315f230bc 39:a6539d1e8e43
     9 * Initial Contributors:
     9 * Initial Contributors:
    10 * Nokia Corporation - initial contribution.
    10 * Nokia Corporation - initial contribution.
    11 *
    11 *
    12 * Contributors:
    12 * Contributors:
    13 *
    13 *
    14 * Description:  This is the client side interface declaration for the 
    14 * Description: This is the client side interface declaration for the
    15 *                predictive search server.
    15 *              predictive search server.
    16 *
    16 *
    17 */
    17 */
    18 
    18 
    19 
    19 
    20 #ifndef __CPSREQUESTHANDLER_H__
    20 #ifndef __CPSREQUESTHANDLER_H__
    60 * @since S60 v3.2
    60 * @since S60 v3.2
    61 */
    61 */
    62 class CPSRequestHandler : public CActive
    62 class CPSRequestHandler : public CActive
    63 {
    63 {
    64 
    64 
    65 	public: // Constructors and destructors
    65     public: // Constructors and destructors
    66 
    66 
    67 		/**
    67         /**
    68 		* NewL.
    68         * NewL.
    69 		* Two-phased constructor.
    69         * Two-phased constructor.
    70 		* Creates a CPSRequestHandler object using two phase construction,
    70         * Creates a CPSRequestHandler object using two phase construction,
    71 		* and return a pointer to the created object.
    71         * and return a pointer to the created object.
    72 		*
    72         *
    73 		* @return A pointer to the created instance of CPSRequestHandler.
    73         * @return A pointer to the created instance of CPSRequestHandler.
    74 		*/
    74         */
    75 		IMPORT_C static CPSRequestHandler* NewL();
    75         IMPORT_C static CPSRequestHandler* NewL();
    76 
    76 
    77 		/**
    77         /**
    78 		* NewLC.
    78         * NewLC.
    79 		* Two-phased constructor.
    79         * Two-phased constructor.
    80 		* Creates a CPSRequestHandler object using two phase construction,
    80         * Creates a CPSRequestHandler object using two phase construction,
    81 		* and return a pointer to the created object.
    81         * and return a pointer to the created object.
    82 		*	
    82         *
    83 		* @return A pointer to the created instance of CPSRequestHandler.
    83         * @return A pointer to the created instance of CPSRequestHandler.
    84 		*/
    84         */
    85 		IMPORT_C static CPSRequestHandler* NewLC();
    85         IMPORT_C static CPSRequestHandler* NewLC();
    86 
    86 
    87 		/**
    87         /**
    88 		* ~CPSRequestHandler.
    88         * ~CPSRequestHandler.
    89 		* Destructor.
    89         * Destructor.
    90 		* Destroys the object and release all memory objects.
    90         * Destroys the object and release all memory objects.
    91 		*/
    91         */
    92 		virtual ~CPSRequestHandler();
    92         virtual ~CPSRequestHandler();
    93 
    93 
    94 	public: // New functions
    94     public: // New functions
    95 
    95 
    96 		/**
    96         /**
    97 		* Version.
    97         * Version.
    98 		* Returns the predictive search server version.
    98         * Returns the predictive search server version.
    99 		*
    99         *
   100 		* @return The current version of predictive search server.
   100         * @return The current version of predictive search server.
   101 		*/
   101         */
   102 		IMPORT_C TVersion Version() const;		
   102         IMPORT_C TVersion Version() const;
   103 		
   103 
   104 		/**
   104         /**
   105 		* AddObserver.
   105         * AddObserver.
   106 		*
   106         *
   107 		* @param aObserver The object to be used to handle updates 
   107         * @param aObserver The object to be used to handle updates
   108 		* from the server.
   108         * from the server.
   109 		*/
   109         */
   110 		IMPORT_C void AddObserverL ( MPsResultsObserver* aObserver );
   110         IMPORT_C void AddObserverL( MPsResultsObserver* aObserver );
   111 		
   111 
   112 		/**
   112         /**
   113 		* RemoveObserverL.
   113         * RemoveObserverL.
   114 		*
   114         *
   115 		* @param aObserver The object used to handle updates from the server.
   115         * @param aObserver The object used to handle updates from the server.
   116 		* @return KErrNone if removed.
   116         * @return KErrNone if removed.
   117 		*         KErrNotFound if observer not added already.
   117         *         KErrNotFound if observer not added already.
   118 		*/
   118         */
   119 		IMPORT_C TInt RemoveObserver ( MPsResultsObserver* aObserver );
   119         IMPORT_C TInt RemoveObserver( MPsResultsObserver* aObserver );
   120 
   120 
   121 		/**
   121         /**
   122 		* SetSearchSettingsL.
   122         * SetSearchSettingsL.
   123 		* Set the databases and fields to be included in search.
   123         * Set the databases and fields to be included in search.
   124 		* Databases ids are mapped to virtual phone book URLs.
   124         * Databases ids are mapped to virtual phone book URLs.
   125 		* Fields to be searched are mapped to virutal phonebook identifiers.
   125         * Fields to be searched are mapped to virutal phonebook identifiers.
   126 		*
   126         *
   127 		* @param aSettings Holds the search settings.
   127         * @param aSettings Holds the search settings.
   128 		*/
   128         */
   129 		IMPORT_C void SetSearchSettingsL(const CPsSettings& aSettings);
   129         IMPORT_C void SetSearchSettingsL( const CPsSettings& aSettings );
   130 
   130 
   131 		/**
   131         /**
   132 		* GetAllContentsL. 
   132         * GetAllContentsL.
   133 		* Sends a request to the predictive search server to get all cached contents.
   133         * Sends a request to the predictive search server to get all cached contents.
   134 		* This is a asynchronous request.
   134         * This is a asynchronous request.
   135 		*/
   135         */
   136 		IMPORT_C void GetAllContentsL();
   136         IMPORT_C void GetAllContentsL();
   137 
   137 
   138 		/**
   138         /**
   139 		* SearchL. 
   139         * SearchL.
   140 		* Sends a request to the predictive search server.
   140         * Sends a request to the predictive search server.
   141 		* This is a asynchronous request.
   141         * This is a asynchronous request.
   142 		* 
   142         *
   143 		* @param aSearchQuery The input search query.(Length of aSearchQuery <= KPsQueryMaxLen)
   143         * @param aSearchQuery The input search query.(Length of aSearchQuery <= KPsQueryMaxLen)
   144 		* @param aStatus      Holds the completion status of search request.
   144         * @param aStatus      Holds the completion status of search request.
   145 		*/
   145         */
   146 		IMPORT_C void SearchL(const CPsQuery& aSearchQuery);
   146         IMPORT_C void SearchL( const CPsQuery& aSearchQuery );
   147 		
   147 
   148 		/**
   148         /**
   149 		* SearchL. 
   149         * SearchL.
   150 		* Sends a request to the predictive search server.
   150         * Sends a request to the predictive search server.
   151 		* This is a asynchronous request. It considers bookmarked contacts 
   151         * This is a asynchronous request. It considers bookmarked contacts
   152 		* while sending the results back to the client
   152         * while sending the results back to the client
   153 		* 
   153         *
   154 		* @param aSearchQuery 		The input search query.(Length of aSearchQuery <= KPsQueryMaxLen)
   154         * @param aSearchQuery    The input search query.(Length of aSearchQuery <= KPsQueryMaxLen)
   155 		* @param aMarkedContacts    Array of marked contacts
   155         * @param aMarkedContacts Array of marked contacts
   156 		* @param aContactManager	Contact manager instance
   156         * @param aContactManager Contact manager instance
   157 		*/
   157         */
   158 		IMPORT_C void SearchL(const CPsQuery& aSearchQuery, 
   158         IMPORT_C void SearchL( const CPsQuery& aSearchQuery,
   159 							  RPointerArray<CPsClientData>& aMarkedContacts,
   159                                RPointerArray<CPsClientData>& aMarkedContacts,
   160 							  CVPbkContactManager* aContactManager);
   160                                CVPbkContactManager* aContactManager );
   161 		
   161 
   162         /**
   162         /**
   163         * CancelSearch.
   163         * CancelSearch.
   164         * Cancels ongoing search.
   164         * Cancels ongoing search.
   165         */
   165         */
   166 		IMPORT_C void CancelSearch();
   166         IMPORT_C void CancelSearch();
   167 		
   167 
   168 		/**
   168         /**
   169 		* LookupL. 
   169         * LookupL.
   170 		* Sends a request to the predictive search server.
   170         * Sends a request to the predictive search server.
   171 		* Does a predictive search in aSearchData for aSearchQuery and return
   171         * Does a predictive search in aSearchData for aSearchQuery and return
   172 		* the matches.
   172         * the matches.
   173 		* This is a synchronous request.
   173         * This is a synchronous request.
   174 		* 
   174         *
   175 		* @param aSearchQuery The input search query.(Length of aSearchQuery <= KPsQueryMaxLen)
   175         * @param aSearchQuery   The input search query.(Length of aSearchQuery <= KPsQueryMaxLen)
   176 		* @param aSearchData  The input data to be searched.
   176         * @param aSearchData    The input data to be searched.
   177 		* @param aMatchSet    The list of matches.
   177         * @param aMatchSet      The list of matches.
   178 		* @param aMatchLocation The list matched index and length of match
   178         * @param aMatchLocation The list matched index and length of match
   179 		*/
   179         */
   180 		IMPORT_C void LookupL(const CPsQuery& aSearchQuery,
   180         IMPORT_C void LookupL( const CPsQuery& aSearchQuery,
   181                               const TDesC& aSearchData,
   181                                const TDesC& aSearchData,
   182                               CDesCArray& aMatchSet,
   182                                CDesCArray& aMatchSet,
   183                               RArray<TPsMatchLocation>& aMatchLocation);
   183                                RArray<TPsMatchLocation>& aMatchLocation );
   184 
   184 
   185         /**
   185         /**
   186         * LookupMatchL. 
   186         * LookupMatchL.
   187         * Sends a request to the predictive search server.
   187         * Sends a request to the predictive search server.
   188         * Does a predictive search in aSearchData for aSearchQuery and return
   188         * Does a predictive search in aSearchData for aSearchQuery and return
   189         * the match string in aMatch.
   189         * the match string in aMatch.
   190         * If there is no full match aMatch will be empty (Length()==0)
   190         * If there is no full match aMatch will be empty (Length()==0)
   191         * This is a synchronous request.
   191         * This is a synchronous request.
   192         * 
   192         *
   193         * @param aSearchQuery The input search query.(Length of aSearchQuery <= KPsQueryMaxLen)
   193         * @param aSearchQuery The input search query.(Length of aSearchQuery <= KPsQueryMaxLen)
   194         * @param aSearchData  The input data to be searched.
   194         * @param aSearchData  The input data to be searched.
   195         * @param aMatch       The matched result
   195         * @param aMatch       The matched result
   196         */
   196         */
   197         IMPORT_C void LookupMatchL(const CPsQuery& aSearchQuery,
   197         IMPORT_C void LookupMatchL( const CPsQuery& aSearchQuery,
   198                                    const TDesC& aSearchData,
   198                                     const TDesC& aSearchData,
   199                                    TDes& aMatch);
   199                                     TDes& aMatch );
   200 		
   200 
   201 		/**
   201         /**
   202 		* IsLanguageSupportedL.
   202         * IsLanguageSupportedL.
   203 		* Checks if the language variant is supported by 
   203         * Checks if the language variant is supported by
   204 		* the predictive search engine.
   204         * the predictive search engine.
   205 		* This is a synchronous request.
   205         * This is a synchronous request.
   206 		*
   206         *
   207 		* @param aLanguage The language which has to be checked
   207         * @param aLanguage The language which has to be checked
   208 		* @return ETrue if the language specified is supported by PS engine
   208         * @return ETrue if the language specified is supported by PS engine
   209 		*         EFalse otherwise
   209         *         EFalse otherwise
   210 		* 
   210         *
   211 		*/ 
   211         */
   212 		IMPORT_C TBool IsLanguageSupportedL(const TLanguage aLanguage);
   212         IMPORT_C TBool IsLanguageSupportedL( const TLanguage aLanguage );
   213 
   213 
   214 		/**
   214         /**
   215 		* GetCachingStatusL
   215         * GetCachingStatusL
   216 		* Gets the status of the caching synchronously
   216         * Gets the status of the caching synchronously
   217 		*
   217         *
   218 		* @param aResultsBuffer Pointer to the result buffer.
   218         * @param aResultsBuffer Pointer to the result buffer.
   219 		*/   
   219         */
   220 		IMPORT_C TInt GetCachingStatusL(TCachingStatus& aStatus);
   220         IMPORT_C TInt GetCachingStatusL( TCachingStatus& aStatus );
   221 
   221 
   222 		/**
   222         /**
   223 		* ConvertToVpbkLinkLC.
   223         * ConvertToVpbkLinkLC.
   224 		* Extract the VPBK contact link associated with the search result.
   224         * Extract the VPBK contact link associated with the search result.
   225 		* This is a synchronous request.
   225         * This is a synchronous request.
   226 		*
   226         *
   227 		* @param aSearchResult PS result for which contact link is required.
   227         * @param aSearchResult PS result for which contact link is required.
   228 		* @param aContactManager An instance of contact manager used for link extraction.
   228         * @param aContactManager An instance of contact manager used for link extraction.
   229 		* @return The contact link.
   229         * @return The contact link.
   230 		*/
   230         */
   231 		IMPORT_C MVPbkContactLink* ConvertToVpbkLinkLC( const CPsClientData& aSearchResult,
   231         IMPORT_C MVPbkContactLink* ConvertToVpbkLinkLC( const CPsClientData& aSearchResult,
   232 		                                                CVPbkContactManager& aContactManager );
   232                                                         CVPbkContactManager& aContactManager );
   233 		    
   233 
   234         /**
   234         /**
   235         * GetDataOrderL.
   235         * GetDataOrderL.
   236         * This function returns the list of supported data fields (mapped to VPbk identifiers)
   236         * This function returns the list of supported data fields (mapped to VPbk identifiers)
   237         * supported by a datastore.
   237         * supported by a datastore.
   238         * This is a synchronous request.
   238         * This is a synchronous request.
   239         * 
   239         *
   240         * @param aDataStore The data store URI.
   240         * @param aDataStore The data store URI.
   241         * @param aDataOrder This array has the field identifiers returned from the server.
   241         * @param aDataOrder This array has the field identifiers returned from the server.
   242         */
   242         */
   243         IMPORT_C void GetDataOrderL(const TDesC& aDataStore, RArray<TInt>& aDataOrder);
   243         IMPORT_C void GetDataOrderL( const TDesC& aDataStore, RArray<TInt>& aDataOrder );
   244         
   244 
   245         /**
   245         /**
   246         * GetSortOrderL.
   246         * GetSortOrderL.
   247         * This function returns the sort order of data fields (mapped to VPbk identifiers)
   247         * This function returns the sort order of data fields (mapped to VPbk identifiers)
   248         * set on a datastore.
   248         * set on a datastore.
   249         * This is a synchronous request.
   249         * This is a synchronous request.
   250         * 
   250         *
   251         * @param aDataStore The data store URI.
   251         * @param aDataStore The data store URI.
   252         * @param aSortOrder This array has the field identifiers returned from the server.
   252         * @param aSortOrder This array has the field identifiers returned from the server.
   253         */
   253         */
   254         IMPORT_C void GetSortOrderL(const TDesC& aDataStore, RArray<TInt>& aSortOrder);
   254         IMPORT_C void GetSortOrderL( const TDesC& aDataStore, RArray<TInt>& aSortOrder );
   255         
   255 
   256         /**
   256         /**
   257         * ChangeSortOrderL.
   257         * ChangeSortOrderL.
   258         * This function sets the sort order of data fields (mapped to VPbk identifiers)
   258         * This function sets the sort order of data fields (mapped to VPbk identifiers)
   259         * on a datastore.
   259         * on a datastore.
   260         * This is a synchronous request.
   260         * This is a synchronous request.
   261         * 
   261         *
   262         * @param aDataStore The data store URI.
   262         * @param aDataStore The data store URI.
   263         * @param aSortOrder This array has the field identifiers to be set for this store.
   263         * @param aSortOrder This array has the field identifiers to be set for this store.
   264         */
   264         */
   265         IMPORT_C void ChangeSortOrderL(const TDesC& aDataStore, RArray<TInt>& aSortOrder);
   265         IMPORT_C void ChangeSortOrderL( const TDesC& aDataStore, RArray<TInt>& aSortOrder );
   266                 
   266 
   267         /**
   267         /**
   268 		* ShutdownServerL
   268         * GetAdaptiveGridCharactersL.
   269 		* Shuts down the predictive search engine.
   269         * This is a support method for Adaptive Search functionality.
   270 		*
   270         * As Predictive Search Engine is well suited for keeping an maintaining data
   271 		* CAUTION: Shutdown of predictive search server shouldn't be done for each
   271         * structures related to contacts and updated according to contacts
   272 		* session. It should be done only when the search engine needs to be 
   272         * additions/modifications/deletions, like it is done already in Predictive Search
   273 		* completely shutdown.
   273         * Engine.
   274 		*/
   274         *
   275 		IMPORT_C void ShutdownServerL();
   275         * @param aDataStores   The data store URIs.
   276 
   276         * @param aSearchText   The text in the find box.
   277 	protected: // Functions from base classes
   277         * @param aCompanyName  The info if Company Name is required.
   278 
   278         * @param aAdaptiveGrid The returned Adaptive Grid.
   279 		/**
   279         */
   280 		* From CActive, RunL.
   280         IMPORT_C void GetAdaptiveGridCharactersL( const MDesCArray& aDataStores,
   281 		* Callback function.
   281                                                   const TDesC& aSearchText,
   282 		* Invoked to handle responses from the server.
   282                                                   const TBool aCompanyName,
   283 		*/
   283                                                   TDes& aAdaptiveGrid );
   284 		void RunL();
   284 
   285 
   285         /**
   286 		/**
   286         * ShutdownServerL
   287 		* From CActive, DoCancel.
   287         * Shuts down the predictive search engine.
   288 		* Cancels any outstanding operation.
   288         *
   289 		*/
   289         * CAUTION: Shutdown of predictive search server shouldn't be done for each
   290 		void DoCancel();
   290         * session. It should be done only when the search engine needs to be
   291 
   291         * completely shutdown.
   292 	public:
   292         */
   293 	
   293         IMPORT_C void ShutdownServerL();
   294 		/**
   294 
   295 		* Notify observers about the cahcing status
   295     protected: // Functions from base classes
   296 		*/
   296 
   297 		void NotifyCachingStatus( TCachingStatus aStatus, TInt aError );
   297         /**
   298     	
   298         * From CActive, RunL.
   299 	private: // Constructors and destructors
   299         * Callback function.
   300 
   300         * Invoked to handle responses from the server.
   301 		/**
   301         */
   302 		* CPSRequestHandler.
   302         void RunL();
   303 		* Performs the first phase of two phase construction.
   303 
   304 		*/
   304         /**
   305 		CPSRequestHandler();
   305         * From CActive, DoCancel.
   306 
   306         * Cancels any outstanding operation.
   307 		/**
   307         */
   308 		* ConstructL.
   308         void DoCancel();
   309 		* Performs the second phase construction of a
   309 
   310 		* CPSRequestHandler object.
   310     public:
   311 		*/
   311 
   312 		void ConstructL();
   312         /**
   313 
   313         * Notify observers about the cahcing status
   314 	private: // Internal data handlers
   314         */
   315 
   315         void NotifyCachingStatus( TCachingStatus aStatus, TInt aError );
   316 		/**
   316 
   317 		* ParseResultsL.
   317     private: // Constructors and destructors
   318 		* Parses the results buffer and converts them to data elements.
   318 
   319 		*/
   319         /**
   320 		void HandleSearchResultsL();
   320         * CPSRequestHandler.
   321 		    
   321         * Performs the first phase of two phase construction.
   322 		/**
   322         */
   323 		* HandleBufferOverFlowL.
   323         CPSRequestHandler();
   324 		* Handles internal buffer overflow event.
   324 
   325 		*/
   325         /**
   326 		void HandleBufferOverFlowL();
   326         * ConstructL.
   327 
   327         * Performs the second phase construction of a
   328 		/**
   328         * CPSRequestHandler object.
   329 		* HandleErrorL.
   329         */
   330 		* Handles error events.
   330         void ConstructL();
   331 		*/
   331 
   332 		void HandleErrorL(TInt aErrorCode);
   332     private: // Internal data handlers
   333 		
   333 
   334 		/**
   334         /**
   335 		* AddMarkedContacts
   335         * ParseResultsL.
   336 		* Filters the bookmark results and adds them to final search result set
   336         * Parses the results buffer and converts them to data elements.
   337 		*/
   337         */
   338 		TInt AddMarkedContactsL(RPointerArray<CPsClientData>& searchResults);
   338         void HandleSearchResultsL();
   339 
   339 
   340 		/**
   340         /**
       
   341         * HandleBufferOverFlowL.
       
   342         * Handles internal buffer overflow event.
       
   343         */
       
   344         void HandleBufferOverFlowL();
       
   345 
       
   346         /**
       
   347         * HandleErrorL.
       
   348         * Handles error events.
       
   349         */
       
   350         void HandleErrorL(TInt aErrorCode);
       
   351 
       
   352         /**
       
   353         * AddMarkedContacts
       
   354         * Filters the bookmark results and adds them to final search result set
       
   355         */
       
   356         TInt AddMarkedContactsL(RPointerArray<CPsClientData>& searchResults);
       
   357 
       
   358         /**
   341         * RunSearchFromBufferL
   359         * RunSearchFromBufferL
   342         * Runs search if search query buffer ( iPendingSearchQueryBuffer ) is not empty
   360         * Runs search if search query buffer ( iPendingSearchQueryBuffer ) is not empty
   343         */
   361         */
   344         void RunSearchFromBufferL();
   362         void RunSearchFromBufferL();
   345         
   363 
   346 	private: // Data
   364     private: // Data
   347 
   365 
   348 		/**
   366         /**
   349 		* iSession, the predictive search server session.
   367         * iSession, the predictive search server session.
   350 		*/
   368         */
   351 		RPsSession iSession;
   369         RPsSession iSession;
   352 
   370 
   353 		/**
   371         /**
   354 		* iObservers, observers which handles updates from the server.
   372         * iObservers, observers which handles updates from the server.
   355 		*/
   373         */
   356 		RPointerArray<MPsResultsObserver> iObservers;
   374         RPointerArray<MPsResultsObserver> iObservers;
   357 
   375 
   358 		/**
   376         /**
   359 		* iSearchQueryBuffer, the buffer that holds the search query.
   377         * iSearchQueryBuffer, the buffer that holds the search query.
   360 		*/
   378         */
   361 		HBufC8* iSearchQueryBuffer;
   379         HBufC8* iSearchQueryBuffer;
   362 
   380 
   363 		/**
   381         /**
   364          * iPendingSearchQueryBuffer, the buffer that holds the pending search query.
   382          * iPendingSearchQueryBuffer, the buffer that holds the pending search query.
   365         */
   383         */
   366         HBufC8* iPendingSearchQueryBuffer;
   384         HBufC8* iPendingSearchQueryBuffer;
   367 
   385 
   368 		/**
   386         /**
   369 		* iSearchDataBuffer, the buffer that holds the search data.
   387         * iSearchDataBuffer, the buffer that holds the search data.
   370 		*/
   388         */
   371 		HBufC8* iSearchDataBuffer;
   389         HBufC8* iSearchDataBuffer;
   372 
   390 
   373 		/**
   391         /**
   374 		* iSearchResultsBuffer, the buffer that holds the search results.
   392         * iSearchResultsBuffer, the buffer that holds the search results.
   375 		*/
   393         */
   376 		HBufC8* iSearchResultsBuffer;
   394         HBufC8* iSearchResultsBuffer;
   377 		
   395 
   378 		/**
   396         /**
   379 		* iConverter, instance of contact id converter
   397         * iConverter, instance of contact id converter
   380 		*/
   398         */
   381 		CVPbkContactIdConverter* iConverter;
   399         CVPbkContactIdConverter* iConverter;
   382 		
   400 
   383         /**
   401         /**
   384         * iPropertyHandler, the handler to property which is asynchronously monitored
   402         * iPropertyHandler, the handler to property which is asynchronously monitored
   385         */
   403         */
   386         CPsPropertyHandler* iPropertyHandler;
   404         CPsPropertyHandler* iPropertyHandler;
   387         
   405 
   388         /**
   406         /**
   389         * iContactAddedHandler, handler for reacting to contact being added to cache
   407         * iContactAddedHandler, handler for reacting to contact being added to cache
   390         */
   408         */
   391         CPsUpdateHandler* iContactAddedHandler;
   409         CPsUpdateHandler* iContactAddedHandler;
   392 
   410 
   393         /**
   411         /**
   394         * iContactRemovedHandler, handler for reacting to contact being removed from cache
   412         * iContactRemovedHandler, handler for reacting to contact being removed from cache
   395         */
   413         */
   396         CPsUpdateHandler* iContactRemovedHandler;
   414         CPsUpdateHandler* iContactRemovedHandler;
   397         
   415 
   398         /**
   416         /**
   399         * iContactModifiedHandler, handler for reacting to contact being modified in cache
   417         * iContactModifiedHandler, handler for reacting to contact being modified in cache
   400         */
   418         */
   401         CPsUpdateHandler* iContactModifiedHandler;
   419         CPsUpdateHandler* iContactModifiedHandler;
   402         
   420 
   403         /**
   421         /**
   404         * Not Owned
   422         * Not Owned
   405         * iBookMarkContactManager, contact manager reference received from the client
   423         * iBookMarkContactManager, contact manager reference received from the client
   406         * To be used only for handling marked contacts.
   424         * To be used only for handling marked contacts.
   407         */
   425         */
   408         CVPbkContactManager* iBookMarkContactManager;
   426         CVPbkContactManager* iBookMarkContactManager;
   409         
   427 
   410         /**
   428         /**
   411         * iMarkedContacts, stores the bookmarked contacts if any, sent by the client
   429         * iMarkedContacts, stores the bookmarked contacts if any, sent by the client
   412         */
   430         */
   413         RPointerArray<CPsClientData> iMarkedContacts;
   431         RPointerArray<CPsClientData> iMarkedContacts;
   414         
   432 
   415         /**
   433         /**
   416         * ETrue, if search request was cancelled
   434         * ETrue, if search request was cancelled
   417         */
   435         */
   418         TBool iSearchRequestCancelled;
   436         TBool iSearchRequestCancelled;
   419 		
   437 
   420 };
   438 };
   421 
   439 
   422 
   440 
   423 #endif //__CPSREQUESTHANDLER_H__
   441 #endif //__CPSREQUESTHANDLER_H__
   424 
   442