1 /* |
|
2 * Copyright (c) 2009 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: RSconSyncSession implementation |
|
15 * |
|
16 */ |
|
17 |
|
18 |
|
19 #include "sconsyncclient.h" |
|
20 |
|
21 #include <SmlDataProvider.h> |
|
22 #include <s32mem.h> |
|
23 |
|
24 #include "sconsyncclientserver.h" |
|
25 #include "debug.h" |
|
26 |
|
27 const TInt KSConSyncChunkSize = 0xFFFF; // 65535 bytes; |
|
28 const TInt KSConSyncChunkMaxSize = 0x400000; // 4194304 bytes |
|
29 |
|
30 EXPORT_C RSconSyncSession::RSconSyncSession() |
|
31 { |
|
32 TRACE_FUNC; |
|
33 } |
|
34 |
|
35 EXPORT_C RSconSyncSession::~RSconSyncSession() |
|
36 { |
|
37 TRACE_FUNC; |
|
38 } |
|
39 |
|
40 EXPORT_C TInt RSconSyncSession::Connect() |
|
41 { |
|
42 TRACE_FUNC_ENTRY; |
|
43 TInt retryCount = 2; |
|
44 TInt error = KErrNone; |
|
45 while(retryCount) |
|
46 { |
|
47 error = CreateSession(KSconSyncServerName, TVersion(1,0,0)); |
|
48 if ( error != KErrNotFound && error != KErrServerTerminated ) |
|
49 { |
|
50 break; |
|
51 } |
|
52 error = StartServer(); |
|
53 if( error != KErrNone && error != KErrAlreadyExists ) |
|
54 { |
|
55 break; |
|
56 } |
|
57 --retryCount; |
|
58 } |
|
59 |
|
60 if ( error == KErrNone ) |
|
61 { |
|
62 error = CreateAndSendChunkHandle(); |
|
63 if ( error != KErrNone ) |
|
64 { |
|
65 LOGGER_WRITE("CreateAndSendChunkHandle failed, close session"); |
|
66 Close(); |
|
67 } |
|
68 } |
|
69 TRACE_FUNC_EXIT; |
|
70 return error; |
|
71 } |
|
72 |
|
73 // ----------------------------------------------------------------------------- |
|
74 // RSconSyncSession::Close() |
|
75 // Closes the server connection |
|
76 // ----------------------------------------------------------------------------- |
|
77 // |
|
78 EXPORT_C void RSconSyncSession::Close() |
|
79 { |
|
80 TRACE_FUNC_ENTRY; |
|
81 iChunk.Close(); |
|
82 RSessionBase::Close(); |
|
83 TRACE_FUNC_EXIT |
|
84 } |
|
85 |
|
86 EXPORT_C void RSconSyncSession::ListAllImplementationsL( RSconDataProviderInfoArray& aInfoArray ) |
|
87 { |
|
88 TRACE_FUNC_ENTRY; |
|
89 TIpcArgs args; |
|
90 TInt ret = SendReceive ( EListImplementations, args ); |
|
91 |
|
92 if ( ret != KErrNone) |
|
93 { |
|
94 LOGGER_WRITE_1( "RSconSyncSession::ListAllImplementationsL() :\ |
|
95 Send Receive failed with code %d", ret ); |
|
96 User::Leave( ret ); |
|
97 }; |
|
98 |
|
99 // copy data from the chunk |
|
100 RMemReadStream readStream( iChunk.Base(), iChunk.Size() ); |
|
101 CleanupClosePushL( readStream ); |
|
102 |
|
103 TInt count( readStream.ReadUint16L() ); |
|
104 LOGGER_WRITE_1("count: %d", count); |
|
105 for ( TInt i=0; i<count; i++ ) |
|
106 { |
|
107 LOGGER_WRITE_1("Import[%d]", i); |
|
108 CSconDataproviderInfo *dpInfo = CSconDataproviderInfo::NewL(); |
|
109 CleanupStack::PushL( dpInfo ); |
|
110 |
|
111 dpInfo->InternalizeL( readStream ); |
|
112 aInfoArray.AppendL( dpInfo ); |
|
113 CleanupStack::Pop( dpInfo ); |
|
114 } |
|
115 |
|
116 CleanupStack::PopAndDestroy( &readStream ); |
|
117 |
|
118 TRACE_FUNC_EXIT; |
|
119 } |
|
120 |
|
121 EXPORT_C void RSconSyncSession::OpenDataStoreL( const TSmlDataProviderId aProviderId, const TDesC& aStoreName, TInt aContextId ) |
|
122 { |
|
123 TRACE_FUNC_ENTRY; |
|
124 User::LeaveIfError( iChunk.Adjust( |
|
125 sizeof(TInt32) |
|
126 + sizeof(TInt32) |
|
127 + aStoreName.Size() |
|
128 + sizeof(TInt) )); |
|
129 |
|
130 RMemWriteStream writeBuf( iChunk.Base(), iChunk.Size() ); |
|
131 writeBuf.WriteInt32L( aProviderId ); |
|
132 |
|
133 writeBuf.WriteInt32L( aStoreName.Length() ); |
|
134 writeBuf.WriteL( aStoreName ); |
|
135 |
|
136 writeBuf.WriteInt32L( aContextId ); |
|
137 |
|
138 writeBuf.CommitL(); |
|
139 writeBuf.Close(); |
|
140 |
|
141 TIpcArgs args; |
|
142 TInt ret = SendReceive ( EOpenStore, args ); |
|
143 |
|
144 if ( ret != KErrNone) |
|
145 { |
|
146 LOGGER_WRITE_1( "RSconSyncSession::OpenDataStoreL() :\ |
|
147 Send Receive failed with code %d", ret ); |
|
148 User::Leave( ret ); |
|
149 }; |
|
150 TRACE_FUNC_EXIT; |
|
151 } |
|
152 |
|
153 EXPORT_C void RSconSyncSession::OpenItemL( TSmlDbItemUid aUid, TBool& aFieldChange, |
|
154 TSmlDbItemUid& aParent, TDes8& aMimeType, TDes8& aMimeVer, CBufFlat& aItemData ) |
|
155 { |
|
156 TRACE_FUNC_ENTRY; |
|
157 TIpcArgs args( aUid ); |
|
158 TInt ret = SendReceive ( EOpenItem, args ); |
|
159 if ( ret != KErrNone) |
|
160 { |
|
161 LOGGER_WRITE_1( "RSconSyncSession::OpenItemL() :\ |
|
162 Send Receive failed with code %d", ret ); |
|
163 User::Leave( ret ); |
|
164 }; |
|
165 |
|
166 // copy data from the chunk |
|
167 RMemReadStream readStream( iChunk.Base(), iChunk.Size() ); |
|
168 CleanupClosePushL( readStream ); |
|
169 TInt32 length ( 0 ); |
|
170 |
|
171 aItemData.Reset(); |
|
172 length = readStream.ReadInt32L(); |
|
173 |
|
174 HBufC8* data = HBufC8::NewLC( length ); |
|
175 TPtr8 dataPtr = data->Des(); |
|
176 |
|
177 readStream.ReadL( dataPtr, length ); |
|
178 aItemData.ExpandL( 0, length ); |
|
179 aItemData.Write ( 0, dataPtr ); |
|
180 |
|
181 CleanupStack::PopAndDestroy( data ); |
|
182 |
|
183 aFieldChange = readStream.ReadInt8L(); |
|
184 |
|
185 aParent = readStream.ReadInt32L(); |
|
186 length = readStream.ReadInt32L(); |
|
187 readStream.ReadL( aMimeType, length ); |
|
188 |
|
189 length = readStream.ReadInt32L(); |
|
190 readStream.ReadL( aMimeVer, length ); |
|
191 |
|
192 CleanupStack::PopAndDestroy( &readStream ); |
|
193 TRACE_FUNC_EXIT; |
|
194 } |
|
195 |
|
196 EXPORT_C void RSconSyncSession::CreateItemL(TSmlDbItemUid& aUid/*, TInt aSize*/, |
|
197 TSmlDbItemUid aParent, const TDesC8& aMimeType, const TDesC8& aMimeVer, |
|
198 const TDesC8& aData) |
|
199 { |
|
200 TRACE_FUNC_ENTRY; |
|
201 User::LeaveIfError( iChunk.Adjust( |
|
202 sizeof(TInt32) |
|
203 + sizeof(TInt32) |
|
204 + aMimeType.Length() |
|
205 + sizeof(TInt32) |
|
206 + aMimeVer.Length() |
|
207 + sizeof(TInt32) |
|
208 + aData.Length() )); |
|
209 RMemWriteStream writeBuf( iChunk.Base(), iChunk.Size() ); |
|
210 CleanupClosePushL( writeBuf ); |
|
211 writeBuf.WriteInt32L( aParent ); |
|
212 writeBuf.WriteInt32L( aMimeType.Length() ); |
|
213 writeBuf.WriteL( aMimeType ); |
|
214 writeBuf.WriteInt32L( aMimeVer.Length() ); |
|
215 writeBuf.WriteL( aMimeVer ); |
|
216 writeBuf.WriteInt32L( aData.Length() ); |
|
217 writeBuf.WriteL( aData ); |
|
218 |
|
219 writeBuf.CommitL(); |
|
220 CleanupStack::PopAndDestroy( &writeBuf ); |
|
221 |
|
222 |
|
223 |
|
224 TPckg<TSmlDbItemUid> pckg(aUid); |
|
225 iArgs = TIpcArgs( &pckg ); |
|
226 |
|
227 TInt ret = SendReceive ( ECreateItem, iArgs ); |
|
228 if ( ret != KErrNone) |
|
229 { |
|
230 LOGGER_WRITE_1( "RSconSyncSession::CreateItemL() :\ |
|
231 Send Receive failed with code %d", ret ); |
|
232 User::Leave( ret ); |
|
233 }; |
|
234 LOGGER_WRITE_1("aUid: %d", aUid); |
|
235 TRACE_FUNC_EXIT; |
|
236 } |
|
237 |
|
238 EXPORT_C void RSconSyncSession::CreateItemL(TPckg<TSmlDbItemUid>& aUidPckg, |
|
239 TSmlDbItemUid aParent, const TDesC8& aMimeType, const TDesC8& aMimeVer, |
|
240 const TDesC8& aData, TRequestStatus& aStatus) |
|
241 { |
|
242 TRACE_FUNC_ENTRY; |
|
243 User::LeaveIfError( iChunk.Adjust( |
|
244 sizeof(TInt32) |
|
245 + sizeof(TInt32) |
|
246 + aMimeType.Length() |
|
247 + sizeof(TInt32) |
|
248 + aMimeVer.Length() |
|
249 + sizeof(TInt32) |
|
250 + aData.Length() )); |
|
251 RMemWriteStream writeBuf( iChunk.Base(), iChunk.Size() ); |
|
252 CleanupClosePushL( writeBuf ); |
|
253 writeBuf.WriteInt32L( aParent ); |
|
254 writeBuf.WriteInt32L( aMimeType.Length() ); |
|
255 writeBuf.WriteL( aMimeType ); |
|
256 writeBuf.WriteInt32L( aMimeVer.Length() ); |
|
257 writeBuf.WriteL( aMimeVer ); |
|
258 writeBuf.WriteInt32L( aData.Length() ); |
|
259 writeBuf.WriteL( aData ); |
|
260 |
|
261 writeBuf.CommitL(); |
|
262 CleanupStack::PopAndDestroy( &writeBuf ); |
|
263 |
|
264 iArgs = TIpcArgs( &aUidPckg ); |
|
265 SendReceive( ECreateItem, iArgs, aStatus ); |
|
266 |
|
267 TRACE_FUNC_EXIT; |
|
268 } |
|
269 |
|
270 EXPORT_C void RSconSyncSession::ReplaceItemL(TSmlDbItemUid aUid, |
|
271 TSmlDbItemUid aParent, TBool aFieldChange, const TDesC8& aData) |
|
272 { |
|
273 TRACE_FUNC_ENTRY; |
|
274 User::LeaveIfError( iChunk.Adjust( |
|
275 sizeof(TInt32) |
|
276 + sizeof(TInt32) |
|
277 + sizeof(TInt8) |
|
278 + sizeof(TInt32) |
|
279 + aData.Length() )); |
|
280 RMemWriteStream writeBuf( iChunk.Base(), iChunk.Size() ); |
|
281 CleanupClosePushL( writeBuf ); |
|
282 writeBuf.WriteInt32L( aUid ); |
|
283 writeBuf.WriteInt32L( aParent ); |
|
284 writeBuf.WriteInt8L( aFieldChange ); |
|
285 writeBuf.WriteInt32L( aData.Length() ); |
|
286 writeBuf.WriteL( aData ); |
|
287 writeBuf.CommitL(); |
|
288 CleanupStack::PopAndDestroy( &writeBuf ); |
|
289 |
|
290 TIpcArgs args; |
|
291 TInt ret = SendReceive( EReplaceItem, args ); |
|
292 if ( ret != KErrNone) |
|
293 { |
|
294 LOGGER_WRITE_1( "RSconSyncSession::ReplaceItemL() :\ |
|
295 Send Receive failed with code %d", ret ); |
|
296 User::Leave( ret ); |
|
297 }; |
|
298 TRACE_FUNC_EXIT; |
|
299 } |
|
300 |
|
301 EXPORT_C void RSconSyncSession::ReplaceItemL(TSmlDbItemUid aUid, |
|
302 TSmlDbItemUid aParent, TBool aFieldChange, const TDesC8& aData, |
|
303 TRequestStatus& aStatus) |
|
304 { |
|
305 TRACE_FUNC_ENTRY; |
|
306 User::LeaveIfError( iChunk.Adjust( |
|
307 sizeof(TInt32) |
|
308 + sizeof(TInt32) |
|
309 + sizeof(TInt8) |
|
310 + sizeof(TInt32) |
|
311 + aData.Length() )); |
|
312 RMemWriteStream writeBuf( iChunk.Base(), iChunk.Size() ); |
|
313 CleanupClosePushL( writeBuf ); |
|
314 writeBuf.WriteInt32L( aUid ); |
|
315 writeBuf.WriteInt32L( aParent ); |
|
316 writeBuf.WriteInt8L( aFieldChange ); |
|
317 writeBuf.WriteInt32L( aData.Length() ); |
|
318 writeBuf.WriteL( aData ); |
|
319 writeBuf.CommitL(); |
|
320 CleanupStack::PopAndDestroy( &writeBuf ); |
|
321 |
|
322 TIpcArgs args; |
|
323 SendReceive( EReplaceItem, args, aStatus ); |
|
324 TRACE_FUNC_EXIT; |
|
325 } |
|
326 |
|
327 EXPORT_C void RSconSyncSession::MoveItemL( TSmlDbItemUid aUid, TSmlDbItemUid aNewParent ) |
|
328 { |
|
329 TRACE_FUNC_ENTRY; |
|
330 |
|
331 TIpcArgs args(aUid, aNewParent); |
|
332 TInt ret = SendReceive ( EMoveItem, args ); |
|
333 if ( ret != KErrNone) |
|
334 { |
|
335 LOGGER_WRITE_1( "RSconSyncSession::MoveItemL() :\ |
|
336 Send Receive failed with code %d", ret ); |
|
337 User::Leave( ret ); |
|
338 }; |
|
339 TRACE_FUNC_EXIT; |
|
340 } |
|
341 |
|
342 EXPORT_C void RSconSyncSession::DeleteItemL( TSmlDbItemUid aUid ) |
|
343 { |
|
344 TRACE_FUNC_ENTRY; |
|
345 |
|
346 TIpcArgs args( aUid ); |
|
347 TInt ret = SendReceive ( EDeleteItem, args ); |
|
348 if ( ret != KErrNone) |
|
349 { |
|
350 LOGGER_WRITE_1( "RSconSyncSession::DeleteItemL() :\ |
|
351 Send Receive failed with code %d", ret ); |
|
352 User::Leave( ret ); |
|
353 }; |
|
354 TRACE_FUNC_EXIT; |
|
355 } |
|
356 |
|
357 |
|
358 EXPORT_C void RSconSyncSession::SoftDeleteItemL( TSmlDbItemUid aUid ) |
|
359 { |
|
360 TRACE_FUNC_ENTRY; |
|
361 |
|
362 TIpcArgs args( aUid ); |
|
363 TInt ret = SendReceive ( ESoftDeleteItem, args ); |
|
364 if ( ret != KErrNone) |
|
365 { |
|
366 LOGGER_WRITE_1( "RSconSyncSession::SoftDeleteItemL() :\ |
|
367 Send Receive failed with code %d", ret ); |
|
368 User::Leave( ret ); |
|
369 }; |
|
370 TRACE_FUNC_EXIT; |
|
371 } |
|
372 |
|
373 EXPORT_C void RSconSyncSession::DeleteAllItems( TRequestStatus& aStatus ) |
|
374 { |
|
375 TRACE_FUNC_ENTRY; |
|
376 TIpcArgs args; |
|
377 SendReceive( EDeleteAllItems, args, aStatus ); |
|
378 TRACE_FUNC_EXIT; |
|
379 } |
|
380 |
|
381 |
|
382 EXPORT_C TBool RSconSyncSession::HasSyncHistoryL() const |
|
383 { |
|
384 TRACE_FUNC; |
|
385 TBool history(EFalse); |
|
386 TPckg<TBool> pck(history); |
|
387 TIpcArgs args(&pck); |
|
388 TInt ret = SendReceive ( EHasHistory, args ); |
|
389 User::LeaveIfError( ret ); |
|
390 TRACE_FUNC_EXIT; |
|
391 return history; |
|
392 } |
|
393 |
|
394 EXPORT_C void RSconSyncSession::AddedItemsL( RArray<TSmlDbItemUid>& aItems) const |
|
395 { |
|
396 TRACE_FUNC_ENTRY; |
|
397 TIpcArgs args; |
|
398 TInt ret = SendReceive ( EAddedItems, args ); |
|
399 User::LeaveIfError( ret ); |
|
400 |
|
401 RMemReadStream readStream( iChunk.Base(), iChunk.Size() ); |
|
402 CleanupClosePushL( readStream ); |
|
403 |
|
404 aItems.Reset(); |
|
405 TInt itemCount = readStream.ReadInt32L(); |
|
406 for (TInt i=0; i<itemCount; i++) |
|
407 { |
|
408 aItems.AppendL( readStream.ReadInt32L() ); |
|
409 } |
|
410 |
|
411 CleanupStack::PopAndDestroy( &readStream ); |
|
412 |
|
413 TRACE_FUNC_EXIT; |
|
414 } |
|
415 |
|
416 EXPORT_C void RSconSyncSession::DeletedItemsL( RArray<TSmlDbItemUid>& aItems) const |
|
417 { |
|
418 TRACE_FUNC_ENTRY; |
|
419 TIpcArgs args; |
|
420 TInt ret = SendReceive ( EDeletedItems, args ); |
|
421 User::LeaveIfError( ret ); |
|
422 |
|
423 RMemReadStream readStream( iChunk.Base(), iChunk.Size() ); |
|
424 CleanupClosePushL( readStream ); |
|
425 |
|
426 aItems.Reset(); |
|
427 TInt itemCount = readStream.ReadInt32L(); |
|
428 for (TInt i=0; i<itemCount; i++) |
|
429 { |
|
430 aItems.AppendL( readStream.ReadInt32L() ); |
|
431 } |
|
432 |
|
433 CleanupStack::PopAndDestroy( &readStream ); |
|
434 |
|
435 TRACE_FUNC_EXIT; |
|
436 } |
|
437 |
|
438 EXPORT_C void RSconSyncSession::SoftDeletedItemsL( RArray<TSmlDbItemUid>& aItems) const |
|
439 { |
|
440 TRACE_FUNC_ENTRY; |
|
441 TIpcArgs args; |
|
442 TInt ret = SendReceive ( ESoftDeletedItems, args ); |
|
443 User::LeaveIfError( ret ); |
|
444 |
|
445 RMemReadStream readStream( iChunk.Base(), iChunk.Size() ); |
|
446 CleanupClosePushL( readStream ); |
|
447 |
|
448 aItems.Reset(); |
|
449 TInt itemCount = readStream.ReadInt32L(); |
|
450 for (TInt i=0; i<itemCount; i++) |
|
451 { |
|
452 aItems.AppendL( readStream.ReadInt32L() ); |
|
453 } |
|
454 |
|
455 CleanupStack::PopAndDestroy( &readStream ); |
|
456 |
|
457 TRACE_FUNC_EXIT; |
|
458 } |
|
459 |
|
460 EXPORT_C void RSconSyncSession::ModifiedItemsL( RArray<TSmlDbItemUid>& aItems) const |
|
461 { |
|
462 TRACE_FUNC_ENTRY; |
|
463 TIpcArgs args; |
|
464 TInt ret = SendReceive ( EModifiedItems, args ); |
|
465 User::LeaveIfError( ret ); |
|
466 |
|
467 RMemReadStream readStream( iChunk.Base(), iChunk.Size() ); |
|
468 CleanupClosePushL( readStream ); |
|
469 |
|
470 aItems.Reset(); |
|
471 TInt itemCount = readStream.ReadInt32L(); |
|
472 for (TInt i=0; i<itemCount; i++) |
|
473 { |
|
474 aItems.AppendL( readStream.ReadInt32L() ); |
|
475 } |
|
476 |
|
477 CleanupStack::PopAndDestroy( &readStream ); |
|
478 |
|
479 TRACE_FUNC_EXIT; |
|
480 } |
|
481 |
|
482 EXPORT_C void RSconSyncSession::MovedItemsL( RArray<TSmlDbItemUid>& aItems) const |
|
483 { |
|
484 TRACE_FUNC_ENTRY; |
|
485 TIpcArgs args; |
|
486 TInt ret = SendReceive ( EMovedItems, args ); |
|
487 User::LeaveIfError( ret ); |
|
488 |
|
489 RMemReadStream readStream( iChunk.Base(), iChunk.Size() ); |
|
490 CleanupClosePushL( readStream ); |
|
491 |
|
492 aItems.Reset(); |
|
493 TInt itemCount = readStream.ReadInt32L(); |
|
494 for (TInt i=0; i<itemCount; i++) |
|
495 { |
|
496 aItems.AppendL( readStream.ReadInt32L() ); |
|
497 } |
|
498 |
|
499 CleanupStack::PopAndDestroy( &readStream ); |
|
500 |
|
501 TRACE_FUNC_EXIT; |
|
502 } |
|
503 |
|
504 EXPORT_C void RSconSyncSession::CloseDataStore() const |
|
505 { |
|
506 TRACE_FUNC_ENTRY; |
|
507 TIpcArgs args; |
|
508 SendReceive ( ECloseStore, args ); |
|
509 TRACE_FUNC_EXIT; |
|
510 } |
|
511 |
|
512 EXPORT_C void RSconSyncSession::ResetChangeInfoL() |
|
513 { |
|
514 TRACE_FUNC_ENTRY; |
|
515 TIpcArgs args; |
|
516 TInt ret = SendReceive ( EResetChangeInfo, args ); |
|
517 User::LeaveIfError( ret ); |
|
518 TRACE_FUNC_EXIT; |
|
519 } |
|
520 |
|
521 EXPORT_C void RSconSyncSession::CommitChangeInfoL(const RArray<TSmlDbItemUid>& aItems ) |
|
522 { |
|
523 TRACE_FUNC_ENTRY; |
|
524 RMemWriteStream stream ( iChunk.Base(), iChunk.Size() ); |
|
525 CleanupClosePushL( stream ); |
|
526 LOGGER_WRITE_1("items count: %d", aItems.Count()); |
|
527 stream.WriteInt32L( aItems.Count() ); |
|
528 for (TInt i=0; i < aItems.Count(); i++ ) |
|
529 { |
|
530 LOGGER_WRITE("Write item"); |
|
531 stream.WriteInt32L( aItems[i] ); |
|
532 } |
|
533 stream.CommitL(); |
|
534 CleanupStack::PopAndDestroy( &stream ); |
|
535 |
|
536 TIpcArgs args; |
|
537 TInt ret = SendReceive ( ECommitChangeInfo, args ); |
|
538 User::LeaveIfError( ret ); |
|
539 TRACE_FUNC_EXIT; |
|
540 } |
|
541 |
|
542 EXPORT_C void RSconSyncSession::GetSyncTimeStampL( const TSmlDataProviderId aProviderId, const TInt aContextId, TDateTime& aTimeStamp ) const |
|
543 { |
|
544 TRACE_FUNC_ENTRY; |
|
545 |
|
546 TPckg<TDateTime> timeBuf( aTimeStamp ); |
|
547 TIpcArgs args( aProviderId, aContextId, &timeBuf ); |
|
548 TInt ret = SendReceive ( EGetSyncTimeStamp, args ); |
|
549 User::LeaveIfError( ret ); |
|
550 |
|
551 TRACE_FUNC_EXIT; |
|
552 } |
|
553 |
|
554 EXPORT_C CSmlDataStoreFormat* RSconSyncSession::StoreFormatL( const RStringPool& aStringPool ) |
|
555 { |
|
556 TRACE_FUNC_ENTRY; |
|
557 TIpcArgs args; |
|
558 TInt ret = SendReceive ( EExportStoreFormat, args ); |
|
559 User::LeaveIfError( ret ); |
|
560 |
|
561 RMemReadStream readStream( iChunk.Base(), iChunk.Size() ); |
|
562 CleanupClosePushL( readStream ); |
|
563 TInt len = readStream.ReadInt32L(); |
|
564 LOGGER_WRITE_1("data size from server: %d", len); |
|
565 LOGGER_WRITE("CSmlDataStoreFormat::NewLC"); |
|
566 CSmlDataStoreFormat* tempStoreFormat = CSmlDataStoreFormat::NewLC( aStringPool, readStream ); |
|
567 LOGGER_WRITE("CSmlDataStoreFormat::NewLC -ok"); |
|
568 CleanupStack::Pop( tempStoreFormat ); |
|
569 |
|
570 LOGGER_WRITE("PopAndDestroy( &readStream )"); |
|
571 CleanupStack::PopAndDestroy( &readStream ); |
|
572 LOGGER_WRITE("return"); |
|
573 TRACE_FUNC_EXIT; |
|
574 return tempStoreFormat; |
|
575 } |
|
576 |
|
577 EXPORT_C void RSconSyncSession::SetRemoteStoreFormatL( const CSmlDataStoreFormat& aServerDataStoreFormat ) |
|
578 { |
|
579 TRACE_FUNC_ENTRY; |
|
580 const TInt KMaximumDataStoreFormatSize = 100000; // 100kb should be enought |
|
581 User::LeaveIfError( iChunk.Adjust( KMaximumDataStoreFormatSize )); |
|
582 |
|
583 RMemWriteStream stream ( iChunk.Base(), iChunk.Size() ); |
|
584 CleanupClosePushL( stream ); |
|
585 |
|
586 aServerDataStoreFormat.ExternalizeL( stream ); |
|
587 |
|
588 stream.CommitL(); |
|
589 CleanupStack::PopAndDestroy( &stream ); |
|
590 |
|
591 TIpcArgs args; |
|
592 TInt ret = SendReceive ( ESetRemoteStoreFormat, args ); |
|
593 User::LeaveIfError( ret ); |
|
594 TRACE_FUNC_EXIT; |
|
595 } |
|
596 |
|
597 EXPORT_C void RSconSyncSession::CancelRequest() |
|
598 { |
|
599 TRACE_FUNC_ENTRY; |
|
600 SendReceive( ECancelRequest, TIpcArgs() ); |
|
601 TRACE_FUNC_EXIT; |
|
602 } |
|
603 |
|
604 EXPORT_C TInt RSconSyncSession::GetParent( TSmlDbItemUid aUid, TSmlDbItemUid& aParent ) |
|
605 { |
|
606 TRACE_FUNC_ENTRY; |
|
607 TPckg<TSmlDbItemUid> pckg(aParent); |
|
608 TIpcArgs args( aUid, &pckg ); |
|
609 TInt ret = SendReceive( EReadParent, args ); |
|
610 TRACE_FUNC_EXIT; |
|
611 return ret; |
|
612 } |
|
613 |
|
614 TInt RSconSyncSession::StartServer() |
|
615 { |
|
616 TRACE_FUNC_ENTRY; |
|
617 |
|
618 RProcess server; |
|
619 TInt error = server.Create(KSconSyncServerExe, KNullDesC); |
|
620 if ( error != KErrNone ) |
|
621 { |
|
622 return error; |
|
623 } |
|
624 // start server and wait for signal before proceeding |
|
625 TRequestStatus status; |
|
626 server.Rendezvous(status); |
|
627 if ( status.Int() != KRequestPending ) |
|
628 { |
|
629 server.Kill(0); |
|
630 } |
|
631 else |
|
632 { |
|
633 server.Resume(); |
|
634 } |
|
635 |
|
636 User::WaitForRequest( status ); |
|
637 error = server.ExitType() == EExitPanic ? KErrGeneral : status.Int(); |
|
638 server.Close(); |
|
639 TRACE_FUNC_EXIT; |
|
640 return error; |
|
641 } |
|
642 |
|
643 // ----------------------------------------------------------------------------- |
|
644 // RSconSyncSession::CreateAndSendChunkHandle() |
|
645 // Creates a chunk and sends a handle to server |
|
646 // ----------------------------------------------------------------------------- |
|
647 // |
|
648 TInt RSconSyncSession::CreateAndSendChunkHandle() |
|
649 { |
|
650 TRACE_FUNC_ENTRY; |
|
651 |
|
652 TInt err = iChunk.CreateGlobal( KNullDesC, |
|
653 KSConSyncChunkSize, |
|
654 KSConSyncChunkMaxSize ); |
|
655 if ( err != KErrNone ) |
|
656 { |
|
657 LOGGER_WRITE_1("iChunk.CreateGlobal failed, err: %d", err); |
|
658 return err; |
|
659 } |
|
660 TIpcArgs args; |
|
661 args.Set( 0, iChunk ); |
|
662 err = SendReceive( ESendChunkHandle, args ); |
|
663 |
|
664 LOGGER_WRITE_1("RSconSyncSession::CreateAndSendChunkHandle : returned: %d", err); |
|
665 return err; |
|
666 } |
|
667 |
|
668 // End of File |
|