|
1 /* |
|
2 * Copyright (c) 2005 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: Session for DS host server. |
|
15 * |
|
16 */ |
|
17 |
|
18 |
|
19 #ifndef __NSMLDSHOSTSERVERSESSION_H__ |
|
20 #define __NSMLDSHOSTSERVERSESSION_H__ |
|
21 |
|
22 // ------------------------------------------------------------------------------------------------ |
|
23 // Includes |
|
24 // ------------------------------------------------------------------------------------------------ |
|
25 #include <e32base.h> |
|
26 #include <stringpool.h> |
|
27 |
|
28 #include <nsmldsconstants.h> |
|
29 #include <nsmlconstants.h> |
|
30 #include "nsmldshostconstants.h" |
|
31 #include "nsmldshostitem.h" |
|
32 #include "nsmldsitemmodificationset.h" |
|
33 #include "Nsmldsasyncrequesthandler.h" |
|
34 #include "Nsmldsdataproviderarray.h" |
|
35 |
|
36 // ------------------------------------------------------------------------------------------------ |
|
37 // Class forwards |
|
38 // ------------------------------------------------------------------------------------------------ |
|
39 class CSyncMLFilter; |
|
40 class CSmlDataProvider; |
|
41 class CSmlDataStore; |
|
42 |
|
43 // ------------------------------------------------------------------------------------------------ |
|
44 // Class declarations |
|
45 // ------------------------------------------------------------------------------------------------ |
|
46 // ------------------------------------------------------------------------------------------------ |
|
47 // class CNSmlDSHostSession |
|
48 // |
|
49 // @lib nsmldshostserver.lib |
|
50 // ------------------------------------------------------------------------------------------------ |
|
51 class CNSmlDSHostSession : public CSession2 |
|
52 { |
|
53 private: //DATA TYPES and INNER CLASSES |
|
54 typedef CNSmlDSAsyncCallBack::TCallBackOperation TCallBackOperation; |
|
55 |
|
56 // ------------------------------------------------------------------------------------------------ |
|
57 // reads from and writes to memory through pointer. |
|
58 // |
|
59 // @lib nsmldshostserver.lib |
|
60 // ------------------------------------------------------------------------------------------------ |
|
61 class TMemPtr |
|
62 { |
|
63 public: |
|
64 // ------------------------------------------------------------------------------------------------ |
|
65 // Buffer + dynamic streams for that buffer. |
|
66 // |
|
67 // @lib nsmldshostserver.lib |
|
68 // ------------------------------------------------------------------------------------------------ |
|
69 struct TStreamBuffers |
|
70 { |
|
71 CBufBase* iBuffer; |
|
72 RWriteStream* iWrite; |
|
73 RReadStream* iRead; |
|
74 }; |
|
75 |
|
76 public: //Constructor |
|
77 |
|
78 TMemPtr(); |
|
79 private: |
|
80 TMemPtr( const TMemPtr& op ); |
|
81 public: |
|
82 |
|
83 /** |
|
84 * pointer to memory |
|
85 * @return TPtr8. Pointer to memory. |
|
86 */ |
|
87 TPtr8 Des(); |
|
88 |
|
89 /** |
|
90 * pointer to memory area. |
|
91 * @param aPos. Start position. |
|
92 * @param aLength. Length of memory area. |
|
93 * @return TPtr8. Pointer to memory. |
|
94 */ |
|
95 TPtr8 Mid( TInt aPos, TInt aLength ); |
|
96 |
|
97 /** |
|
98 * copies memory to aDest buffer. |
|
99 * @param aDest. destination for copy. |
|
100 */ |
|
101 void CopyTo(TDes8& aDest) const; |
|
102 |
|
103 /** |
|
104 * write stream to memory. |
|
105 * @return RWriteStream&. write stream to memory. |
|
106 */ |
|
107 RWriteStream& WriteStreamLC() const; |
|
108 |
|
109 /** |
|
110 * write stream with dynamic buffer. |
|
111 * @return RWriteStream&. write stream to memory. |
|
112 */ |
|
113 TStreamBuffers* StreamBufferLC() const; |
|
114 |
|
115 /** |
|
116 * read stream to memory. |
|
117 * @return RReadStream&. read stream to memory. |
|
118 */ |
|
119 RReadStream& ReadStreamLC() const; |
|
120 |
|
121 /** |
|
122 * Adjusts memory so that at least needed size is reserved. |
|
123 * @param iNeededSize. Memory needed for chunk in bytes. |
|
124 */ |
|
125 void AdjustChunkIfNeededL( TInt iNeededSize ); |
|
126 |
|
127 /** |
|
128 * size of memory area. |
|
129 * @return TInt. size of memory area. |
|
130 */ |
|
131 TInt Size() const; |
|
132 private: |
|
133 |
|
134 /** |
|
135 * Changes the number of bytes committed to the chunk |
|
136 * @param aNewSize. The number of bytes to be committed to this chunk |
|
137 * @return TInt. status code |
|
138 */ |
|
139 TInt Adjust( TInt aNewSize ); |
|
140 |
|
141 /** |
|
142 * handles clean up of write stream. |
|
143 * @param aP. write stream. |
|
144 */ |
|
145 static void CleanupWriteStream( TAny* aP ); |
|
146 |
|
147 /** |
|
148 * handles clean up of read stream. |
|
149 * @param aP. read stream. |
|
150 */ |
|
151 static void CleanupReadStream( TAny* aP ); |
|
152 |
|
153 /** |
|
154 * handles clean up of stream buffer. |
|
155 * @param aP. read stream. |
|
156 */ |
|
157 static void CleanupStreamBuffer( TAny* aP ); |
|
158 |
|
159 /** |
|
160 * restores chunk memory. |
|
161 * @param aP. pointer to TMemPtr |
|
162 */ |
|
163 static void CancelAdjust( TAny* aP ); |
|
164 |
|
165 /** |
|
166 * modifiable pointer to memory. |
|
167 * @return TUint8*. pointer to memory. |
|
168 */ |
|
169 TUint8* Ptr8(); |
|
170 |
|
171 /** |
|
172 * const pointer to memory. |
|
173 * @return const TUint8*. read pointer to memory. |
|
174 */ |
|
175 const TUint8* Ptr8() const; |
|
176 |
|
177 /** |
|
178 * modifiable pointer to memory. |
|
179 * @return TAny*. pointer to memory. |
|
180 */ |
|
181 TAny* Ptr() const; |
|
182 |
|
183 public: |
|
184 RChunk iChunk; |
|
185 |
|
186 #ifdef __HOST_SERVER_MTEST__ |
|
187 TInt iChunkSize; |
|
188 #endif |
|
189 }; |
|
190 |
|
191 typedef CNSmlDSHostSession::TMemPtr::TStreamBuffers TStreamBuffers; |
|
192 |
|
193 // ------------------------------------------------------------------------------------------------ |
|
194 // for transporting item parameters over IPC. |
|
195 // |
|
196 // @lib nsmldshostserver.lib |
|
197 // ------------------------------------------------------------------------------------------------ |
|
198 class CNSmlServerDSHostItem : public CNSmlDSHostItem |
|
199 { |
|
200 public: //Constructor |
|
201 |
|
202 /** |
|
203 * Two-phased constructor. |
|
204 */ |
|
205 static CNSmlServerDSHostItem* NewLC(); |
|
206 public: //New functions |
|
207 |
|
208 /** |
|
209 * reference to uid member |
|
210 * @return TSmlDbItemUid&. reference to uid |
|
211 */ |
|
212 TSmlDbItemUid& Uid(); |
|
213 |
|
214 /** |
|
215 * reference to fieldchange member. |
|
216 * @return TBool&. reference to fieldchange member. |
|
217 */ |
|
218 TBool& FieldChange(); |
|
219 |
|
220 /** |
|
221 * reference to size member. |
|
222 * @return TInt&. reference to size member. |
|
223 */ |
|
224 TInt& Size(); |
|
225 |
|
226 /** |
|
227 * reference to parent uid member. |
|
228 * @return TSmlDbItemUid&. reference to parent uid member. |
|
229 */ |
|
230 TSmlDbItemUid& ParentUid(); |
|
231 public: //Data |
|
232 |
|
233 TBuf8<64> iMimeTypePtr; |
|
234 TBuf8<64> iMimeVerPtr; |
|
235 TSmlDbItemUid* iCreateItemUid; //uid for CSmlDataStore::CreateItemL |
|
236 }; |
|
237 |
|
238 public: //constructors and destructors |
|
239 |
|
240 /** |
|
241 * Creates new instance of CNSmlDSHostSession. |
|
242 * @param aServer. the server instance, owner of session. |
|
243 * @return CNSmlDSHostSession*. Created instance. |
|
244 */ |
|
245 static CNSmlDSHostSession* NewL( CNSmlDSHostServer& aServer); |
|
246 ~CNSmlDSHostSession(); |
|
247 |
|
248 /** |
|
249 * Handles the servicing of a client request that has been passed to the server. |
|
250 * @param aMessage. message to service. |
|
251 */ |
|
252 public: //Functions from base classes. |
|
253 |
|
254 void ServiceL( const RMessage2 &aMessage ); |
|
255 |
|
256 private: // New methods |
|
257 |
|
258 /** |
|
259 * Checks the message, then calls the correct method to service the message. |
|
260 * @param aMessage. Message to dispatch. |
|
261 * @param aCompleteRequest. set to ETrue, if message should be completed after calling this method. |
|
262 * EFalse, if request is asynchronous, and completion is done by an active object. |
|
263 */ |
|
264 void DispatchMessageL( const RMessage2 &aMessage, TBool& aCompleteRequest ); |
|
265 |
|
266 /** |
|
267 * C++ constructor. |
|
268 * @param aServer.the server instance, owner of session. |
|
269 */ |
|
270 CNSmlDSHostSession( CNSmlDSHostServer& aServer); |
|
271 |
|
272 /** |
|
273 * Symbian 2nd phase constructor |
|
274 */ |
|
275 void ConstructL(); |
|
276 |
|
277 /** |
|
278 * saves shared memory chunk handle from client for later use. |
|
279 * @param aMessage.Message to service. |
|
280 */ |
|
281 void HandleChunk( const RMessage2& aMessage ); |
|
282 |
|
283 /** |
|
284 * Creates data providers. Sends status code for each to client. |
|
285 * @param aMessage. Message to service. |
|
286 */ |
|
287 void CreateDataProvidersL( const RMessage2& aMessage ); |
|
288 |
|
289 /** |
|
290 * Creates data providers except those sent from client. Sends created data provider ids to client. |
|
291 * @param aMessage. Message to service. |
|
292 */ |
|
293 void CreateDataProvidersExceptL( const RMessage2& aMessage ); |
|
294 |
|
295 /** |
|
296 * Creates one data provider, stores it, if creation succeeds. |
|
297 * @param aId. Data provider id to data provider to create. |
|
298 */ |
|
299 void CreateDataProviderL(TSmlDataProviderId aId); |
|
300 |
|
301 /** |
|
302 * Sends Data provider information to client. |
|
303 * @param aMessage. Message to service. |
|
304 */ |
|
305 void DPInformationL( const RMessage2& aMessage ); |
|
306 |
|
307 /** |
|
308 * Calls CSmlDataProvider::SupportsOperation() and sends the result to client. |
|
309 * @param aMessage. Message to service. |
|
310 */ |
|
311 void SupportsOperationL( const RMessage2& aMessage ); |
|
312 |
|
313 /** |
|
314 * Calls CSmlDataProvider::StoreFormatL() and sends the result to client. |
|
315 * @param aMessage. Message to service. |
|
316 */ |
|
317 void StoreFormatL( const RMessage2& aMessage ); |
|
318 |
|
319 /** |
|
320 * Calls CSmlDataProvider::ListStoresLC() and sends the result to client. |
|
321 * @param aMessage. Message to service. |
|
322 */ |
|
323 void ListStoresL( const RMessage2& aMessage ); |
|
324 |
|
325 /** |
|
326 * Calls CSmlDataProvider::DefaultStoreL() and sends the result to client. |
|
327 * @param aMessage. Message to service. |
|
328 */ |
|
329 void DefaultStoreL( const RMessage2& aMessage ); |
|
330 |
|
331 /** |
|
332 * Calls CSmlDataProvider::SupportedServerFiltersL(). |
|
333 * @param aMessage. Message to service. |
|
334 */ |
|
335 void SupportedServerFiltersL( const RMessage2& aMessage ); |
|
336 |
|
337 /** |
|
338 * Calls CSmlDataProvider::CheckServerFiltersL(). |
|
339 * @param aMessage. Message to service. |
|
340 */ |
|
341 void CheckServerFiltersL( const RMessage2& aMessage ); |
|
342 |
|
343 /* |
|
344 * Calls CSmlDataProvider::CheckSupportedServerFiltersL. |
|
345 * @param aMessage. Message to service. |
|
346 */ |
|
347 void CheckSupportedServerFiltersL( const RMessage2& aMessage ); |
|
348 |
|
349 /** |
|
350 * get filters |
|
351 * @param aMessage. Message to service. |
|
352 */ |
|
353 void GetFiltersL( const RMessage2& aMessage ); |
|
354 |
|
355 /** |
|
356 * Opens the data store requested in message. |
|
357 * @param aMessage. Message to service.If open succeeds, |
|
358 * the data store is stored for later use. |
|
359 */ |
|
360 void OpenL( const RMessage2& aMessage ); |
|
361 |
|
362 /** |
|
363 * Called after OpenL request completes. |
|
364 * @param aDSAO. object, that handled the request. |
|
365 * @param aOperation. Operation to perform. |
|
366 */ |
|
367 TInt OpenFinishedL( CNSmlDSAsyncCallBack* aDSAO, TCallBackOperation aOperation ); |
|
368 |
|
369 /** |
|
370 * Calls CSmlDataStore::CancelRequest. |
|
371 * @param aMessage. |
|
372 */ |
|
373 void CancelRequestL( const RMessage2& aMessage ); |
|
374 |
|
375 /** |
|
376 * Calls CSmlDataStore::BeginTransactionL |
|
377 * @param aMessage. |
|
378 */ |
|
379 void BeginTransactionL( const RMessage2& aMessage ); |
|
380 |
|
381 /** |
|
382 * Calls asynchronously CSmlDataStore::CommitTransactionL |
|
383 * @param aMessage. |
|
384 */ |
|
385 void CommitTransactionL( const RMessage2& aMessage ); |
|
386 |
|
387 /** |
|
388 * Calls asynchronously CSmlDataStore::RevertTransaction |
|
389 * @param aMessage. |
|
390 */ |
|
391 void RevertTransactionL( const RMessage2& aMessage ); |
|
392 |
|
393 /** |
|
394 * Calls CSmlDataStore::BeginBatchL |
|
395 * @param aMessage. |
|
396 */ |
|
397 void BeginBatchL( const RMessage2& aMessage ); |
|
398 |
|
399 /** |
|
400 * Calls asynchronously CSmlDataStore::CommitBatchL. |
|
401 * @param aMessage. |
|
402 */ |
|
403 void CommitBatchL( const RMessage2& aMessage ); |
|
404 |
|
405 /** |
|
406 * Called after CommitBatchL request completes. |
|
407 * @param aDSAO. object, that handled the request. |
|
408 * @param aOperation. Operation to perform. |
|
409 */ |
|
410 TInt CommitBatchRequestFinishedL( CNSmlDSAsyncCallBack* aDSAO, TCallBackOperation aOperation ); |
|
411 |
|
412 /** |
|
413 * Calls CSmlDataStore::CancelBatch |
|
414 * @param aMessage. |
|
415 */ |
|
416 void CancelBatchL( const RMessage2& aMessage ); |
|
417 |
|
418 /** |
|
419 * Calls CSmlDataStore::SetRemoteStoreFormatL |
|
420 * @param aMessage. |
|
421 */ |
|
422 void SetRemoteDataStoreFormatL( const RMessage2& aMessage ); |
|
423 |
|
424 /** |
|
425 * Calls CSmlDataStore::SetRemoteMaxObjectSize |
|
426 * @param aMessage. |
|
427 */ |
|
428 void SetRemoteMaxObjectSizeL( const RMessage2& aMessage ); |
|
429 |
|
430 /** |
|
431 * Calls CSmlDataStore::MaxObjectSize |
|
432 * @param aMessage. |
|
433 */ |
|
434 void MaxObjectSizeL( const RMessage2& aMessage ); |
|
435 |
|
436 /** |
|
437 * Calls asynchronously CSmlDataStore::OpenItemL(). |
|
438 * @param aMessage. |
|
439 */ |
|
440 void OpenItemL( const RMessage2& aMessage ); |
|
441 |
|
442 /** |
|
443 * Called after OpenItemL request completes. |
|
444 * @param aDSAO. object, that handled to request. |
|
445 * @param aOperation. Operation to perform. |
|
446 */ |
|
447 TInt OpenItemRequestFinishedL( CNSmlDSAsyncCallBack* iDSAO, TCallBackOperation aOperation ); |
|
448 |
|
449 /** |
|
450 * Creates an CNSmlServerDSHostItem instance with values read from shared memory chunk. |
|
451 * Leaves object to cleanup stack. |
|
452 * @return CNSmlServerDSHostItem*. Instance created. |
|
453 */ |
|
454 CNSmlServerDSHostItem* DataStoreItemParamsLC(); |
|
455 |
|
456 /** |
|
457 * write data store items to shared memoy chunk. |
|
458 * @param dshi. Object, that contains data store item - variables. |
|
459 */ |
|
460 void WriteDataStoreItemParamsL( CNSmlDSHostItem* dshi ); |
|
461 |
|
462 /** |
|
463 * Calls asynchronously CSmlDataStore::CreateItemL. |
|
464 * @param aMessage. |
|
465 */ |
|
466 void CreateItemL( const RMessage2& aMessage ); |
|
467 |
|
468 /** |
|
469 * Called after CreateItemL request completes. |
|
470 * @param aDSAO. object, that handled the request. |
|
471 * @param aOperation. Operation to perform. |
|
472 */ |
|
473 TInt CreateItemRequestFinishedL( CNSmlDSAsyncCallBack* aDSAO, TCallBackOperation aOperation ); |
|
474 |
|
475 /** |
|
476 * Calls asynchronously CSmlDataStore::ReplaceItemL |
|
477 * @param aMessage. |
|
478 */ |
|
479 void ReplaceItemL( const RMessage2& aMessage ); |
|
480 |
|
481 /** |
|
482 * Calls CSmlDataStore::ReadItemL |
|
483 * @param aMessage. |
|
484 */ |
|
485 void ReadItemL( const RMessage2& aMessage ); |
|
486 |
|
487 /** |
|
488 * Calls CSmlDataStore::WriteItemL |
|
489 * @param aMessage. |
|
490 */ |
|
491 void WriteItemL( const RMessage2& aMessage ); |
|
492 |
|
493 /** |
|
494 * Calls CSmlDataStore::CommitItemL. |
|
495 * @param aMessage. |
|
496 */ |
|
497 void CommitItemL( const RMessage2& aMessage ); |
|
498 |
|
499 /** |
|
500 * Called after CommitItemL request completes. |
|
501 * @param aDSAO. object, that handled the request. |
|
502 * @param aOperation. Operation to perform. |
|
503 */ |
|
504 TInt CommitItemRequestFinishedL( CNSmlDSAsyncCallBack* aDSAO, TCallBackOperation aOperation ); |
|
505 |
|
506 /** |
|
507 * Calls CSmlDataStore::CloseItem |
|
508 * @param aMessage. |
|
509 */ |
|
510 void CloseItemL( const RMessage2& aMessage ); |
|
511 |
|
512 /** |
|
513 * Calls asynchronously CSmlDataStore::MoveItemL |
|
514 * @param aMessage. |
|
515 */ |
|
516 void MoveItemL( const RMessage2& aMessage ); |
|
517 |
|
518 /** |
|
519 * Calls asynchronously CSmlDataStore::DeleteItemL |
|
520 * @param aMessage. |
|
521 */ |
|
522 void DeleteItemL( const RMessage2& aMessage ); |
|
523 |
|
524 /** |
|
525 * Calls asynchronously CSmlDataStore::SoftDeleteItemL |
|
526 * @param aMessage. |
|
527 */ |
|
528 void SoftDeleteItemL( const RMessage2& aMessage ); |
|
529 |
|
530 /** |
|
531 * Calls asynchronously CSmlDataStore::DeleteAllItemsL |
|
532 * @param aMessage. |
|
533 */ |
|
534 void DeleteAllItemsL( const RMessage2& aMessage ); |
|
535 |
|
536 /** |
|
537 * Calls CSmlDataStore::HasSyncHistory |
|
538 * @param aMessage. |
|
539 */ |
|
540 void HasSyncHistoryL( const RMessage2& aMessage ); |
|
541 |
|
542 /** |
|
543 * Calls CSmlDataStore::AddedItems |
|
544 * @param aMessage. |
|
545 */ |
|
546 void AddedItemsL( const RMessage2& aMessage ); |
|
547 |
|
548 /** |
|
549 * Calls CSmlDataStore::DeletedItems |
|
550 * @param aMessage. |
|
551 */ |
|
552 void DeletedItemsL( const RMessage2& aMessage ); |
|
553 |
|
554 /** |
|
555 * Calls CSmlDataStore::SoftDeletedItems |
|
556 * @param aMessage. |
|
557 */ |
|
558 void SoftDeleteItemsL( const RMessage2& aMessage ); |
|
559 |
|
560 /** |
|
561 * Calls CSmlDataStore::ModifiedItems |
|
562 * @param aMessage. |
|
563 */ |
|
564 void ModifiedItemsL( const RMessage2& aMessage ); |
|
565 |
|
566 /** |
|
567 * Calls CSmlDataStore::MovedItems |
|
568 * @param aMessage. |
|
569 */ |
|
570 void MovedItemsL( const RMessage2& aMessage ); |
|
571 |
|
572 /** |
|
573 * calls asynchronously MovedItems, ModifiedItems, SoftDeletedItems, DeletedItems, AddedItems |
|
574 * @param aMessage. |
|
575 */ |
|
576 void AllItemsL( const RMessage2& aMessage ); |
|
577 |
|
578 /** |
|
579 * Called after OpenL request completes. |
|
580 * @param aDSAO. object, that handled the request. |
|
581 */ |
|
582 void AllItemsRequestFinishedL( CNSmlDSChangedItemsFetcher* aDSAO ); |
|
583 |
|
584 /** |
|
585 * Calls CSmlDataStore:: ResetChangeInfoL |
|
586 * @param aMessage. |
|
587 */ |
|
588 void ResetChangeInfoL( const RMessage2& aMessage ); |
|
589 |
|
590 /** |
|
591 * Calls asynchronously CSmlDataStore::CommitChangeInfoL |
|
592 * @param aMessage. |
|
593 */ |
|
594 void CommitChangesL( const RMessage2& aMessage); |
|
595 |
|
596 /** |
|
597 * Called after CommitChangesL request completes. |
|
598 * @param aDSAO. object, that handled the request. |
|
599 * @param aOperation. Operation to perform. |
|
600 */ |
|
601 TInt CommitChangesRequestFinishedL( CNSmlDSAsyncCallBack* aDSAO, TCallBackOperation aOperation ); |
|
602 |
|
603 /** |
|
604 * Calls asynchronously CSmlDataStore::CommitChangeInfoL |
|
605 * @param aMessage. |
|
606 */ |
|
607 void CommitAllChangesL( const RMessage2& aMessage ); |
|
608 |
|
609 /** |
|
610 * Updates server id to adapter log. |
|
611 * @param aMessage. |
|
612 */ |
|
613 void UpdateServerIdL( const RMessage2& aMessage ); |
|
614 |
|
615 /** |
|
616 * searches data provider using its aId. |
|
617 * @param aId. Data provider id to data provider to search. Leaves if not found. |
|
618 * @return CSmlDataProvider*. Data provider found. |
|
619 */ |
|
620 CSmlDataProvider* DataProviderL( TSmlDataProviderId aId ); |
|
621 |
|
622 /** |
|
623 * searches data provider item using data provider id. |
|
624 * @param aId. Data provider id to data provider to search. Leaves if not found. |
|
625 * @return TNSmlDSDataProviderElement*. Data provider found. |
|
626 */ |
|
627 TNSmlDSDataProviderElement* DataProviderItemL( TSmlDataProviderId aId ); |
|
628 |
|
629 /** |
|
630 * finds data store from aMessage. Leaves if not found. |
|
631 * @param aMessage. |
|
632 * @return CSmlDataStore*. The data store requested in aMessage. |
|
633 */ |
|
634 CSmlDataStore* DataStoreL( const RMessage2& aMessage ); |
|
635 |
|
636 /** |
|
637 * finds data store element from aMessage. Leaves if not found. |
|
638 * @param aMessage. |
|
639 * @return TNSmlDSDataStoreElement*. The data store requested in aMessage. |
|
640 */ |
|
641 TNSmlDSDataStoreElement* DataStoreItemL( const RMessage2& aMessage ); |
|
642 |
|
643 /** |
|
644 * Is data store created. |
|
645 * @param aMessage. Message, that contains the data store. |
|
646 * @return ETrue if data store in aMessage is created, EFalse if not. |
|
647 */ |
|
648 TBool HasDataStoreL( const RMessage2& aMessage ); |
|
649 |
|
650 /** |
|
651 * Retrieves data store name from message. |
|
652 * @param aMessage. |
|
653 * @return HBufC*. Data store name from aMessage. |
|
654 */ |
|
655 static HBufC* DataStoreNameLC( const RMessage2& aMessage ); |
|
656 |
|
657 /** |
|
658 * Read filters from stream. |
|
659 * @param aStream. stream, where filters are read. |
|
660 * @param aFilters. Receives filters read from stream. |
|
661 */ |
|
662 static void InternalizeFiltersL( RReadStream& aStream, RPointerArray<CSyncMLFilter>& aFilters ); |
|
663 |
|
664 /** |
|
665 * Write filters to stream. |
|
666 * @param aStream. Stream to write |
|
667 * @param aFilters. filters to write. |
|
668 */ |
|
669 static void ExternalizeFiltersL( RWriteStream& aStream, const RPointerArray<CSyncMLFilter>& aFilters ); |
|
670 |
|
671 |
|
672 /** |
|
673 * Panics the client |
|
674 * @param aMessage. Message from client to panic. |
|
675 * @param aReason. Reason code. |
|
676 */ |
|
677 void PanicClient( const RMessage2& aMessage, TInt aReason ) const; |
|
678 |
|
679 /** |
|
680 * returns shared memory chunk pointer. |
|
681 * @return shared memory chunk pointer. |
|
682 */ |
|
683 TMemPtr& MemPtrL(); |
|
684 |
|
685 /** |
|
686 * copies data from stream buffer to chunk |
|
687 * @param aMemPtr. pointer to chunk |
|
688 * @param aSb. contains data to copy |
|
689 */ |
|
690 void StreamBufferToChunkL( TMemPtr& aMemPtr, TStreamBuffers* aSb ); |
|
691 |
|
692 private: //Data |
|
693 |
|
694 TMemPtr iMemPtr; |
|
695 CNSmlDSHostServer& iServer; |
|
696 RNSmlDSDataProviderArray iDataProviders; |
|
697 RStringPool iStringPool; |
|
698 }; |
|
699 |
|
700 #include "Nsmldshostsession.inl" |
|
701 #endif // __NSMLDSHOSTSERVERSESSION_H__ |
|
702 |
|
703 // End of File |