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: Session implementation class for Content Manager |
|
15 * |
|
16 */ |
|
17 |
|
18 |
|
19 // INCLUDE FILES |
|
20 #include <e32base.h> |
|
21 #include <s32mem.h> |
|
22 |
|
23 #include "cmcommon.h" |
|
24 #include "cmfillrulecontainer.h" |
|
25 #include "cmfillrule.h" |
|
26 #include "cmstorerulecontainer.h" |
|
27 #include "cmstorerule.h" |
|
28 #include "cmbaselistitem.h" |
|
29 #include "cmdmmain.h" |
|
30 #include "cmsettingsfactory.h" |
|
31 #include "cmsettings.h" |
|
32 #include "cmmediaserverfull.h" |
|
33 #include "cmsqlpropertycontainer.h" |
|
34 #include "cmsqlpropertycollector.h" |
|
35 #include "cmdriveinfo.h" |
|
36 #include "cmserversession.h" |
|
37 #include "cmserver.h" |
|
38 #include "msdebug.h" |
|
39 |
|
40 // data buffer size |
|
41 const TInt KBufferExpandSize = KKilo; |
|
42 |
|
43 |
|
44 // ============================ MEMBER FUNCTIONS ============================= |
|
45 |
|
46 // --------------------------------------------------------------------------- |
|
47 // CCmSession::CCmSession |
|
48 // --------------------------------------------------------------------------- |
|
49 // |
|
50 CCmSession::CCmSession( CCmDmMain& aDbManager, MCmSettings& aSettings ) |
|
51 : iDbManager( aDbManager ), iSettings( aSettings ) |
|
52 { |
|
53 } |
|
54 |
|
55 // --------------------------------------------------------------------------- |
|
56 // CCmSession::NewL |
|
57 // --------------------------------------------------------------------------- |
|
58 // |
|
59 CCmSession* CCmSession::NewL( CCmDmMain& aDbManager, |
|
60 MCmSettings& aSettings ) |
|
61 { |
|
62 LOG(_L("[Cm Server]\t CCmSession::NewL")); |
|
63 CCmSession* self = |
|
64 new (ELeave) CCmSession( aDbManager, aSettings ); |
|
65 CleanupStack::PushL( self ); |
|
66 self->ConstructL(); |
|
67 CleanupStack::Pop( self ); |
|
68 return self; |
|
69 } |
|
70 |
|
71 // --------------------------------------------------------------------------- |
|
72 // CCmSession::ConstructL |
|
73 // --------------------------------------------------------------------------- |
|
74 // |
|
75 void CCmSession::ConstructL() |
|
76 { |
|
77 LOG(_L("[Cm Server]\t CCmSession::ConstructL")) |
|
78 iCollector = CCmSqlPropertyCollector::NewL(); |
|
79 } |
|
80 |
|
81 |
|
82 // --------------------------------------------------------------------------- |
|
83 // CCmSession::~CCmSession |
|
84 // --------------------------------------------------------------------------- |
|
85 // |
|
86 CCmSession::~CCmSession() |
|
87 { |
|
88 LOG(_L("[Cm Server]\t CCmSession::~CCmSession")); |
|
89 |
|
90 delete iDataBuffer; |
|
91 |
|
92 Server().DecrementSessions(); |
|
93 |
|
94 delete iCollector; |
|
95 } |
|
96 |
|
97 |
|
98 |
|
99 // --------------------------------------------------------------------------- |
|
100 // CCmSession::Server |
|
101 // Returns a reference to server |
|
102 // --------------------------------------------------------------------------- |
|
103 // |
|
104 CCmServer& CCmSession::Server() |
|
105 { |
|
106 LOG(_L("[Cm Server]\t CCmSession::Server")); |
|
107 |
|
108 return *static_cast<CCmServer*>(const_cast<CServer2*> |
|
109 (CSession2::Server())); |
|
110 } |
|
111 |
|
112 |
|
113 |
|
114 // --------------------------------------------------------------------------- |
|
115 // CCmSession::ServiceL |
|
116 // Implements CSession2 -derived ServiceL -method. |
|
117 // (other items were commented in a header). |
|
118 // --------------------------------------------------------------------------- |
|
119 // |
|
120 void CCmSession::ServiceL(const RMessage2& aMessage) |
|
121 { |
|
122 LOG(_L("[Cm Server]\t CCmSession::ServiceL")); |
|
123 |
|
124 switch ( aMessage.Function() ) |
|
125 { |
|
126 case ECmExecuteService: |
|
127 { |
|
128 LOG(_L("[Cm Server]\t ECmExecuteService request")); |
|
129 TCmService service = (TCmService)aMessage.Int0(); |
|
130 |
|
131 TRACE( Print (_L("[Cm Server]\t CCmSession::\ |
|
132 ServiceL ECmExecuteService service = %d\n"), service )); |
|
133 |
|
134 Server().SetCurrentAsyncMsg( aMessage ); |
|
135 Server().ExecuteServiceL( service ); |
|
136 break; |
|
137 } |
|
138 |
|
139 case ECmCancel: |
|
140 { |
|
141 LOG(_L("[Cm Server]\t ECmCancel request")); |
|
142 Server().CancelServiceL(); |
|
143 |
|
144 aMessage.Complete( KErrNone ); |
|
145 break; |
|
146 } |
|
147 |
|
148 case ECmGetServerState: |
|
149 { |
|
150 LOG(_L("[Cm Server]\t ECmGetServerState request")); |
|
151 TPckg<TCmServerState> pckg( Server().ServerState() ); |
|
152 aMessage.WriteL(0, pckg ); |
|
153 aMessage.Complete( KErrNone ); |
|
154 break; |
|
155 } |
|
156 |
|
157 case ECmGetServiceState: |
|
158 { |
|
159 LOG(_L("[Cm Server]\t ECmGetServiceState request")); |
|
160 TCmService service = static_cast<TCmService>(aMessage.Int0()); |
|
161 |
|
162 TRACE( Print (_L("[Cm Server]\t CCmSession::\ |
|
163 ServiceL ECmGetServiceState service = %d\n"), service )); |
|
164 |
|
165 TCmServiceState state = ECmServiceStateDisabled; |
|
166 TInt err( KErrNone ); |
|
167 switch ( service ) |
|
168 { |
|
169 case ECmServiceFill: // fall through |
|
170 case ECmServiceStore: // fall through |
|
171 case ECmServiceContentManager: |
|
172 { |
|
173 iSettings.GetServiceState( ECmServiceContentManager, |
|
174 state ); |
|
175 if ( state ) |
|
176 { |
|
177 TBool autoSync = EFalse; |
|
178 iSettings.GetAutoSync( autoSync ); |
|
179 if ( autoSync ) |
|
180 { |
|
181 state = ECmServiceStateAutomatic; |
|
182 } |
|
183 else |
|
184 { |
|
185 LOG(_L("[Cm Server]\t ECmGetServiceState \ |
|
186 request autosync = disabled")); |
|
187 } |
|
188 } |
|
189 else |
|
190 { |
|
191 LOG(_L("[Cm Server]\t ECmGetServiceState request \ |
|
192 state = ECmServiceStateDisabled")); |
|
193 } |
|
194 break; |
|
195 } |
|
196 case ECmServiceMemoryManager: |
|
197 { |
|
198 TBool mm = EFalse; |
|
199 iSettings.GetMemoryManagerStatus( mm ); |
|
200 state = ECmServiceStateAutomatic; |
|
201 if ( !mm ) |
|
202 { |
|
203 state = ECmServiceStateDisabled; |
|
204 } |
|
205 |
|
206 break; |
|
207 } |
|
208 default: |
|
209 { |
|
210 err = KErrArgument; |
|
211 break; |
|
212 } |
|
213 } |
|
214 TPckg<TCmServiceState> pckg( state ); |
|
215 aMessage.WriteL(1, pckg ); |
|
216 aMessage.Complete( err ); |
|
217 break; |
|
218 } |
|
219 |
|
220 case ECmSetServiceState: |
|
221 { |
|
222 LOG(_L("[Cm Server]\t ECmSetServiceState request")); |
|
223 |
|
224 TCmService service = static_cast<TCmService>(aMessage.Int0()); |
|
225 TCmServiceState state = |
|
226 static_cast<TCmServiceState>(aMessage.Int1()); |
|
227 |
|
228 TRACE(Print(_L("[Cm Server]\t service %d state %d \n"), |
|
229 service, state )); |
|
230 |
|
231 Server().SetServiceStateL( service, state ); |
|
232 |
|
233 aMessage.Complete( KErrNone ); |
|
234 break; |
|
235 } |
|
236 |
|
237 case ECmGetItemCount: |
|
238 { |
|
239 LOG(_L("[Cm Server]\t ECmGetItemCount request")); |
|
240 TCmService service = static_cast<TCmService>(aMessage.Int2()); |
|
241 |
|
242 TRACE( Print (_L("[Cm Server]\t CCmSession::\ |
|
243 ServiceL ECmGetItemCount service = %d\n"), service )); |
|
244 |
|
245 TInt len = aMessage.GetDesLength( 3 ); |
|
246 if( len <= 0 ) |
|
247 { |
|
248 LOG(_L("[Cm Server]\t ECmGetItemCount request \ |
|
249 leaving with KErrArgument")); |
|
250 User::Leave( KErrArgument ); |
|
251 } |
|
252 HBufC8* name = HBufC8::NewLC( len ); |
|
253 TPtr8 ptr( name->Des() ); |
|
254 aMessage.ReadL( 3, ptr ); |
|
255 TInt64 size = 0; |
|
256 TInt count = 0; |
|
257 |
|
258 if ( service == ECmServiceFill ) |
|
259 { |
|
260 size = iDbManager.ListSize( |
|
261 ECmFmFillRule, |
|
262 *name, |
|
263 ECmFilled | ECmToBeFilled | ECmToBeShrinked |
|
264 ); |
|
265 iDbManager.GetFillFileCount( |
|
266 *name, |
|
267 ECmFilled | ECmToBeFilled | ECmToBeShrinked, |
|
268 count |
|
269 ); |
|
270 TRACE(Print(_L("[Cm Server]\t got fill size %ld count %d"), |
|
271 size, count)); |
|
272 } |
|
273 else // ECmServiceStore |
|
274 { |
|
275 size = iDbManager.ListSize( |
|
276 ECmFmStoreRule, |
|
277 *name, |
|
278 ECmToBeRemoved | ECmToBeShrinked | ECmKeepOnDevice |
|
279 ); |
|
280 iDbManager.GetStoreFileCount( |
|
281 *name, |
|
282 ECmToBeRemoved | ECmToBeShrinked | ECmKeepOnDevice, |
|
283 count |
|
284 ); |
|
285 TRACE(Print(_L("[Cm Server]\t got store size %ld count %d"), |
|
286 size, count)); |
|
287 } |
|
288 CleanupStack::PopAndDestroy( name ); |
|
289 TPckg<TInt> countPckg( count ); |
|
290 TPckg<TInt64> sizePckg( size ); |
|
291 aMessage.WriteL( 0, countPckg ); |
|
292 aMessage.WriteL( 1, sizePckg ); |
|
293 |
|
294 aMessage.Complete( KErrNone ); |
|
295 break; |
|
296 } |
|
297 |
|
298 case ECmGetTransferInfo: |
|
299 { |
|
300 LOG(_L("[Cm Server]\t ECmGetTransferInfo request")); |
|
301 TCmService service = static_cast<TCmService>(aMessage.Int0()); |
|
302 TInt count( 0 ); |
|
303 TInt time( 0 ); |
|
304 TPckg<TInt> countPckg( count ); |
|
305 TPckg<TInt> timePckg( time ); |
|
306 |
|
307 iDbManager.GetTransferInfo( |
|
308 service, count, time ); |
|
309 |
|
310 TRACE(Print(_L("[Cm Server]\t ECmGetTransferInfo \ |
|
311 count = %d, time = %d"), count, time)); |
|
312 |
|
313 aMessage.WriteL( 1, countPckg ); |
|
314 aMessage.WriteL( 2, timePckg ); |
|
315 aMessage.Complete( KErrNone ); |
|
316 break; |
|
317 } |
|
318 |
|
319 |
|
320 case ECmGetDataFields: |
|
321 { |
|
322 LOG(_L("[Cm Server]\t ECmGetDataFields request")); |
|
323 |
|
324 TInt len = aMessage.GetDesLength(0); |
|
325 if( len <= 0 ) |
|
326 { |
|
327 LOG(_L("[Cm Server]\t ECmGetDataFields request \ |
|
328 leaving with KErrArgument")); |
|
329 User::Leave( KErrArgument ); |
|
330 } |
|
331 TRACE(Print(_L("[Cm Server]\t buffer length is %d"), len)); |
|
332 |
|
333 HBufC8* buffer = HBufC8::NewLC(len); |
|
334 |
|
335 TPtr8 ptr(buffer->Des()); |
|
336 aMessage.ReadL(0, ptr); |
|
337 RDesReadStream stream; |
|
338 stream.Open(ptr); |
|
339 CleanupClosePushL(stream); |
|
340 |
|
341 iCollector->InternalizeL( stream ); |
|
342 |
|
343 Server().SetCurrentAsyncMsg( aMessage ); |
|
344 Server().ExecuteServiceL( ECmServiceGetFillFields, |
|
345 0, |
|
346 iCollector ); |
|
347 CleanupStack::PopAndDestroy( 2 ); |
|
348 break; |
|
349 } |
|
350 |
|
351 case ECmGetDataFieldSize: |
|
352 { |
|
353 LOG(_L("[Cm Server]\t ECmGetDataFieldSize request")); |
|
354 |
|
355 delete iDataBuffer; |
|
356 iDataBuffer = NULL; |
|
357 |
|
358 iDataBuffer = CBufFlat::NewL( KBufferExpandSize ); |
|
359 RBufWriteStream propertyStream; |
|
360 propertyStream.Open( *iDataBuffer ); |
|
361 CleanupClosePushL( propertyStream ); |
|
362 |
|
363 CCmSqlPropertyCollector* propertyCollector = |
|
364 Server().PropertyCollector(); |
|
365 |
|
366 if( !propertyCollector ) |
|
367 { |
|
368 LOG(_L("[Cm Server]\t ECmGetDataFieldSize request \ |
|
369 leaving with KErrArgument")); |
|
370 User::Leave( KErrArgument ); |
|
371 } |
|
372 propertyCollector->ExternalizeL( propertyStream ); |
|
373 |
|
374 TInt size = iDataBuffer->Size(); |
|
375 TPckg<TInt> pckg( size ); |
|
376 aMessage.WriteL(0, pckg ); |
|
377 CleanupStack::PopAndDestroy( &propertyStream ); |
|
378 |
|
379 TRACE(Print(_L("[Cm Server]\t buffer size is %d"), size)); |
|
380 |
|
381 aMessage.Complete( KErrNone ); |
|
382 break; |
|
383 } |
|
384 |
|
385 case ECmGetDataBuffer: |
|
386 { |
|
387 TInt errCode = KErrNone; |
|
388 if ( !iDataBuffer ) |
|
389 { |
|
390 LOG(_L("[Cm Server]\t ECmGetDataBuffer \ |
|
391 databuffer doesn't exist")); |
|
392 errCode = KErrNotReady; |
|
393 } |
|
394 |
|
395 if (errCode == KErrNone ) |
|
396 { |
|
397 aMessage.WriteL(0, iDataBuffer->Ptr(0)); |
|
398 } |
|
399 aMessage.Complete( errCode ); |
|
400 break; |
|
401 } |
|
402 |
|
403 case ECmGetFillRulesSize: |
|
404 { |
|
405 LOG(_L("[Cm Server]\t ECmGetFillRulesSize request")); |
|
406 |
|
407 delete iDataBuffer; |
|
408 iDataBuffer = NULL; |
|
409 |
|
410 iDataBuffer = CBufFlat::NewL( KBufferExpandSize ); |
|
411 RBufWriteStream ruleStream; |
|
412 ruleStream.Open( *iDataBuffer ); |
|
413 CleanupClosePushL( ruleStream ); |
|
414 |
|
415 CCmFillRuleContainer* ruleContainer = |
|
416 Server().FillRuleContainerL(); |
|
417 CleanupStack::PushL( ruleContainer ); |
|
418 ruleContainer->ExternalizeL( ruleStream ); |
|
419 CleanupStack::PopAndDestroy( ruleContainer ); |
|
420 |
|
421 TInt size = iDataBuffer->Size(); |
|
422 TPckg<TInt> pckg( size ); |
|
423 aMessage.WriteL(0, pckg ); |
|
424 CleanupStack::PopAndDestroy( &ruleStream ); |
|
425 |
|
426 TRACE(Print(_L("[Cm Server]\t buffer size is %d"), size)); |
|
427 |
|
428 aMessage.Complete( KErrNone ); |
|
429 LOG(_L("[Cm Server]\t ECmGetFillRulesSize request end")); |
|
430 |
|
431 break; |
|
432 } |
|
433 |
|
434 case ECmGetStoreItemsSize: |
|
435 { |
|
436 LOG(_L("[Cm Server]\t ECmGetStoreItemsSize request")); |
|
437 |
|
438 TInt len = aMessage.GetDesLength( 0 ); |
|
439 if( len <= 0 ) |
|
440 { |
|
441 LOG(_L("[Cm Server]\t ECmGetStoreItemsSize request \ |
|
442 leaving with KErrArgument")); |
|
443 User::Leave( KErrArgument ); |
|
444 } |
|
445 HBufC8* name = HBufC8::NewLC( len ); |
|
446 TPtr8 ptr( name->Des() ); |
|
447 aMessage.ReadL(0, ptr); |
|
448 |
|
449 iDbManager.PrepareQueryCmdL( EStoreFilesQuery ); |
|
450 RPointerArray<CCmBaseListItem> items; |
|
451 CleanupClosePushL( items ); |
|
452 |
|
453 iDbManager.QueryStoreFileListL( |
|
454 items, |
|
455 *name, |
|
456 ECmToBeRemoved | ECmToBeShrinked | ECmKeepOnDevice |
|
457 ); |
|
458 |
|
459 TInt count = items.Count(); |
|
460 |
|
461 TRACE(Print(_L("[Cm Server]\t store item array size is %d"), |
|
462 count)); |
|
463 |
|
464 delete iDataBuffer; |
|
465 iDataBuffer = NULL; |
|
466 |
|
467 iDataBuffer = CBufFlat::NewL( KBufferExpandSize ); |
|
468 RBufWriteStream ruleStream; |
|
469 ruleStream.Open( *iDataBuffer ); |
|
470 CleanupClosePushL( ruleStream ); |
|
471 |
|
472 for ( TInt i = 0; i < count; i++ ) |
|
473 { |
|
474 items[i]->ExternalizeL( ruleStream ); |
|
475 } |
|
476 |
|
477 CleanupStack::PopAndDestroy( &ruleStream ); |
|
478 items.ResetAndDestroy(); |
|
479 CleanupStack::PopAndDestroy( &items ); |
|
480 CleanupStack::PopAndDestroy( name ); |
|
481 |
|
482 TInt size = iDataBuffer->Size(); |
|
483 |
|
484 TPckg<TInt> sizePckg( size ); |
|
485 aMessage.WriteL( 1, sizePckg ); |
|
486 TRACE(Print(_L("[Cm Server]\t buffer size is %d"), size)); |
|
487 |
|
488 TPckg<TInt> countPckg( count ); |
|
489 aMessage.WriteL( 2, countPckg ); |
|
490 TRACE(Print(_L("[Cm Server]\t item count is %d"), count)); |
|
491 |
|
492 aMessage.Complete( KErrNone ); |
|
493 |
|
494 LOG(_L("[Cm Server]\t ECmGetStoreItemsSize request end")); |
|
495 |
|
496 break; |
|
497 } |
|
498 |
|
499 case ECmGetFillItemsSize: |
|
500 { |
|
501 LOG(_L("[Cm Server]\t ECmGetFillItemsSize request")); |
|
502 |
|
503 TInt len = aMessage.GetDesLength( 0 ); |
|
504 if( len <= 0 ) |
|
505 { |
|
506 LOG(_L("[Cm Server]\t ECmGetFillItemsSize request \ |
|
507 leaving with KErrArgument")); |
|
508 User::Leave( KErrArgument ); |
|
509 } |
|
510 HBufC8* name = HBufC8::NewLC( len ); |
|
511 TPtr8 ptr( name->Des() ); |
|
512 aMessage.ReadL(0, ptr); |
|
513 |
|
514 iDbManager.PrepareQueryCmdL( EFillFilesQuery ); |
|
515 RPointerArray<CCmBaseListItem> items; |
|
516 CleanupClosePushL( items ); |
|
517 |
|
518 iDbManager.QueryFillFileListL( |
|
519 items, |
|
520 *name, |
|
521 ECmFilled | ECmToBeFilled | ECmToBeShrinked | ECmLocalCopy |
|
522 ); |
|
523 |
|
524 TInt count = items.Count(); |
|
525 |
|
526 TRACE(Print(_L("[Cm Server]\t list item array size is %d"), |
|
527 count)); |
|
528 |
|
529 delete iDataBuffer; |
|
530 iDataBuffer = NULL; |
|
531 |
|
532 iDataBuffer = CBufFlat::NewL( KBufferExpandSize ); |
|
533 RBufWriteStream ruleStream; |
|
534 ruleStream.Open( *iDataBuffer ); |
|
535 CleanupClosePushL( ruleStream ); |
|
536 |
|
537 for ( TInt i = 0; i < count; i++ ) |
|
538 { |
|
539 items[i]->ExternalizeL( ruleStream ); |
|
540 } |
|
541 |
|
542 CleanupStack::PopAndDestroy( &ruleStream ); |
|
543 items.ResetAndDestroy(); |
|
544 CleanupStack::PopAndDestroy( &items ); |
|
545 CleanupStack::PopAndDestroy( name ); |
|
546 TInt size = iDataBuffer->Size(); |
|
547 |
|
548 TPckg<TInt> sizePckg( size ); |
|
549 aMessage.WriteL( 1, sizePckg ); |
|
550 TRACE(Print(_L("[Cm Server]\t buffer size is %d"), size)); |
|
551 |
|
552 TPckg<TInt> countPckg( count ); |
|
553 aMessage.WriteL( 2, countPckg ); |
|
554 TRACE(Print(_L("[Cm Server]\t item count is %d"), count)); |
|
555 |
|
556 aMessage.Complete( KErrNone ); |
|
557 |
|
558 LOG(_L("[Cm Server]\t ECmGetStoreItemsSize request end")); |
|
559 |
|
560 break; |
|
561 } |
|
562 |
|
563 case ECmSetFillRules: |
|
564 { |
|
565 LOG(_L("[Cm Server]\t ECmSetFillRules request")); |
|
566 |
|
567 TInt len = aMessage.GetDesLength(0); |
|
568 if( len <= 0 ) |
|
569 { |
|
570 LOG(_L("[Cm Server]\t ECmSetFillRules request \ |
|
571 leaving with KErrArgument")); |
|
572 User::Leave( KErrArgument ); |
|
573 } |
|
574 TRACE(Print(_L("[Cm Server]\t buffer length is %d"), len)); |
|
575 |
|
576 HBufC8* buffer = HBufC8::NewLC(len); |
|
577 |
|
578 TPtr8 ptr(buffer->Des()); |
|
579 aMessage.ReadL(0, ptr); |
|
580 RDesReadStream stream; |
|
581 stream.Open(ptr); |
|
582 CleanupClosePushL(stream); |
|
583 |
|
584 CCmFillRuleContainer* tempContainer = |
|
585 CCmFillRuleContainer::NewLC(); |
|
586 tempContainer->InternalizeL( stream ); |
|
587 iDbManager.DeleteAllFillRules(); |
|
588 for ( TInt i = 0; i < tempContainer->FillRuleCount(); i++ ) |
|
589 { |
|
590 #ifdef _DEBUG |
|
591 TDesC8& name = tempContainer->FillRule( i )->Name(); |
|
592 TBuf<KMaxFileName> buf; |
|
593 buf.Copy(name); |
|
594 TRACE(Print(_L("[Cm Server]\t updating fill rule %S"), &buf)); |
|
595 #endif |
|
596 |
|
597 if ( tempContainer->FillRule( i )->Selected() == ECmDeleted ) |
|
598 { |
|
599 TRACE(Print(_L("[Cm Server]\t skipping deleted rule %S"), |
|
600 &buf)); |
|
601 iDbManager.SetFillListStateL( |
|
602 tempContainer->FillRule( i )->ListId(), ECmDeleted ); |
|
603 } |
|
604 else |
|
605 { |
|
606 TRACE(Print(_L("[Cm Server]\t storing rule %S to db"), |
|
607 &buf)); |
|
608 TInt ret = iDbManager.AddFillRuleL( |
|
609 tempContainer->FillRule( i )); |
|
610 TRACE(Print(_L("[Cm Server]\t ret = %d"), ret)); |
|
611 } |
|
612 } |
|
613 aMessage.Complete( KErrNone ); |
|
614 CleanupStack::PopAndDestroy( 3, buffer ); |
|
615 break; |
|
616 } |
|
617 |
|
618 case ECmPreProcessFillList: |
|
619 { |
|
620 LOG(_L("[Cm Server]\t ECmPreProcessFillList request")); |
|
621 |
|
622 TInt len = aMessage.GetDesLength( 0 ); |
|
623 if( len <= 0 ) |
|
624 { |
|
625 LOG(_L("[Cm Server]\t ECmPreProcessFillList request \ |
|
626 leaving with KErrArgument")); |
|
627 User::Leave( KErrArgument ); |
|
628 } |
|
629 HBufC8* name = HBufC8::NewLC( len ); |
|
630 TPtr8 ptr( name->Des() ); |
|
631 aMessage.ReadL(0, ptr); |
|
632 |
|
633 TRACE(Print(_L("[Cm Server]\t list name %S"), name )); |
|
634 |
|
635 Server().ExecuteServiceL( |
|
636 ECmServicePreProcessingFilllist, 0, name ); |
|
637 Server().SetCurrentAsyncMsg( aMessage ); |
|
638 |
|
639 CleanupStack::Pop( name ); |
|
640 break; |
|
641 } |
|
642 |
|
643 case ECmGetSyncTime: |
|
644 { |
|
645 LOG(_L("[Cm Server]\t ECmGetSyncTime request")); |
|
646 TTime syncTime; |
|
647 TInt err = iDbManager.GetSyncTime( syncTime ); |
|
648 TRACE( Print(_L("[Cm Server]\t returning time %ld"), |
|
649 syncTime.Int64() ) ); |
|
650 |
|
651 TPckg<TTime> pckg( syncTime ); |
|
652 aMessage.WriteL( 0, pckg ); |
|
653 aMessage.Complete( err ); |
|
654 break; |
|
655 } |
|
656 |
|
657 case ECmGetMediaserversSize: |
|
658 { |
|
659 LOG(_L("[Cm Server]\t ECmGetMediaserversSize request")); |
|
660 |
|
661 iDbManager.PrepareQueryCmdL( EMediaServersAllQuery ); |
|
662 |
|
663 delete iDataBuffer; |
|
664 iDataBuffer = NULL; |
|
665 |
|
666 iDataBuffer = CBufFlat::NewL( KBufferExpandSize ); |
|
667 RBufWriteStream serverStream; |
|
668 serverStream.Open( *iDataBuffer ); |
|
669 CleanupClosePushL( serverStream ); |
|
670 |
|
671 TInt ret( KErrNone ); |
|
672 TInt amount = 0; |
|
673 while( KErrNotFound != ret ) |
|
674 { |
|
675 CCmMediaServerFull* server = CCmMediaServerFull::NewLC(); |
|
676 ret = iDbManager.QueryAllMediaServersL( server ); |
|
677 if( KErrNotFound != ret ) |
|
678 { |
|
679 ++amount; |
|
680 server->ExternalizeL( serverStream ); |
|
681 } |
|
682 CleanupStack::PopAndDestroy( server ); |
|
683 } |
|
684 |
|
685 TInt size = iDataBuffer->Size(); |
|
686 TPckg<TInt> pckg( size ); |
|
687 aMessage.WriteL(0, pckg ); |
|
688 |
|
689 TPckg<TInt> pckg2( amount ); |
|
690 aMessage.WriteL(1, pckg2 ); |
|
691 |
|
692 TRACE(Print(_L("[Cm Server]\t buffer size is %d, amount %d"), |
|
693 size, amount)); |
|
694 |
|
695 aMessage.Complete( KErrNone ); |
|
696 CleanupStack::PopAndDestroy( &serverStream ); |
|
697 break; |
|
698 } |
|
699 |
|
700 case ECmGetStoreRulesSize: |
|
701 { |
|
702 LOG(_L("[Cm Server]\t ECmGetStoreRulesSize request")); |
|
703 RPointerArray<HBufC8> array; |
|
704 CleanupClosePushL( array ); |
|
705 iDbManager.PrepareQueryCmdL( EStoreRuleNamesQuery ); |
|
706 iDbManager.QueryStoreRuleNamesL( array ); |
|
707 TRACE(Print(_L("[Cm Server]\t store rule array size is %d"), |
|
708 array.Count())); |
|
709 |
|
710 CCmStoreRuleContainer* ruleContainer = |
|
711 CCmStoreRuleContainer::NewLC(); |
|
712 for ( TInt i = 0; i < array.Count(); i++ ) |
|
713 { |
|
714 CCmStoreRule* rule = CCmStoreRule::NewLC(); |
|
715 rule->SetNameL( *(array[i]) ); |
|
716 iDbManager.PrepareQueryCmdL( EStoreRuleQuery ); |
|
717 iDbManager.QueryStoreRuleL( rule ); |
|
718 ruleContainer->AddStoreRuleL( rule ); |
|
719 CleanupStack::Pop( rule ); |
|
720 } |
|
721 |
|
722 delete iDataBuffer; |
|
723 iDataBuffer = NULL; |
|
724 |
|
725 iDataBuffer = CBufFlat::NewL( KBufferExpandSize ); |
|
726 RBufWriteStream ruleStream; |
|
727 ruleStream.Open( *iDataBuffer ); |
|
728 CleanupClosePushL( ruleStream ); |
|
729 |
|
730 ruleContainer->ExternalizeL( ruleStream ); |
|
731 TInt size = iDataBuffer->Size(); |
|
732 TPckg<TInt> pckg( size ); |
|
733 aMessage.WriteL(0, pckg ); |
|
734 |
|
735 TRACE(Print(_L("[Cm Server]\t buffer size is %d"), size)); |
|
736 |
|
737 aMessage.Complete( KErrNone ); |
|
738 CleanupStack::PopAndDestroy( 2, ruleContainer ); |
|
739 array.Reset(); |
|
740 CleanupStack::PopAndDestroy( &array ); |
|
741 LOG(_L("[Cm Server]\t ECmGetStoreRulesSize request end")); |
|
742 |
|
743 break; |
|
744 } |
|
745 |
|
746 case ECmSetStoreRules: |
|
747 { |
|
748 LOG(_L("[Cm Server]\t ECmSetStoreRules request")); |
|
749 |
|
750 TInt len = aMessage.GetDesLength(0); |
|
751 TInt totalCount(0); |
|
752 if( len <= 0 ) |
|
753 { |
|
754 LOG(_L("[Cm Server]\t ECmSetStoreRules request \ |
|
755 leaving with KErrArgument")); |
|
756 User::Leave( KErrArgument ); |
|
757 } |
|
758 TRACE(Print(_L("[Cm Server]\t buffer length is %d"), len)); |
|
759 |
|
760 HBufC8* buffer = HBufC8::NewLC(len); |
|
761 |
|
762 TPtr8 ptr(buffer->Des()); |
|
763 aMessage.ReadL(0, ptr); |
|
764 RDesReadStream stream; |
|
765 stream.Open(ptr); |
|
766 CleanupClosePushL(stream); |
|
767 |
|
768 CCmStoreRuleContainer* tempContainer = |
|
769 CCmStoreRuleContainer::NewLC(); |
|
770 tempContainer->InternalizeL( stream ); |
|
771 iDbManager.DeleteAllStoreRules(); |
|
772 for ( TInt i = 0; i < tempContainer->StoreRuleCount(); i++ ) |
|
773 { |
|
774 TDesC8& name = tempContainer->StoreRule( i )->Name(); |
|
775 TBuf<KMaxFileName> buf; |
|
776 buf.Copy(name); |
|
777 TRACE(Print(_L("[Cm Server]\t updating store rule %S"), |
|
778 &buf)); |
|
779 TInt ret = iDbManager.AddStoreRuleL( |
|
780 tempContainer->StoreRule( i )); |
|
781 TRACE(Print(_L("[Cm Server]\t ret = %d"), ret)); |
|
782 |
|
783 if( tempContainer->StoreRule( i )->Selected() ) |
|
784 { |
|
785 TInt oneRuleCount(0); |
|
786 iDbManager.GetStoreFileCount( |
|
787 name, |
|
788 ECmToBeRemoved | ECmToBeShrinked | ECmKeepOnDevice, |
|
789 oneRuleCount ); |
|
790 totalCount += oneRuleCount; |
|
791 } |
|
792 } |
|
793 TInt time (0); |
|
794 TInt count(0); |
|
795 iDbManager.GetTransferInfo( ECmServiceStore, count, time ); |
|
796 iDbManager.UpdateTransferInfo( ECmServiceStore, totalCount, |
|
797 time ); |
|
798 |
|
799 aMessage.Complete( KErrNone ); |
|
800 |
|
801 CleanupStack::PopAndDestroy( 3, buffer ); |
|
802 break; |
|
803 } |
|
804 |
|
805 case ECmSetMediaServers: |
|
806 { |
|
807 LOG(_L("[Cm Server]\t ECmSetMediaServers request")); |
|
808 |
|
809 TInt mediaServerCount = aMessage.Int1(); |
|
810 TInt len = aMessage.GetDesLength(0); |
|
811 if( len <= 0 ) |
|
812 { |
|
813 LOG(_L("[Cm Server]\t ECmSetMediaServers request \ |
|
814 leaving with KErrArgument")); |
|
815 User::Leave( KErrArgument ); |
|
816 } |
|
817 TRACE(Print(_L("[Cm Server]\t buffer length is %d"), len)); |
|
818 TRACE(Print(_L("[Cm Server]\t mediaserver count is %d"), |
|
819 mediaServerCount )); |
|
820 |
|
821 HBufC8* buffer = HBufC8::NewLC(len); |
|
822 |
|
823 TPtr8 ptr(buffer->Des()); |
|
824 aMessage.ReadL(0, ptr); |
|
825 RDesReadStream stream; |
|
826 stream.Open(ptr); |
|
827 CleanupClosePushL(stream); |
|
828 |
|
829 RPointerArray<CCmMediaServerFull> mediaServers; |
|
830 CleanupClosePushL( mediaServers); |
|
831 |
|
832 for ( TInt i = 0; i < mediaServerCount; i++ ) |
|
833 { |
|
834 CCmMediaServerFull* mediaServer = |
|
835 CCmMediaServerFull::NewLC(); |
|
836 mediaServer->InternalizeL( stream ); |
|
837 mediaServers.AppendL( mediaServer ); |
|
838 CleanupStack::Pop( mediaServer ); |
|
839 } |
|
840 TInt ret = iDbManager.SetMediaServersL( mediaServers ); |
|
841 TRACE(Print(_L("[Cm Server]\t mediaservers update ret = %d"), |
|
842 ret)); |
|
843 |
|
844 aMessage.Complete( ret ); |
|
845 |
|
846 mediaServers.ResetAndDestroy(); |
|
847 CleanupStack::PopAndDestroy( 3 ); //buffer, &stream, &mediaServers |
|
848 break; |
|
849 } |
|
850 |
|
851 case ECmSetFillFileStatuses: |
|
852 { |
|
853 LOG(_L("[Cm Server]\t ECmSetFillFileStatuses request")); |
|
854 |
|
855 TInt itemCount = aMessage.Int1(); |
|
856 TInt len = aMessage.GetDesLength(0); |
|
857 if( len <= 0 ) |
|
858 { |
|
859 LOG(_L("[Cm Server]\t ECmSetFillFileStatuses request \ |
|
860 leaving with KErrArgument")); |
|
861 User::Leave( KErrArgument ); |
|
862 } |
|
863 TRACE(Print(_L("[Cm Server]\t buffer length is %d"), len)); |
|
864 TRACE(Print(_L("[Cm Server]\t item count is %d"), |
|
865 itemCount )); |
|
866 |
|
867 HBufC8* buffer = HBufC8::NewLC(len); |
|
868 |
|
869 TPtr8 ptr(buffer->Des()); |
|
870 aMessage.ReadL(0, ptr); |
|
871 RDesReadStream stream; |
|
872 stream.Open(ptr); |
|
873 CleanupClosePushL(stream); |
|
874 |
|
875 RPointerArray<CCmBaseListItem> items; |
|
876 CleanupClosePushL( items ); |
|
877 |
|
878 for ( TInt i = 0; i < itemCount; i++ ) |
|
879 { |
|
880 CCmBaseListItem* item = CCmBaseListItem::NewLC(); |
|
881 item->InternalizeL( stream ); |
|
882 items.AppendL( item ); |
|
883 CleanupStack::Pop( item ); |
|
884 } |
|
885 TInt ret = iDbManager.UpdateStatusValues( items ); |
|
886 TRACE(Print(_L("[Cm Server]\t fillfile status update ret = %d"), |
|
887 ret)); |
|
888 |
|
889 aMessage.Complete( ret ); |
|
890 |
|
891 items.ResetAndDestroy(); |
|
892 CleanupStack::PopAndDestroy( 3 ); //buffer, &stream, &items |
|
893 break; |
|
894 } |
|
895 |
|
896 case ECmGetAppWizardState: |
|
897 { |
|
898 LOG(_L("[Cm Server]\t ECmGetAppWizardState request")); |
|
899 |
|
900 TInt appWizardState( KErrNotFound ); |
|
901 TInt err; |
|
902 err = iSettings.GetAppWizardInformation( appWizardState ); |
|
903 TPckg<TInt> pckg( appWizardState ); |
|
904 aMessage.WriteL(0, pckg ); |
|
905 aMessage.Complete( err ); |
|
906 break; |
|
907 } |
|
908 |
|
909 case ECmSetAppWizardState: |
|
910 { |
|
911 LOG(_L("[Cm Server]\t ECmSetAppWizardState request")); |
|
912 TInt err; |
|
913 err = iSettings.SetAppWizardInformation(); |
|
914 aMessage.Complete( err ); |
|
915 |
|
916 break; |
|
917 } |
|
918 case ECmUpdateFillLists: |
|
919 { |
|
920 LOG(_L("[Cm Server]\t ECmUpdateLists request")); |
|
921 Server().ExecuteServiceL( |
|
922 ECmServiceUpdateFillLists, 0, NULL ); |
|
923 Server().SetCurrentAsyncMsg( aMessage ); |
|
924 break; |
|
925 } |
|
926 case ECmDeleteMetadata: |
|
927 { |
|
928 LOG(_L("[Cm Server]\t ECmDeleteMetadata request")); |
|
929 |
|
930 Server().ExecuteServiceL( |
|
931 ECmServiceDeleteMetadata, 0, NULL ); |
|
932 Server().SetCurrentAsyncMsg( aMessage ); |
|
933 break; |
|
934 } |
|
935 case ECmDeleteDeletedMediaServers: |
|
936 { |
|
937 TRAPD( err, iDbManager.DeleteDeletedMediaServersL() ); |
|
938 aMessage.Complete( err ); |
|
939 break; |
|
940 } |
|
941 case ECmGetDriveSelectionStatus: |
|
942 { |
|
943 TInt err( KErrNone ); |
|
944 TPckg<TBool> pckg( Server().DriveSelectionStatus() ); |
|
945 aMessage.WriteL( 0, pckg ); |
|
946 aMessage.Complete( err ); |
|
947 break; |
|
948 } |
|
949 case ECmSetDrives: |
|
950 { |
|
951 LOG(_L("[Cm Server]\t ECmSetDrives request")); |
|
952 |
|
953 TInt driveCount = aMessage.Int1(); |
|
954 TInt len = aMessage.GetDesLength(0); |
|
955 if( len < 0 ) |
|
956 { |
|
957 LOG(_L("[Cm Server]\t ECmSetDrives request \ |
|
958 leaving with KErrArgument")); |
|
959 User::Leave( KErrArgument ); |
|
960 } |
|
961 TRACE(Print(_L("[Cm Server]\t buffer length is %d"), len)); |
|
962 TRACE(Print(_L("[Cm Server]\t drive count is %d"), |
|
963 driveCount )); |
|
964 |
|
965 RPointerArray<CCmDriveInfo> origDrives; |
|
966 CleanupClosePushL( origDrives ); |
|
967 |
|
968 iDbManager.PrepareQueryCmdL( EDrivesQuery ); |
|
969 TRAPD( ret, iDbManager.QueryDrivesL( origDrives ) ); |
|
970 TRACE(Print(_L("[Cm Server]\t Query orig drives ret = %d"), |
|
971 ret )); |
|
972 |
|
973 HBufC8* buffer = HBufC8::NewLC(len); |
|
974 |
|
975 TPtr8 ptr(buffer->Des()); |
|
976 aMessage.ReadL(0, ptr); |
|
977 RDesReadStream stream; |
|
978 stream.Open(ptr); |
|
979 CleanupClosePushL(stream); |
|
980 |
|
981 RPointerArray<CCmDriveInfo> drives; |
|
982 CleanupClosePushL( drives ); |
|
983 |
|
984 for ( TInt i = 0; i < driveCount; i++ ) |
|
985 { |
|
986 CCmDriveInfo* drive = |
|
987 CCmDriveInfo::NewLC(); |
|
988 drive->InternalizeL( stream ); |
|
989 drives.AppendL( drive ); |
|
990 } |
|
991 // Has drive slots changed or has some mmc taken away |
|
992 TBool driveSelected( EFalse ); |
|
993 for( TInt j = 0; j < origDrives.Count(); j++ ) |
|
994 { |
|
995 for( TInt k = 0; k < drives.Count(); k++ ) |
|
996 { |
|
997 if( origDrives[j]->DriveId() == drives[k]->DriveId() ) |
|
998 { |
|
999 driveSelected = ETrue; |
|
1000 if( origDrives[j]->DriveNumber() != |
|
1001 drives[k]->DriveNumber() ) |
|
1002 { |
|
1003 // update fill list drive numbers and ids |
|
1004 iDbManager.UpdateFillListDriveStatusesL( |
|
1005 origDrives[j], drives[k], driveSelected ); |
|
1006 } |
|
1007 else |
|
1008 { |
|
1009 // Do nothing, drive still in same slot as |
|
1010 // previously |
|
1011 } |
|
1012 } |
|
1013 } |
|
1014 if( !driveSelected ) |
|
1015 { |
|
1016 // Drive not selected, update fill file list statuses |
|
1017 // Use drive id in update clause |
|
1018 iDbManager.UpdateFillListDriveStatusesL( |
|
1019 origDrives[j], NULL, driveSelected ); |
|
1020 } |
|
1021 driveSelected = EFalse; |
|
1022 } |
|
1023 |
|
1024 TRAP( ret, iDbManager.SetDrivesL( drives ) ); |
|
1025 TRACE(Print(_L("[Cm Server]\t drives update ret = %d"), |
|
1026 ret)); |
|
1027 if( drives.Count() ) |
|
1028 { |
|
1029 Server().SetDriveSelectionStatus( ETrue ); |
|
1030 } |
|
1031 else |
|
1032 { |
|
1033 Server().SetDriveSelectionStatus( EFalse ); |
|
1034 } |
|
1035 aMessage.Complete( ret ); |
|
1036 |
|
1037 CleanupStack::PopAndDestroy( driveCount ); |
|
1038 drives.Reset(); |
|
1039 CleanupStack::PopAndDestroy( &drives ); |
|
1040 CleanupStack::PopAndDestroy( 2, buffer ); |
|
1041 origDrives.ResetAndDestroy(); |
|
1042 CleanupStack::PopAndDestroy( &origDrives ); |
|
1043 // Restart quota listener if needed |
|
1044 TBool mmEnabled( EFalse ); |
|
1045 iSettings.GetMemoryManagerStatus( mmEnabled ); |
|
1046 Server().SetServiceStateL( ECmServiceMemoryManager, |
|
1047 (TCmServiceState)mmEnabled ); |
|
1048 break; |
|
1049 } |
|
1050 case ECmGetDrivesSize: |
|
1051 { |
|
1052 LOG(_L("[Cm Server]\t ECmGetDrivesSize request")); |
|
1053 |
|
1054 iDbManager.PrepareQueryCmdL( EDrivesQuery ); |
|
1055 |
|
1056 delete iDataBuffer; |
|
1057 iDataBuffer = NULL; |
|
1058 |
|
1059 iDataBuffer = CBufFlat::NewL( KBufferExpandSize ); |
|
1060 RBufWriteStream driveStream; |
|
1061 driveStream.Open( *iDataBuffer ); |
|
1062 CleanupClosePushL( driveStream ); |
|
1063 |
|
1064 RPointerArray<CCmDriveInfo> drives; |
|
1065 CleanupClosePushL( drives ); |
|
1066 iDbManager.QueryDrivesL( drives ); |
|
1067 for( TInt i = 0; i < drives.Count(); i++ ) |
|
1068 { |
|
1069 drives[i]->ExternalizeL( driveStream ); |
|
1070 } |
|
1071 |
|
1072 TInt size = iDataBuffer->Size(); |
|
1073 TPckg<TInt> pckg( size ); |
|
1074 aMessage.WriteL(0, pckg ); |
|
1075 |
|
1076 TPckg<TInt> pckg2( drives.Count() ); |
|
1077 aMessage.WriteL(1, pckg2 ); |
|
1078 |
|
1079 TRACE(Print(_L("[Cm Server]\t buffer size is %d, amount %d"), |
|
1080 size, drives.Count() )); |
|
1081 |
|
1082 aMessage.Complete( KErrNone ); |
|
1083 drives.ResetAndDestroy(); |
|
1084 CleanupStack::PopAndDestroy( &drives ); |
|
1085 CleanupStack::PopAndDestroy( &driveStream ); |
|
1086 break; |
|
1087 } |
|
1088 case ECmApplicationExit: |
|
1089 { |
|
1090 LOG(_L("[Cm Server]\t ECmApplicationExit request")); |
|
1091 Server().SetAsyncRequestStateL( EFalse ); |
|
1092 if ( !aMessage.IsNull() ) |
|
1093 { |
|
1094 aMessage.Complete( KErrNone ); |
|
1095 } |
|
1096 break; |
|
1097 } |
|
1098 case ECmGetFilledFilesSize: |
|
1099 { |
|
1100 LOG(_L("[Cm Server]\t ECmGetFilledFilesSize request")); |
|
1101 TInt id = aMessage.Int1(); |
|
1102 TInt64 size = iDbManager.BytesFilled( id ); |
|
1103 TPckg<TInt64> pckg( size ); |
|
1104 |
|
1105 aMessage.WriteL(0, pckg ); |
|
1106 aMessage.Complete( KErrNone ); |
|
1107 |
|
1108 break; |
|
1109 } |
|
1110 default: |
|
1111 { |
|
1112 LOG(_L("[Cm Server]\t default panic with ECmClientBadRequest")); |
|
1113 // Unknown opcode --> panic client |
|
1114 PanicClient( aMessage, ECmClientBadRequest ); |
|
1115 break; |
|
1116 } |
|
1117 } |
|
1118 |
|
1119 // If ServiceL leaves, default implementation in server framework |
|
1120 // completes the RMessage2 with the leave code. |
|
1121 } |
|
1122 |
|
1123 // --------------------------------------------------------------------------- |
|
1124 // PanicClient |
|
1125 // Client panic handler |
|
1126 // RMessage2::Panic() also completes the message. This is: |
|
1127 // (a) important for efficient cleanup within the kernel |
|
1128 // (b) a problem if the message is completed a second time |
|
1129 // (other items were commented in a header). |
|
1130 // --------------------------------------------------------------------------- |
|
1131 // |
|
1132 void CCmSession::PanicClient( const RMessage2& aMessage, TInt aPanic ) const |
|
1133 { |
|
1134 TRACE(Print(_L("[Cm Server]\t PanicClient: Reason = %d\n"), aPanic)); |
|
1135 aMessage.Panic( KCmServerPanic, aPanic ); |
|
1136 } |
|
1137 |
|
1138 // End of File |
|