1 /* |
|
2 * Copyright (c) 2005-2010 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: PC Connectivity server |
|
15 * |
|
16 */ |
|
17 |
|
18 |
|
19 #include <s32mem.h> // For RMemReadStream |
|
20 #include <utf.h> |
|
21 #include <Etel3rdParty.h> |
|
22 #include <f32file.h> |
|
23 |
|
24 #include "sconpcconnclientserver.h" |
|
25 #include "sconpcconnserver.h" |
|
26 #include "sconpcd.h" |
|
27 #include "sconcsc.h" |
|
28 #include "sconconmlhandler.h" |
|
29 #include "sconimsireader.h" |
|
30 #include "sconoviaccounthandler.h" |
|
31 #include "sconfolderlister.h" |
|
32 #include "sconbtengine.h" |
|
33 #include "debug.h" |
|
34 |
|
35 #ifdef DEBUG_XML |
|
36 #include <s32file.h> |
|
37 _LIT8( KTimeFormat, "%02d:%02d:%02d.%03d" ); |
|
38 _LIT8( KXmlBegin, "\nXML:\n" ); |
|
39 #endif |
|
40 |
|
41 _LIT( KSCONGetMetadataRequest, "METADATA:" ); |
|
42 _LIT8( KSCONSyncRequest, "SYNC:" ); |
|
43 _LIT( KSCONReadImsi, "READIMSI"); |
|
44 _LIT( KSCONReadNetworkInfo, "READNETWORKINFO"); |
|
45 _LIT( KSCONReadOviAccount, "READOVIACCOUNT"); |
|
46 _LIT( KSCONListPath, "LISTP:"); |
|
47 _LIT( KSCONReadBtInfo, "READBTINFO" ); |
|
48 _LIT( KSCONSetBtPower, "SETBTPOWER:" ); |
|
49 _LIT( KSCONSetBtName, "SETBTNAME:" ); |
|
50 _LIT( KSCONSetBtAuthorized, "SETBTAUTHORIZED:" ); |
|
51 |
|
52 //------------------------------------------------------------ |
|
53 // Global functions |
|
54 //------------------------------------------------------------ |
|
55 |
|
56 // ----------------------------------------------------------------------------- |
|
57 // E32Main() |
|
58 // Entry point |
|
59 // ----------------------------------------------------------------------------- |
|
60 // |
|
61 TInt E32Main() |
|
62 { |
|
63 TRACE_FUNC_ENTRY; |
|
64 __UHEAP_MARK; |
|
65 TInt error( KErrNone ); |
|
66 error = CSConPCConnServer::RunServer(); |
|
67 __UHEAP_MARKEND; |
|
68 TRACE_FUNC_EXIT; |
|
69 return error; |
|
70 } |
|
71 |
|
72 // ----------------------------------------------------------------------------- |
|
73 // PanicServer() |
|
74 // Panics the server with panic reason aPanic |
|
75 // ----------------------------------------------------------------------------- |
|
76 // |
|
77 GLDEF_C void PanicServer(TPCConnServPanic aPanic) |
|
78 { |
|
79 LOGGER_WRITE_1( "CSConPCConnSession::PanicServer() : Panic code %d", aPanic ); |
|
80 _LIT(KTxtServerPanic,"PCConn server panic"); |
|
81 User::Panic(KTxtServerPanic,aPanic); |
|
82 } |
|
83 |
|
84 // ----------------------------------------------------------------------------- |
|
85 // CSConPCConnServer::CSConPCConnServer () |
|
86 // Default constructor - can not leave |
|
87 // ----------------------------------------------------------------------------- |
|
88 // |
|
89 CSConPCConnServer::CSConPCConnServer () : CServer2( EPriorityStandard) |
|
90 { |
|
91 LOGGER_WRITE( "* * * * CSConPCConnServer * * * *" ); |
|
92 } |
|
93 |
|
94 // ----------------------------------------------------------------------------- |
|
95 // CSConPCConnServer::~CSConPCConnServer() |
|
96 // Default destructor |
|
97 // ----------------------------------------------------------------------------- |
|
98 // |
|
99 EXPORT_C CSConPCConnServer::~CSConPCConnServer() |
|
100 { |
|
101 TRACE_FUNC; |
|
102 } |
|
103 |
|
104 // ----------------------------------------------------------------------------- |
|
105 // CSConPCConnServer::NewLC() |
|
106 // Creates a new instance of CSConPCConnServer |
|
107 // ----------------------------------------------------------------------------- |
|
108 // |
|
109 EXPORT_C CSConPCConnServer* CSConPCConnServer::NewLC() |
|
110 { |
|
111 TRACE_FUNC_ENTRY; |
|
112 CSConPCConnServer* self = new (ELeave) CSConPCConnServer(); |
|
113 CleanupStack::PushL( self ); |
|
114 self->StartL( KSConPCConnServerName ); |
|
115 TRACE_FUNC_EXIT; |
|
116 return self; |
|
117 } |
|
118 |
|
119 // ----------------------------------------------------------------------------- |
|
120 // CSConPCConnServer::NewSessionL() |
|
121 // Creates a new session to the client |
|
122 // ----------------------------------------------------------------------------- |
|
123 // |
|
124 CSession2* CSConPCConnServer::NewSessionL( |
|
125 const TVersion &aVersion, const RMessage2& /*aMessage*/ ) const |
|
126 { |
|
127 TRACE_FUNC_ENTRY; |
|
128 |
|
129 // check version |
|
130 TVersion version( KSConPCConnServerVersionMajor, |
|
131 KSConPCConnServerVersionMinor, |
|
132 KSConPCConnServerVersionBuild); |
|
133 |
|
134 if (!User::QueryVersionSupported(version, aVersion)) |
|
135 { |
|
136 User::Leave(KErrNotSupported); |
|
137 } |
|
138 |
|
139 // check client identity |
|
140 RThread client; |
|
141 Message().Client( client ); |
|
142 TSecureId clientId = client.SecureId(); |
|
143 |
|
144 if ( clientId != KSConPCConnClientSecureId ) |
|
145 { |
|
146 LOGGER_WRITE( "CSConPCConnServer::NewSessionL() : Secure ID does not match" ); |
|
147 User::Leave( KErrAccessDenied ); |
|
148 } |
|
149 |
|
150 TRACE_FUNC_EXIT; |
|
151 return CSConPCConnSession::NewL( *CONST_CAST( CSConPCConnServer*, this)); |
|
152 } |
|
153 |
|
154 // ----------------------------------------------------------------------------- |
|
155 // CSConPCConnServer::RunServer() |
|
156 // Starts the server |
|
157 // ----------------------------------------------------------------------------- |
|
158 // |
|
159 TInt CSConPCConnServer::RunServer() |
|
160 { |
|
161 TRACE_FUNC_ENTRY; |
|
162 |
|
163 CTrapCleanup* cleanup = CTrapCleanup::New(); |
|
164 TInt ret = KErrNoMemory; |
|
165 if( cleanup ) |
|
166 { |
|
167 TRAP( ret, CSConPCConnServer::RunServerL( ) ); |
|
168 delete cleanup; |
|
169 } |
|
170 if( ret != KErrNone ) |
|
171 { |
|
172 // Signal the client that server creation failed |
|
173 RProcess::Rendezvous( ret ); |
|
174 } |
|
175 TRACE_FUNC_EXIT; |
|
176 return ret; |
|
177 } |
|
178 |
|
179 // ----------------------------------------------------------------------------- |
|
180 // CSConPCConnServer::RunServerL() |
|
181 // Starts the server |
|
182 // ----------------------------------------------------------------------------- |
|
183 // |
|
184 void CSConPCConnServer::RunServerL() |
|
185 { |
|
186 // Create and install the active scheduler we need |
|
187 TRACE_FUNC_ENTRY; |
|
188 CActiveScheduler *as=new (ELeave)CActiveScheduler; |
|
189 CleanupStack::PushL( as ); |
|
190 CActiveScheduler::Install( as ); |
|
191 |
|
192 // Create server |
|
193 CSConPCConnServer* server = CSConPCConnServer::NewLC(); |
|
194 |
|
195 // Initialisation complete, now signal the client |
|
196 User::LeaveIfError( RThread().RenameMe( KSConPCConnServerName ) ); |
|
197 RProcess::Rendezvous( KErrNone ); |
|
198 |
|
199 // Ready to run |
|
200 CActiveScheduler::Start(); |
|
201 |
|
202 // Cleanup the scheduler |
|
203 CleanupStack::PopAndDestroy( 2, as ); |
|
204 TRACE_FUNC_EXIT; |
|
205 } |
|
206 |
|
207 // ----------------------------------------------------------------------------- |
|
208 // CSConPCConnServer::IncSessionCount() |
|
209 // Increments session count |
|
210 // ----------------------------------------------------------------------------- |
|
211 // |
|
212 void CSConPCConnServer::IncSessionCount() |
|
213 { |
|
214 TRACE_FUNC_ENTRY; |
|
215 iSessionCount++; |
|
216 LOGGER_WRITE_1( "There are now %d sessions", iSessionCount ); |
|
217 TRACE_FUNC_EXIT; |
|
218 } |
|
219 |
|
220 // ----------------------------------------------------------------------------- |
|
221 // CSConPCConnServer::DecSessionCount() |
|
222 // Decrements session count |
|
223 // ----------------------------------------------------------------------------- |
|
224 // |
|
225 void CSConPCConnServer::DecSessionCount() |
|
226 { |
|
227 TRACE_FUNC_ENTRY; |
|
228 iSessionCount--; |
|
229 LOGGER_WRITE_1( "There are still %d sessions", iSessionCount ); |
|
230 if ( iSessionCount < 1 ) |
|
231 { |
|
232 Cancel(); |
|
233 CActiveScheduler::Stop(); |
|
234 } |
|
235 TRACE_FUNC_EXIT; |
|
236 } |
|
237 |
|
238 // ----------------------------------------------------------------------------- |
|
239 // CSConPCConnSession::CSConPCConnSession() |
|
240 // Default constructor |
|
241 // ----------------------------------------------------------------------------- |
|
242 // |
|
243 CSConPCConnSession::CSConPCConnSession ( |
|
244 CSConPCConnServer& aServer ) : iServer (aServer) |
|
245 { |
|
246 TRACE_FUNC_ENTRY; |
|
247 iServer.IncSessionCount(); |
|
248 TRACE_FUNC_EXIT; |
|
249 } |
|
250 |
|
251 // ----------------------------------------------------------------------------- |
|
252 // CSConPCConnSession::CSConPCConnSession() |
|
253 // Default destructor - frees resources |
|
254 // ----------------------------------------------------------------------------- |
|
255 // |
|
256 CSConPCConnSession::~CSConPCConnSession() |
|
257 { |
|
258 TRACE_FUNC_ENTRY; |
|
259 |
|
260 iServer.DecSessionCount(); |
|
261 |
|
262 if ( iConMLHandler ) |
|
263 { |
|
264 delete iConMLHandler; |
|
265 iConMLHandler = NULL; |
|
266 iConMLHandlerLib.Close(); |
|
267 } |
|
268 |
|
269 if ( iPCDHandler ) |
|
270 { |
|
271 delete iPCDHandler; |
|
272 iPCDHandler = NULL; |
|
273 iPCDlib.Close(); |
|
274 } |
|
275 |
|
276 if ( iCSCHandler ) |
|
277 { |
|
278 delete iCSCHandler; |
|
279 iCSCHandler = NULL; |
|
280 iCSClib.Close(); |
|
281 } |
|
282 |
|
283 if ( iBuffer ) |
|
284 { |
|
285 delete iBuffer; |
|
286 iBuffer = NULL; |
|
287 } |
|
288 |
|
289 iChunk.Close(); |
|
290 delete iFolderLister; |
|
291 |
|
292 iFs.Close(); |
|
293 |
|
294 delete iBtEngine; |
|
295 |
|
296 TRACE_FUNC_EXIT; |
|
297 } |
|
298 |
|
299 // ----------------------------------------------------------------------------- |
|
300 // CSConPCConnSession::NewL() |
|
301 // Creates a new instance of CSConPCConnSession |
|
302 // ----------------------------------------------------------------------------- |
|
303 // |
|
304 EXPORT_C CSConPCConnSession *CSConPCConnSession::NewL( |
|
305 CSConPCConnServer& aServer) |
|
306 { |
|
307 TRACE_FUNC_ENTRY; |
|
308 CSConPCConnSession* self = new ( ELeave ) CSConPCConnSession(aServer); |
|
309 CleanupStack::PushL( self ); |
|
310 self->ConstructL(); |
|
311 CleanupStack::Pop( self ); |
|
312 TRACE_FUNC_EXIT; |
|
313 return self; |
|
314 } |
|
315 |
|
316 // ----------------------------------------------------------------------------- |
|
317 // CSConPCConnSession::ConstructL() |
|
318 // 2nd phase constructor |
|
319 // ----------------------------------------------------------------------------- |
|
320 // |
|
321 void CSConPCConnSession::ConstructL() |
|
322 { |
|
323 TRACE_FUNC_ENTRY; |
|
324 TInt ret ( KErrNone ); |
|
325 iResult = KErrNone; |
|
326 |
|
327 User::LeaveIfError( iFs.Connect() ); |
|
328 |
|
329 #ifdef DEBUG_XML |
|
330 // create log file |
|
331 |
|
332 RFile file; |
|
333 TInt err = file.Create ( iFs, KSConConMLDebugFile, EFileWrite ); |
|
334 if( err == KErrNone ) |
|
335 { |
|
336 // file created, close it |
|
337 file.Close(); |
|
338 } |
|
339 #endif |
|
340 |
|
341 // initialize buffer |
|
342 iBuffer = CBufFlat::NewL ( KSConPCConnBufferMaxSize ); |
|
343 |
|
344 // load handlers |
|
345 if ( !iPCDHandler ) |
|
346 { |
|
347 TRAP( ret, LoadPCDDllL() ); |
|
348 if ( ret != KErrNone) |
|
349 { |
|
350 LOGGER_WRITE_1( "CSConPCConnSession::ConstructL() : PCD load failed with error code %d", ret ); |
|
351 User::Leave( ret ); |
|
352 } |
|
353 } |
|
354 |
|
355 if ( !iCSCHandler ) |
|
356 { |
|
357 TRAP( ret, LoadCSCDllL() ); |
|
358 if ( ret != KErrNone) |
|
359 { |
|
360 LOGGER_WRITE_1( "CSConPCConnSession::ConstructL() : CSC dll load failed with error code %d", ret ); |
|
361 User::Leave ( ret ); |
|
362 } |
|
363 } |
|
364 |
|
365 // Load parser |
|
366 if ( !iConMLHandler ) |
|
367 { |
|
368 TRAPD( ret, LoadConMLHandlerDllL() ); |
|
369 if ( ret != KErrNone) |
|
370 { |
|
371 LOGGER_WRITE_1( "CSConPCConnSession::ConstructL() : Parser dll load failed with error code %d", ret ); |
|
372 User::Leave ( ret ); |
|
373 } |
|
374 } |
|
375 |
|
376 iFolderLister = CSconFolderLister::NewL( iFs ); |
|
377 |
|
378 TRACE_FUNC_EXIT; |
|
379 } |
|
380 |
|
381 // ----------------------------------------------------------------------------- |
|
382 // CSConPCConnSession::ServiceL() |
|
383 // Gets the client's request |
|
384 // ----------------------------------------------------------------------------- |
|
385 // |
|
386 void CSConPCConnSession::ServiceL( const RMessage2 &aMessage) |
|
387 { |
|
388 TRACE_FUNC_ENTRY; |
|
389 TRAPD(err,DispatchRequestL(aMessage) ); |
|
390 if ( err != KErrNone ) |
|
391 { |
|
392 LOGGER_WRITE_1( "CSConPCConnSession::ServiceL() : leave code %d", err ); |
|
393 PanicServer( E_DispatchRequest ); |
|
394 } |
|
395 TRACE_FUNC_EXIT; |
|
396 } |
|
397 |
|
398 // ----------------------------------------------------------------------------- |
|
399 // CSConPCConnSession::DispatchRequestL() |
|
400 // Identifies an IPC command from the client |
|
401 // ----------------------------------------------------------------------------- |
|
402 // |
|
403 void CSConPCConnSession::DispatchRequestL(const RMessage2 &aMessage) |
|
404 { |
|
405 TRACE_FUNC_ENTRY; |
|
406 |
|
407 TInt ret (KErrNone); |
|
408 |
|
409 switch (aMessage.Function()) |
|
410 { |
|
411 case EPutMessage: |
|
412 LOGGER_WRITE( "CSConPCConnSession::DispatchRequestL() : EPutMessage" ); |
|
413 ret = HandlePutMessageL(); |
|
414 break; |
|
415 |
|
416 case EGetMessage: |
|
417 LOGGER_WRITE( "CSConPCConnSession::DispatchRequestL() : EGetMessage" ); |
|
418 ret = HandleGetMessageL(); |
|
419 break; |
|
420 |
|
421 case EResetMessage: |
|
422 LOGGER_WRITE( "CSConPCConnSession::DispatchRequestL() : EResetMessage" ); |
|
423 ret = HandleResetMessage(); |
|
424 break; |
|
425 |
|
426 case EChunkMessage: |
|
427 LOGGER_WRITE( "CSConPCConnSession::DispatchRequestL() : EChunkMessage" ); |
|
428 ret = HandleChunkMessage( aMessage ); |
|
429 break; |
|
430 |
|
431 default: |
|
432 PanicServer (E_BadRequest); |
|
433 break; |
|
434 } |
|
435 |
|
436 aMessage.Complete( ret ); |
|
437 TRACE_FUNC_EXIT; |
|
438 } |
|
439 |
|
440 // ----------------------------------------------------------------------------- |
|
441 // CSConPCConnSession::HandlePutMessageL() |
|
442 // Handles a PUT -type message from the client |
|
443 // ----------------------------------------------------------------------------- |
|
444 // |
|
445 TInt CSConPCConnSession::HandlePutMessageL() |
|
446 { |
|
447 TRACE_FUNC_ENTRY; |
|
448 LOGGER_WRITE_1( "CSConPCConnSession::HandlePutMessageL() : begin : Heap count : %d", User::Heap().Count() ); |
|
449 TInt ret ( KErrNone ); |
|
450 |
|
451 if ( !iPCDHandler ) |
|
452 { |
|
453 TRAP( ret, LoadPCDDllL() ); |
|
454 if ( ret != KErrNone) |
|
455 { |
|
456 LOGGER_WRITE_1( "CSConPCConnSession::HandlePutMessageL (): PCD dll load failed with error code %d", ret ); |
|
457 return ( ret ); |
|
458 } |
|
459 } |
|
460 |
|
461 if ( ! iConMLHandler ) |
|
462 { |
|
463 TRAP ( ret, LoadConMLHandlerDllL() ); |
|
464 if ( ret != KErrNone ) |
|
465 { |
|
466 LOGGER_WRITE_1( "CSConPCConnSession::HandlePutMessageL (): ConML Handler dll load failed with error code %d", ret ); |
|
467 return ( ret ); |
|
468 } |
|
469 } |
|
470 |
|
471 TInt length ( 0 ); |
|
472 |
|
473 RMemReadStream buf( iChunk.Base(), iChunk.Size() ); |
|
474 |
|
475 |
|
476 iBuffer->Reset(); |
|
477 |
|
478 length = buf.ReadInt32L(); |
|
479 HBufC8* name8 = HBufC8::NewLC( length ); |
|
480 TPtr8 namePtr8 = name8->Des(); |
|
481 buf.ReadL( namePtr8, length); |
|
482 |
|
483 const TUint8* ptr8 = namePtr8.Ptr(); |
|
484 const TUint16* ptr16 = reinterpret_cast<const TUint16*>( ptr8 ); |
|
485 TPtrC namePtr; |
|
486 namePtr.Set( ptr16, length/2 ); |
|
487 |
|
488 length = buf.ReadInt32L(); |
|
489 HBufC8* type = HBufC8::NewLC( length ); |
|
490 TPtr8 typePtr = type->Des(); |
|
491 buf.ReadL( typePtr, length); |
|
492 |
|
493 // WBXML Document |
|
494 length = buf.ReadInt32L(); |
|
495 HBufC8* data = HBufC8::NewLC( length ); |
|
496 TPtr8 dataPtr = data->Des(); |
|
497 |
|
498 buf.ReadL( dataPtr, length ); |
|
499 iBuffer->ResizeL( length ); |
|
500 iBuffer->Write( 0, dataPtr ); |
|
501 |
|
502 buf.Close(); |
|
503 |
|
504 #ifdef DEBUG_XML |
|
505 |
|
506 RFile file; |
|
507 if ( file.Open( iFs, KSConConMLDebugFile, EFileWrite ) == KErrNone ) |
|
508 { |
|
509 RFileWriteStream fws; |
|
510 TInt fileSize; |
|
511 file.Size( fileSize ); |
|
512 |
|
513 TTime now; |
|
514 now.HomeTime(); |
|
515 TDateTime time = now.DateTime(); |
|
516 TBuf8<16> timeLine; |
|
517 timeLine.Format (KTimeFormat, time.Hour(), time.Minute(), |
|
518 time.Second(), time.MicroSecond() ); |
|
519 |
|
520 fws.Attach( file, fileSize ); |
|
521 fws.PushL(); |
|
522 fws.WriteL( timeLine ); |
|
523 _LIT8( KPutMessage, "__________PUT-MESSAGE \nWBXML:\n" ); |
|
524 fws.WriteL( KPutMessage ); |
|
525 fws.WriteL( iBuffer->Ptr(0), iBuffer->Size() ); |
|
526 TRAP_IGNORE( fws.CommitL() ); |
|
527 fws.Close(); |
|
528 |
|
529 CleanupStack::PopAndDestroy( &fws ); |
|
530 } |
|
531 file.Close(); |
|
532 #endif |
|
533 if ( ( ( typePtr.CompareC( KSConPCDWBXMLObjectType)== KErrNone ) || |
|
534 ( typePtr.CompareC( KSConPCDWBXMLObjectType2 )== KErrNone ) ) |
|
535 && namePtr8.Find(KSCONSyncRequest) == 0 ) |
|
536 { |
|
537 LOGGER_WRITE_1("Sync request: %S", &namePtr); |
|
538 RBufReadStream stream( *iBuffer ); |
|
539 |
|
540 CleanupClosePushL( stream ); |
|
541 TRAP( ret, iPCDHandler->HandlePutSyncRequestL( namePtr8, stream )); |
|
542 if ( ret ) |
|
543 { |
|
544 LOGGER_WRITE_1("HandlePutSyncRequestL() Leaved with %d", ret); |
|
545 } |
|
546 |
|
547 CleanupStack::PopAndDestroy( &stream ); |
|
548 } |
|
549 else if ( ( typePtr.Compare( KSConPCDWBXMLObjectType ) == KErrNone) || |
|
550 ( typePtr.Compare( KSConPCDWBXMLObjectType2 )== KErrNone) ) |
|
551 { |
|
552 LOGGER_WRITE( "CSConPCConnSession::HandlePutMessageL() : Object type PCD " ); |
|
553 TRAPD( err, ret = iConMLHandler->ParseDocumentL( *iBuffer, this ) ); |
|
554 if ( err != KErrNone ) |
|
555 { |
|
556 ret = err; |
|
557 } |
|
558 if ( ret == KErrNone ) |
|
559 { |
|
560 // Possible error code returned from PCCS |
|
561 ret = iResult; |
|
562 } |
|
563 } |
|
564 else |
|
565 { |
|
566 LOGGER_WRITE( "Object type not regognized " ); |
|
567 ret = KErrNotSupported; |
|
568 } |
|
569 CleanupStack::PopAndDestroy( data ); |
|
570 CleanupStack::PopAndDestroy( type ); |
|
571 CleanupStack::PopAndDestroy( name8 ); |
|
572 LOGGER_WRITE_1( "CSConPCConnSession::HandlePutMessageL() end : Heap count : %d", User::Heap().Count() ); |
|
573 LOGGER_WRITE_1( "CSConPCConnSession::HandlePutMessageL() : returned %d", ret ); |
|
574 return ret; |
|
575 } |
|
576 |
|
577 // ----------------------------------------------------------------------------- |
|
578 // CSConPCConnSession::HandleGetMessageL() |
|
579 // Handles a GET -type message from the client |
|
580 // ----------------------------------------------------------------------------- |
|
581 // |
|
582 TInt CSConPCConnSession::HandleGetMessageL() |
|
583 { |
|
584 TRACE_FUNC_ENTRY; |
|
585 TInt ret ( KErrNone ); |
|
586 |
|
587 if ( !iCSCHandler ) |
|
588 { |
|
589 TRAP( ret, LoadCSCDllL() ); |
|
590 if ( ret != KErrNone) |
|
591 { |
|
592 LOGGER_WRITE_1( "CSConPCConnSession::HandleGetMessageL() : CSC dll load failed with error code %d", ret ); |
|
593 return ret; |
|
594 } |
|
595 } |
|
596 |
|
597 TInt32 length ( 0 ); |
|
598 RMemReadStream readBuf( iChunk.Base(), iChunk.Size() ); |
|
599 iBuffer->Reset(); |
|
600 |
|
601 length = readBuf.ReadInt32L(); |
|
602 HBufC8* name = HBufC8::NewLC( length ); |
|
603 TPtr8 namePtr8 = name->Des(); |
|
604 readBuf.ReadL( namePtr8, length); |
|
605 namePtr8.SetLength( length ); |
|
606 LOGGER_WRITE8_1("namePtr: %S", &namePtr8); |
|
607 |
|
608 const TUint8* ptr8 = namePtr8.Ptr(); |
|
609 const TUint16* ptr16 = reinterpret_cast<const TUint16*>( ptr8 ); |
|
610 TPtrC namePtr; |
|
611 namePtr.Set( ptr16, length/2 ); |
|
612 |
|
613 length = readBuf.ReadInt32L(); |
|
614 HBufC8* type = HBufC8::NewLC( length ); |
|
615 TPtr8 typePtr = type->Des(); |
|
616 readBuf.ReadL( typePtr, length); |
|
617 |
|
618 readBuf.Close(); |
|
619 |
|
620 if ( typePtr.Compare( KSConCapabilityObjectType ) == KErrNone ) |
|
621 { |
|
622 ret = iCSCHandler->CapabilityObject( *iBuffer ); |
|
623 |
|
624 #ifdef DEBUG_XML |
|
625 |
|
626 RFile file; |
|
627 if ( file.Open(iFs, KSConConMLDebugFile, EFileWrite ) == KErrNone ) |
|
628 { |
|
629 RFileWriteStream fws; |
|
630 TInt fileSize; |
|
631 file.Size ( fileSize ); |
|
632 TTime now; |
|
633 now.HomeTime(); |
|
634 TDateTime time = now.DateTime(); |
|
635 TBuf8<16> timeLine; |
|
636 timeLine.Format( KTimeFormat, time.Hour(), time.Minute(), |
|
637 time.Second(), time.MicroSecond() ); |
|
638 |
|
639 fws.Attach ( file, fileSize); |
|
640 fws.PushL(); |
|
641 fws.WriteL( timeLine ); |
|
642 _LIT8( KGetMessage, "__________GET -MESSAGE - Capability Object \n " ); |
|
643 fws.WriteL( KGetMessage ); |
|
644 fws.WriteL( iBuffer->Ptr(0), iBuffer->Size() ); |
|
645 TRAP_IGNORE( fws.CommitL() ); |
|
646 fws.Close(); |
|
647 |
|
648 CleanupStack::PopAndDestroy( &fws ); |
|
649 } |
|
650 file.Close(); |
|
651 #endif |
|
652 |
|
653 } |
|
654 else if ( typePtr.CompareC( KSConPCDWBXMLObjectType) == KErrNone ) |
|
655 { |
|
656 if ( namePtr8.Find(KSCONSyncRequest) == 0 ) // 8-bit search |
|
657 { |
|
658 LOGGER_WRITE("Sync request"); |
|
659 |
|
660 RBufWriteStream stream( *iBuffer ); |
|
661 |
|
662 CleanupClosePushL( stream ); |
|
663 |
|
664 TRAP( ret, iPCDHandler->HandleGetSyncRequestL( namePtr8, stream, iChunk.MaxSize() - sizeof(TInt32) )); |
|
665 if ( ret ) |
|
666 { |
|
667 LOGGER_WRITE_1("HandleGetSyncRequestL() Leaved with %d", ret); |
|
668 } |
|
669 stream.CommitL(); |
|
670 CleanupStack::PopAndDestroy( &stream ); |
|
671 |
|
672 LOGGER_WRITE_1("iBuffer size: %d", iBuffer->Size()); |
|
673 |
|
674 } |
|
675 else if ( namePtr.Find(KSCONReadImsi) == 0 ) // 16-bit search |
|
676 { |
|
677 LOGGER_WRITE("Read IMSI"); |
|
678 TBuf<CTelephony::KIMSISize> imsi; |
|
679 ret = CSconImsiReader::GetImsiL( imsi ); |
|
680 |
|
681 if ( ret == KErrNone ) |
|
682 { |
|
683 TBuf8<CTelephony::KIMSISize> imsi8; |
|
684 User::LeaveIfError( CnvUtfConverter::ConvertFromUnicodeToUtf8(imsi8,imsi) ); |
|
685 |
|
686 iBuffer->ResizeL( imsi8.Length() ); |
|
687 iBuffer->Write( 0, imsi8 ); |
|
688 } |
|
689 else |
|
690 { |
|
691 // Change error code more generic |
|
692 ret = KErrNotFound; |
|
693 } |
|
694 } |
|
695 else if ( namePtr.Find(KSCONReadNetworkInfo) == 0 ) // 16-bit search |
|
696 { |
|
697 LOGGER_WRITE("Read NetworkInfo"); |
|
698 CTelephony::TRegistrationStatus regStatus; |
|
699 ret = CSconImsiReader::GetNetworkStatusL( regStatus ); |
|
700 |
|
701 if ( ret == KErrNone ) |
|
702 { |
|
703 RBufWriteStream stream( *iBuffer ); |
|
704 CleanupClosePushL( stream ); |
|
705 stream.WriteInt8L( regStatus ); |
|
706 stream.CommitL(); |
|
707 CleanupStack::PopAndDestroy( &stream ); |
|
708 } |
|
709 else |
|
710 { |
|
711 // Change error code more generic |
|
712 ret = KErrNotFound; |
|
713 } |
|
714 } |
|
715 else if ( namePtr.Find(KSCONReadOviAccount) == 0 ) |
|
716 { |
|
717 LOGGER_WRITE("Read Ovi account"); |
|
718 RBufWriteStream stream( *iBuffer ); |
|
719 CleanupClosePushL( stream ); |
|
720 |
|
721 ret = ReadOviAccountInfoL( stream ); |
|
722 stream.CommitL(); |
|
723 CleanupStack::PopAndDestroy( &stream ); |
|
724 |
|
725 } |
|
726 else if ( namePtr.Find(KSCONListPath) == 0 ) |
|
727 { |
|
728 LOGGER_WRITE("List path"); |
|
729 // LISTP:0:pathname |
|
730 if ( namePtr.Length() > KSCONListPath().Length()+2) |
|
731 { |
|
732 TPtrC pathname = namePtr.Mid( KSCONListPath().Length()+2 ); |
|
733 |
|
734 const TUint16 levelsChar = namePtr[ KSCONListPath().Length() ]; |
|
735 TInt level(KErrNotFound); |
|
736 if ( levelsChar >= TChar('0') ) |
|
737 { |
|
738 level = levelsChar - TChar('0'); |
|
739 } |
|
740 |
|
741 RBufWriteStream stream( *iBuffer ); |
|
742 CleanupClosePushL( stream ); |
|
743 TRAP( ret, iFolderLister->GenerateFolderListL( stream, pathname, level )); |
|
744 LOGGER_WRITE_1("GenerateFolderListL leaved with err: %d", ret); |
|
745 stream.CommitL(); |
|
746 CleanupStack::PopAndDestroy( &stream ); |
|
747 } |
|
748 else |
|
749 { |
|
750 ret = KErrArgument; |
|
751 } |
|
752 |
|
753 } |
|
754 else if ( namePtr.Find(KSCONReadBtInfo) == 0 ) |
|
755 { |
|
756 LOGGER_WRITE( "Read BT info"); |
|
757 if ( !iBtEngine ) |
|
758 { |
|
759 iBtEngine = CSconBtEngine::NewL(); |
|
760 } |
|
761 RBufWriteStream stream( *iBuffer ); |
|
762 CleanupClosePushL( stream ); |
|
763 TRAP( ret, iBtEngine->ReadBTInfoL( stream ) ); |
|
764 LOGGER_WRITE_1("ReadBTInfoL leaved with err: %d", ret); |
|
765 stream.CommitL(); |
|
766 CleanupStack::PopAndDestroy( &stream ); |
|
767 } |
|
768 else if ( namePtr.Find(KSCONSetBtPower) == 0 ) |
|
769 { |
|
770 LOGGER_WRITE( "Change BT Power state"); |
|
771 if ( namePtr.Length() == KSCONSetBtPower().Length()+1 ) |
|
772 { |
|
773 const TUint16 lastChar = namePtr[ KSCONSetBtPower().Length() ]; |
|
774 TBool changeBtOn; |
|
775 if ( lastChar == TChar('0') ) |
|
776 { |
|
777 changeBtOn = EFalse; |
|
778 } |
|
779 else if ( lastChar == TChar('1') ) |
|
780 { |
|
781 changeBtOn = ETrue; |
|
782 } |
|
783 else |
|
784 { |
|
785 ret = KErrArgument; |
|
786 } |
|
787 |
|
788 if ( !ret ) |
|
789 { |
|
790 if ( !iBtEngine ) |
|
791 { |
|
792 iBtEngine = CSconBtEngine::NewL(); |
|
793 } |
|
794 TInt err = iBtEngine->SetBtPowerState( changeBtOn ); |
|
795 |
|
796 RBufWriteStream stream( *iBuffer ); |
|
797 CleanupClosePushL( stream ); |
|
798 stream.WriteInt32L( err ); |
|
799 stream.CommitL(); |
|
800 CleanupStack::PopAndDestroy( &stream ); |
|
801 } |
|
802 } |
|
803 else |
|
804 { |
|
805 ret = KErrArgument; |
|
806 } |
|
807 } |
|
808 else if ( namePtr.Find(KSCONSetBtName) == 0 ) |
|
809 { |
|
810 LOGGER_WRITE( "Set BT Name"); |
|
811 TPtrC btName = namePtr.Mid( KSCONSetBtName().Length() ); |
|
812 TInt err = iBtEngine->SetBtName( btName ); |
|
813 |
|
814 RBufWriteStream stream( *iBuffer ); |
|
815 CleanupClosePushL( stream ); |
|
816 stream.WriteInt32L( err ); |
|
817 stream.CommitL(); |
|
818 CleanupStack::PopAndDestroy( &stream ); |
|
819 } |
|
820 else if ( namePtr.Find(KSCONSetBtAuthorized) == 0 ) |
|
821 { |
|
822 LOGGER_WRITE( "Set BT Authorized"); |
|
823 ret = KErrArgument; |
|
824 // SETBTAUTHORIZED:0:00245f8d6a26 |
|
825 // 1. param = auth. state ("0"=off, "1"=true) |
|
826 // 2. param = bt address (hex string) |
|
827 |
|
828 if ( namePtr.Length() > KSCONSetBtAuthorized().Length()+2) |
|
829 { |
|
830 TPtrC btAddr = namePtr.Mid( KSCONSetBtAuthorized().Length()+2 ); |
|
831 |
|
832 const TUint16 authStateChar = namePtr[ KSCONSetBtAuthorized().Length() ]; |
|
833 TBool authorize(EFalse); |
|
834 if ( authStateChar == TChar('0') ) |
|
835 { |
|
836 authorize = EFalse; |
|
837 ret = KErrNone; |
|
838 } |
|
839 else if ( authStateChar == TChar('1') ) |
|
840 { |
|
841 authorize = ETrue; |
|
842 ret = KErrNone; |
|
843 } |
|
844 |
|
845 if ( !iBtEngine ) |
|
846 { |
|
847 iBtEngine = CSconBtEngine::NewL(); |
|
848 } |
|
849 TRAPD(err, iBtEngine->SetBtAuthorizedL( btAddr, authorize ) ); |
|
850 |
|
851 RBufWriteStream stream( *iBuffer ); |
|
852 CleanupClosePushL( stream ); |
|
853 stream.WriteInt32L( err ); |
|
854 stream.CommitL(); |
|
855 CleanupStack::PopAndDestroy( &stream ); |
|
856 } |
|
857 |
|
858 } |
|
859 else |
|
860 { |
|
861 ret = HandleWBXMLGetRequestL( namePtr ); |
|
862 } |
|
863 } |
|
864 else |
|
865 { |
|
866 LOGGER_WRITE( "CSConPCConnSession::HandleGetMessageL() : Header type not regognized " ); |
|
867 ret = KErrNotSupported; |
|
868 } |
|
869 |
|
870 CleanupStack::PopAndDestroy( 2 ); // name, type |
|
871 |
|
872 if ( ret != KErrNone ) |
|
873 { |
|
874 return ret; |
|
875 } |
|
876 |
|
877 length = iBuffer->Size(); |
|
878 |
|
879 if ( sizeof(TInt32) + length > iChunk.Size() ) |
|
880 { |
|
881 // need to resize chunk |
|
882 TInt err = iChunk.Adjust( sizeof(TInt32) + length ); |
|
883 LOGGER_WRITE_2("iChunk.Adjust( %d ) err: %d", sizeof(TInt32) + length, err); |
|
884 if ( err ) |
|
885 { |
|
886 iBuffer->Reset(); |
|
887 LOGGER_WRITE_1( "CSConPCConnSession::HandleGetMessageL() : returned %d", ret ); |
|
888 return err; |
|
889 } |
|
890 } |
|
891 |
|
892 // copy data to chunk |
|
893 RMemWriteStream writeBuf ( iChunk.Base(), iChunk.Size() ); |
|
894 |
|
895 if ( length > 0 ) |
|
896 { |
|
897 writeBuf.WriteInt32L( length ); |
|
898 writeBuf.WriteL( iBuffer->Ptr(0), length ); |
|
899 writeBuf.CommitL(); |
|
900 } |
|
901 else |
|
902 { |
|
903 writeBuf.WriteInt32L( 0 ); |
|
904 } |
|
905 writeBuf.CommitL(); |
|
906 writeBuf.Close(); |
|
907 iBuffer->Reset(); |
|
908 LOGGER_WRITE_1( "CSConPCConnSession::HandleGetMessageL() : returned %d", ret ); |
|
909 return ( ret ); |
|
910 } |
|
911 |
|
912 // ----------------------------------------------------------------------------- |
|
913 // CSConPCConnSession::HandleWBXMLGetRequestL() |
|
914 // Handles a ConML(wbxml) Get request from the client |
|
915 // ----------------------------------------------------------------------------- |
|
916 // |
|
917 TInt CSConPCConnSession::HandleWBXMLGetRequestL( const TDesC& aFileName ) |
|
918 { |
|
919 TRACE_FUNC_ENTRY; |
|
920 TInt ret(KErrNone); |
|
921 if ( aFileName.Find(KSCONGetMetadataRequest) == 0 ) |
|
922 { |
|
923 // ConML get metadata request --> Create metadata task |
|
924 LOGGER_WRITE( "ConML GetMetadataRequest" ); |
|
925 TPtrC filename = aFileName.Mid( KSCONGetMetadataRequest().Length() ); |
|
926 |
|
927 TSConMethodName method ( EGetMetadata ); |
|
928 CSConTask* task = CSConTask::NewLC( method ); |
|
929 |
|
930 if ( filename.Length() > task->iGetMetadataParams->iFilename.MaxLength() ) |
|
931 { |
|
932 User::Leave( KErrTooBig ); |
|
933 } |
|
934 task->iGetMetadataParams->iFilename = filename; |
|
935 |
|
936 ret = iPCDHandler->PutTaskL( task ); |
|
937 CleanupStack::Pop( task ); |
|
938 LOGGER_WRITE_1("iPCDHandler->PutTaskL ret: %d", ret); |
|
939 } |
|
940 else if ( aFileName.Length() > 0 ) |
|
941 { |
|
942 LOGGER_WRITE("Error: aFilename does not match to any definitions"); |
|
943 TRACE_FUNC_RET( KErrArgument ); |
|
944 return KErrArgument; |
|
945 } |
|
946 |
|
947 // Get reply |
|
948 LOGGER_WRITE( "CSConPCConnSession::HandleGetMessageL() before ConML GetReplyL" ); |
|
949 CSConStatusReply* reply = iPCDHandler->GetReply(); |
|
950 CleanupStack::PushL( reply ); |
|
951 |
|
952 ConML_ConMLPtr_t content = new ( ELeave ) ConML_ConML_t(); |
|
953 CleanupStack::PushL( content ); |
|
954 |
|
955 AppendStatusL( content, reply ); |
|
956 ret = iConMLHandler->GenerateDocument( content ); |
|
957 |
|
958 CleanupStack::PopAndDestroy( content ); |
|
959 CleanupStack::PopAndDestroy( reply ); |
|
960 |
|
961 TPtrC8 ptr( iConMLHandler->WBXMLDocument() ); |
|
962 LOGGER_WRITE_1("ptr.Size(): %d", ptr.Size()); |
|
963 iBuffer->ResizeL( ptr.Size() ); |
|
964 iBuffer->Write( 0, ptr ); |
|
965 |
|
966 #ifdef DEBUG_XML |
|
967 RFile file; |
|
968 if ( file.Open( iFs, KSConConMLDebugFile, EFileWrite) == KErrNone ) |
|
969 { |
|
970 RFileWriteStream fws; |
|
971 TInt fileSize; |
|
972 file.Size ( fileSize ); |
|
973 fws.Attach ( file, fileSize); |
|
974 fws.PushL(); |
|
975 TTime now; |
|
976 now.HomeTime(); |
|
977 TDateTime time = now.DateTime(); |
|
978 TBuf8<16> timeLine; |
|
979 timeLine.Format( KTimeFormat, time.Hour(), time.Minute(), |
|
980 time.Second(), time.MicroSecond() ); |
|
981 |
|
982 fws.WriteL( timeLine ); |
|
983 _LIT8( KGetMessage, "__________GET -MESSAGE" ); |
|
984 fws.WriteL( KGetMessage ); |
|
985 fws.WriteL(KXmlBegin); |
|
986 fws.WriteL(iConMLHandler->XMLDocument().Ptr(), |
|
987 iConMLHandler->XMLDocument().Length()); |
|
988 fws.WriteL(_L("\n\n")); |
|
989 TRAP_IGNORE( fws.CommitL() ); |
|
990 fws.Close(); |
|
991 CleanupStack::PopAndDestroy( &fws ); |
|
992 } |
|
993 |
|
994 file.Close(); |
|
995 #endif |
|
996 TRACE_FUNC_RET(ret); |
|
997 return ret; |
|
998 } |
|
999 |
|
1000 |
|
1001 // ----------------------------------------------------------------------------- |
|
1002 // CSConPCConnSession::ReadOviAccountInfoL() |
|
1003 // Reads ovi account information to stream |
|
1004 // ----------------------------------------------------------------------------- |
|
1005 // |
|
1006 TInt CSConPCConnSession::ReadOviAccountInfoL( RWriteStream& aAccountInfoStream ) |
|
1007 { |
|
1008 TRACE_FUNC_ENTRY; |
|
1009 RLibrary oviaccounthandlerLib; |
|
1010 CleanupClosePushL( oviaccounthandlerLib ); |
|
1011 // Dynamically load DLL |
|
1012 TInt err = oviaccounthandlerLib.Load( KSconOviAccountHandlerDllName ); |
|
1013 if ( err ) |
|
1014 { |
|
1015 LOGGER_WRITE_1("oviaccounthandlerLib.Load err: %d", err); |
|
1016 err = KErrNotSupported; |
|
1017 } |
|
1018 else if( oviaccounthandlerLib.Type()[1] != KSconOviAccountHandlerDllUid ) |
|
1019 { |
|
1020 LOGGER_WRITE_1( "KSconOviAccountHandlerDllUid incorrect... (0x%08X)",oviaccounthandlerLib.Type()[1].iUid ); |
|
1021 err = KErrNotSupported; |
|
1022 } |
|
1023 |
|
1024 if ( err == KErrNone ) |
|
1025 { |
|
1026 TSConCreateCSconOviAccountHandlerFunc CreateCSconOviAccountHandlerL = |
|
1027 (TSConCreateCSconOviAccountHandlerFunc)oviaccounthandlerLib.Lookup(1); |
|
1028 |
|
1029 CSconOviAccountHandler* oviAccountHandler = (CSconOviAccountHandler*)CreateCSconOviAccountHandlerL(); |
|
1030 |
|
1031 TRAP(err, oviAccountHandler->GetOviAccountDetailsL( aAccountInfoStream ) ); |
|
1032 LOGGER_WRITE_1("GetOviAccountDetailsL err: %d", err); |
|
1033 |
|
1034 delete oviAccountHandler; |
|
1035 oviAccountHandler = NULL; |
|
1036 |
|
1037 if ( err ) |
|
1038 { |
|
1039 // change error code |
|
1040 err = KErrNotFound; |
|
1041 } |
|
1042 } |
|
1043 else |
|
1044 { |
|
1045 err = KErrNotSupported; |
|
1046 } |
|
1047 |
|
1048 CleanupStack::PopAndDestroy( &oviaccounthandlerLib ); |
|
1049 TRACE_FUNC_EXIT; |
|
1050 return err; |
|
1051 } |
|
1052 |
|
1053 // ----------------------------------------------------------------------------- |
|
1054 // CSConPCConnSession::HandleResetMessage() |
|
1055 // Resets the PCCS service |
|
1056 // ----------------------------------------------------------------------------- |
|
1057 // |
|
1058 TInt CSConPCConnSession::HandleResetMessage() |
|
1059 { |
|
1060 TRACE_FUNC_ENTRY; |
|
1061 TInt ret ( KErrNone ); |
|
1062 |
|
1063 // reset PCD |
|
1064 if ( iPCDHandler ) |
|
1065 { |
|
1066 iPCDHandler->ResetPCD(); |
|
1067 } |
|
1068 |
|
1069 LOGGER_WRITE_1( "CSConPCConnSession::HandleResetMessage() : ret %d", ret ); |
|
1070 return ret; |
|
1071 } |
|
1072 |
|
1073 // ----------------------------------------------------------------------------- |
|
1074 // CSConPCConnSession::HandleChunkMessage( const RMessage2& aMessage ) |
|
1075 // Receives the chunk handle from the client |
|
1076 // ----------------------------------------------------------------------------- |
|
1077 // |
|
1078 TInt CSConPCConnSession::HandleChunkMessage( const RMessage2& aMessage ) |
|
1079 { |
|
1080 TRACE_FUNC_ENTRY; |
|
1081 TInt ret ( KErrNone ); |
|
1082 |
|
1083 ret = iChunk.Open( aMessage, 0, EFalse ); |
|
1084 |
|
1085 LOGGER_WRITE_1( "CSConPCConnSession::HandleChunkMessageL() : ret %d", ret ); |
|
1086 return ret; |
|
1087 } |
|
1088 |
|
1089 // ----------------------------------------------------------------------------- |
|
1090 // CSConPCConnSession::LoadPCDDllL() |
|
1091 // Loads the PCCS service |
|
1092 // ----------------------------------------------------------------------------- |
|
1093 // |
|
1094 void CSConPCConnSession::LoadPCDDllL() |
|
1095 { |
|
1096 TRACE_FUNC_ENTRY; |
|
1097 |
|
1098 // Dynamically load DLL |
|
1099 User::LeaveIfError( iPCDlib.Load( KSConPCDLibName ) ); |
|
1100 if( iPCDlib.Type()[1] != KSConPCDUid ) |
|
1101 { |
|
1102 LOGGER_WRITE( "CSConPCConnSession::LoadPCDDllL() : KSConPCDUidValue incorrect..." ); |
|
1103 iPCDlib.Close(); |
|
1104 User::Leave( KErrNotFound ); |
|
1105 } |
|
1106 TSConCreateCSConPCDFunc CreateCSConPCDL = |
|
1107 (TSConCreateCSConPCDFunc)iPCDlib.Lookup(1); |
|
1108 |
|
1109 iPCDHandler = (CSConPCD*)CreateCSConPCDL(); |
|
1110 TRACE_FUNC_EXIT; |
|
1111 } |
|
1112 |
|
1113 // ----------------------------------------------------------------------------- |
|
1114 // CSConPCConnSession::LoadCSCDllL() |
|
1115 // Loads the CSC service |
|
1116 // ----------------------------------------------------------------------------- |
|
1117 // |
|
1118 void CSConPCConnSession::LoadCSCDllL() |
|
1119 { |
|
1120 TRACE_FUNC_ENTRY; |
|
1121 // Dynamically load DLL |
|
1122 User::LeaveIfError( iCSClib.Load( KSConCSCLibName ) ); |
|
1123 if( iCSClib.Type()[1] != KSConCSCUid ) |
|
1124 { |
|
1125 LOGGER_WRITE( "CSConPCConnSession::LoadCSCDllL() : KSConCSCUidValue incorrect" ); |
|
1126 iCSClib.Close(); |
|
1127 User::Leave( KErrNotFound ); |
|
1128 } |
|
1129 TSConCreateCSConCSCFunc CreateCSConCSCL = |
|
1130 (TSConCreateCSConCSCFunc)iCSClib.Lookup(1); |
|
1131 |
|
1132 iCSCHandler = (CSConCSC*)CreateCSConCSCL(); |
|
1133 TRACE_FUNC_EXIT; |
|
1134 } |
|
1135 |
|
1136 // ----------------------------------------------------------------------------- |
|
1137 // CSConPCConnSession::LoadConMLHandlerDllL() |
|
1138 // Loads the ConML handler |
|
1139 // ----------------------------------------------------------------------------- |
|
1140 // |
|
1141 void CSConPCConnSession::LoadConMLHandlerDllL() |
|
1142 { |
|
1143 TRACE_FUNC_ENTRY; |
|
1144 // Dynamically load DLL |
|
1145 User::LeaveIfError( iConMLHandlerLib.Load( KSConConMLHandlerLibName ) ); |
|
1146 if ( iConMLHandlerLib.Type()[1] != KSConConMLHandlerUid ) |
|
1147 { |
|
1148 LOGGER_WRITE( "CSConPCConnSession::LoadConMLHandlerDllL() : KSConConMLHandlerUidValue incorrect" ); |
|
1149 iConMLHandlerLib.Close(); |
|
1150 User::Leave( KErrNotFound ); |
|
1151 } |
|
1152 TSConCreateCSConConMLHandlerFunc CreateCSConConMLHandlerL = |
|
1153 (TSConCreateCSConConMLHandlerFunc)iConMLHandlerLib.Lookup(1); |
|
1154 |
|
1155 iConMLHandler = (CSConConMLHandler*)CreateCSConConMLHandlerL(); |
|
1156 TRACE_FUNC_EXIT; |
|
1157 } |
|
1158 |
|
1159 // ----------------------------------------------------------------------------- |
|
1160 // CSConPCConnSession::ConMLL() |
|
1161 // Callback function for ConML handler - parsed data processing starts |
|
1162 // ----------------------------------------------------------------------------- |
|
1163 // |
|
1164 void CSConPCConnSession::ConMLL( ConML_ConMLPtr_t aContent ) |
|
1165 { |
|
1166 TRACE_FUNC_ENTRY; |
|
1167 TInt ret ( KErrNone ); |
|
1168 |
|
1169 #ifdef DEBUG_XML |
|
1170 iConMLHandler->GenerateDocument( aContent ); |
|
1171 RFile file; |
|
1172 if ( file.Open(iFs, KSConConMLDebugFile, EFileWrite) == KErrNone ) |
|
1173 { |
|
1174 RFileWriteStream fws; |
|
1175 TInt fileSize; |
|
1176 file.Size( fileSize ); |
|
1177 fws.Attach ( file, fileSize ); |
|
1178 fws.PushL(); |
|
1179 |
|
1180 TTime now; |
|
1181 now.HomeTime(); |
|
1182 TDateTime time = now.DateTime(); |
|
1183 TBuf8<16> timeLine; |
|
1184 timeLine.Format (KTimeFormat, time.Hour(), time.Minute(), |
|
1185 time.Second(), time.MicroSecond() ); |
|
1186 |
|
1187 fws.WriteL( timeLine ); |
|
1188 _LIT8( KPutMessage, "__________PUT-MESSAGE" ); |
|
1189 fws.WriteL( KPutMessage ); |
|
1190 fws.WriteL( KXmlBegin ); |
|
1191 fws.WriteL( iConMLHandler->XMLDocument().Ptr(), |
|
1192 iConMLHandler->XMLDocument().Length()); |
|
1193 fws.WriteL(_L("\n\n")); |
|
1194 TRAP_IGNORE( fws.CommitL() ); |
|
1195 fws.Close(); |
|
1196 CleanupStack::PopAndDestroy( &fws ); |
|
1197 } |
|
1198 file.Close(); |
|
1199 |
|
1200 #endif |
|
1201 |
|
1202 |
|
1203 if ( aContent ) |
|
1204 { |
|
1205 if ( aContent->execute ) |
|
1206 { |
|
1207 ret = OptionsFromExecuteL( aContent->execute ); |
|
1208 } |
|
1209 else if ( aContent->cancel ) |
|
1210 { |
|
1211 ret = TaskCancelL( aContent->cancel ); |
|
1212 } |
|
1213 else if ( aContent->getStatus ) |
|
1214 { |
|
1215 ret = TaskGetStatusL ( aContent->getStatus ); |
|
1216 } |
|
1217 else |
|
1218 { |
|
1219 LOGGER_WRITE( "CSConPCConnSession::ConML() : No appropriate content in ConML -element " ); |
|
1220 ret = KErrArgument; |
|
1221 } |
|
1222 } |
|
1223 else |
|
1224 { |
|
1225 ret = KErrArgument; |
|
1226 } |
|
1227 |
|
1228 // store result for later use |
|
1229 iResult = ret; |
|
1230 TRACE_FUNC_EXIT; |
|
1231 } |
|
1232 |
|
1233 // ----------------------------------------------------------------------------- |
|
1234 // CSConPCConnSession::OptionsFromExecuteL() |
|
1235 // Handles data of an execute -element |
|
1236 // ----------------------------------------------------------------------------- |
|
1237 // |
|
1238 TInt CSConPCConnSession::OptionsFromExecuteL(ConML_ExecutePtr_t aContent ) |
|
1239 { |
|
1240 TRACE_FUNC_ENTRY; |
|
1241 |
|
1242 TInt ret ( KErrNone ); |
|
1243 if ( aContent->updateDeviceInfo ) |
|
1244 { |
|
1245 ret = TaskUpdateDeviceInfoL( aContent->updateDeviceInfo); |
|
1246 } |
|
1247 else if ( aContent->listInstalledApps ) |
|
1248 { |
|
1249 ret = TaskListInstalledAppsL( aContent->listInstalledApps); |
|
1250 } |
|
1251 else if ( aContent->install ) |
|
1252 { |
|
1253 ret = TaskInstallL( aContent->install ); |
|
1254 } |
|
1255 else if ( aContent->unInstall ) |
|
1256 { |
|
1257 ret = TaskUnInstallL( aContent->unInstall ); |
|
1258 } |
|
1259 else if ( aContent->listDataOwners ) |
|
1260 { |
|
1261 ret = TaskListDataOwnersL(); |
|
1262 } |
|
1263 else if ( aContent->setBurMode ) |
|
1264 { |
|
1265 ret = TaskSetBURModeL( aContent->setBurMode ); |
|
1266 } |
|
1267 else if ( aContent->getDataSize ) |
|
1268 { |
|
1269 ret = TaskGetDataSizeL( aContent->getDataSize ); |
|
1270 } |
|
1271 else if ( aContent->requestData ) |
|
1272 { |
|
1273 ret = TaskRequestDataL( aContent->requestData ); |
|
1274 } |
|
1275 else if ( aContent->listPublicFiles ) |
|
1276 { |
|
1277 ret = TaskListPublicFilesL( aContent->listPublicFiles ); |
|
1278 } |
|
1279 else if ( aContent->reboot ) |
|
1280 { |
|
1281 ret = TaskRebootL(); |
|
1282 } |
|
1283 else if ( aContent->getDataOwnerStatus ) |
|
1284 { |
|
1285 ret = TaskGetDataOwnerStatusL( aContent->getDataOwnerStatus ); |
|
1286 } |
|
1287 else if ( aContent->supplyData ) |
|
1288 { |
|
1289 ret = TaskSupplyDataL( aContent->supplyData ); |
|
1290 } |
|
1291 else if ( aContent->getMetadata ) |
|
1292 { |
|
1293 ret = TaskGetMetadataL( aContent->getMetadata ); |
|
1294 } |
|
1295 else |
|
1296 { |
|
1297 LOGGER_WRITE( "CSConPCConnSession::OptionsFromExecute() : No content " ); |
|
1298 ret = KErrNotSupported; |
|
1299 } |
|
1300 LOGGER_WRITE_1( "CSConPCConnSession::OptionsFromExecute() : returned %d", ret ); |
|
1301 return ret; |
|
1302 } |
|
1303 |
|
1304 // ----------------------------------------------------------------------------- |
|
1305 // CSConPCConnSession::TaskCancelL(ConML_CancelPtr_t aContent) |
|
1306 // Sends a Cancel -task to PCCS service |
|
1307 // ----------------------------------------------------------------------------- |
|
1308 // |
|
1309 TInt CSConPCConnSession::TaskCancelL( ConML_CancelPtr_t aContent ) |
|
1310 { |
|
1311 TRACE_FUNC_ENTRY; |
|
1312 TInt ret ( KErrNone ); |
|
1313 TSConMethodName method ( ECancel ); |
|
1314 CSConTask* task = CSConTask::NewLC( method ); |
|
1315 if ( aContent->all ) |
|
1316 { |
|
1317 task->iCancelTaskAll = ETrue; |
|
1318 } |
|
1319 if ( aContent->id ) |
|
1320 { |
|
1321 task->iCancelTaskId = ( DesToInt( aContent->id->Data() )); |
|
1322 } |
|
1323 ret = iPCDHandler->PutTaskL( task ); |
|
1324 CleanupStack::Pop( task ); |
|
1325 LOGGER_WRITE_1( "CSConPCConnSession::TaskCancelL() : returned %d", ret ); |
|
1326 return ret; |
|
1327 } |
|
1328 |
|
1329 |
|
1330 // ----------------------------------------------------------------------------- |
|
1331 // CSConPCConnSession::TaskGetStatusL() |
|
1332 // Sends a Get Status -task to PCCS service |
|
1333 // ----------------------------------------------------------------------------- |
|
1334 // |
|
1335 TInt CSConPCConnSession::TaskGetStatusL( ConML_GetStatusPtr_t aContent ) |
|
1336 { |
|
1337 TRACE_FUNC_ENTRY; |
|
1338 TInt ret ( KErrNone ); |
|
1339 TSConMethodName method ( EGetStatus ); |
|
1340 CSConTask* task = CSConTask::NewLC( method ); |
|
1341 if ( aContent->all ) |
|
1342 { |
|
1343 task->iGetStatusParams->iAll = ETrue; |
|
1344 } |
|
1345 if ( aContent->id) |
|
1346 { |
|
1347 task->iGetStatusParams->iTaskId = ( DesToInt( aContent->id->Data() )); |
|
1348 } |
|
1349 ret = iPCDHandler->PutTaskL( task ); |
|
1350 CleanupStack::Pop( task ); |
|
1351 LOGGER_WRITE_1( "CSConPCConnSession::TaskGetStatusL() : returned %d", ret ); |
|
1352 return ret; |
|
1353 } |
|
1354 |
|
1355 // ----------------------------------------------------------------------------- |
|
1356 // CSConPCConnSession::TaskInstallL() |
|
1357 // Sends an Install -task to PCCS service |
|
1358 // ----------------------------------------------------------------------------- |
|
1359 // |
|
1360 TInt CSConPCConnSession::TaskInstallL( ConML_InstallPtr_t aContent ) |
|
1361 { |
|
1362 TRACE_FUNC_ENTRY; |
|
1363 TInt ret ( KErrNone ); |
|
1364 TSConMethodName method ( EInstall ); |
|
1365 CSConTask* task = CSConTask::NewLC( method); |
|
1366 task->iInstallParams->iMode = EUnknown; |
|
1367 if ( aContent->name ) |
|
1368 { |
|
1369 // Unicode conversion from 8-bit to 16-bit |
|
1370 CnvUtfConverter::ConvertToUnicodeFromUtf8(task->iInstallParams->iPath, |
|
1371 aContent->name->Data()); |
|
1372 } |
|
1373 if ( aContent->instParams ) |
|
1374 { |
|
1375 if ( aContent->instParams->param ) |
|
1376 { |
|
1377 for ( ConML_ParamListPtr_t p = aContent->instParams->param; |
|
1378 p && p->data; p = p->next) |
|
1379 { |
|
1380 LOGGER_WRITE( "CSConPCConnSession::TaskInstallL() : Parameters found " ); |
|
1381 if ( p->data->name ) |
|
1382 { |
|
1383 LOGGER_WRITE( "CSConPCConnSession::TaskInstallL() : name param found " ); |
|
1384 TPtrC8 silent(KParamNameSilent); |
|
1385 |
|
1386 TInt comp = Mem::Compare((TUint8*)p->data->name->content, (TInt)p->data->name->length, silent.Ptr(), silent.Length()); |
|
1387 if( comp == 0) |
|
1388 { |
|
1389 // "Silent"-param found |
|
1390 LOGGER_WRITE( "CSConPCConnSession::TaskInstallL() : Silent-param found " ); |
|
1391 if ( p->data->value ) |
|
1392 { |
|
1393 TPtrC8 dataValue((TUint8*)p->data->value->content, (TInt)p->data->value->length); |
|
1394 TInt value = DesToInt( dataValue ); |
|
1395 if (value == 1) |
|
1396 { |
|
1397 LOGGER_WRITE( "CSConPCConnSession::TaskInstallL() : ESilentInstall " ); |
|
1398 task->iInstallParams->iMode = ESilentInstall; |
|
1399 } |
|
1400 else if( value == 0 ) |
|
1401 { |
|
1402 LOGGER_WRITE( "CSConPCConnSession::TaskInstallL() : EUnsilentInstall " ); |
|
1403 task->iInstallParams->iMode = EUnsilentInstall; |
|
1404 } |
|
1405 } |
|
1406 } |
|
1407 } |
|
1408 } |
|
1409 } |
|
1410 } |
|
1411 ret = iPCDHandler->PutTaskL( task ); |
|
1412 CleanupStack::Pop( task ); |
|
1413 LOGGER_WRITE_1( "CSConPCConnSession::TaskInstallL() : returned %d", ret ); |
|
1414 return ret; |
|
1415 } |
|
1416 |
|
1417 // ----------------------------------------------------------------------------- |
|
1418 // CSConPCConnSession::TaskUnInstallL() |
|
1419 // Sends an Uninstall -task to PCCS service |
|
1420 // ----------------------------------------------------------------------------- |
|
1421 // |
|
1422 TInt CSConPCConnSession::TaskUnInstallL( ConML_UnInstallPtr_t aContent ) |
|
1423 { |
|
1424 TRACE_FUNC_ENTRY; |
|
1425 TInt ret ( KErrNone ); |
|
1426 TSConMethodName method ( EUninstall ); |
|
1427 CSConTask* task = CSConTask::NewLC( method ); |
|
1428 task->iUninstallParams->iMode = EUnknown; |
|
1429 |
|
1430 if ( aContent->applications->application) |
|
1431 { |
|
1432 for ( ConML_ApplicationListPtr_t p = |
|
1433 aContent->applications->application; p && p->data; p = p->next ) |
|
1434 { |
|
1435 if ( p->data ) |
|
1436 { |
|
1437 if ( p->data->name ) |
|
1438 { |
|
1439 // get application name |
|
1440 HBufC* nameBuf = CnvUtfConverter::ConvertToUnicodeFromUtf8L( p->data->name->Data() ); |
|
1441 task->iUninstallParams->iName.Copy( nameBuf->Des() ); |
|
1442 delete nameBuf; |
|
1443 nameBuf = NULL; |
|
1444 } |
|
1445 if ( p->data->uid ) |
|
1446 { |
|
1447 // parse uid: UID # Type # Size # Version # Vendor # Parent app. name # |
|
1448 // only UID and Vendor are needed from whole uid-field. |
|
1449 LOGGER_WRITE( "CSConPCConnSession::TaskUnInstallL() : start parsing uid " ); |
|
1450 |
|
1451 TPtrC8 buf( p->data->uid->Data() ); |
|
1452 |
|
1453 RArray<TPtrC8> arr(6); |
|
1454 CleanupClosePushL( arr ); |
|
1455 TBuf8<1> separator(KSConAppInfoSeparator); |
|
1456 |
|
1457 SplitL(buf, separator[0], arr); |
|
1458 if ( arr.Count() >= 5 ) |
|
1459 { |
|
1460 task->iUninstallParams->iUid = DesToUid( arr[0] ); |
|
1461 task->iUninstallParams->iType = (TSConAppType)DesToInt( arr[1] ); |
|
1462 HBufC* vendorBuf = CnvUtfConverter::ConvertToUnicodeFromUtf8L( arr[4] ); |
|
1463 task->iUninstallParams->iVendor.Copy( vendorBuf->Des() ); |
|
1464 delete vendorBuf; |
|
1465 vendorBuf = NULL; |
|
1466 } |
|
1467 CleanupStack::PopAndDestroy( &arr ); |
|
1468 |
|
1469 |
|
1470 } // endif p->data->uid |
|
1471 } |
|
1472 } |
|
1473 } |
|
1474 |
|
1475 if ( aContent->instParams) |
|
1476 { |
|
1477 if ( aContent->instParams->param ) |
|
1478 { |
|
1479 for ( ConML_ParamListPtr_t p = aContent->instParams->param; |
|
1480 p && p->data; p = p->next ) |
|
1481 { |
|
1482 LOGGER_WRITE( "CSConPCConnSession::TaskUnInstallL() : Parameters found " ); |
|
1483 if ( p->data->name ) |
|
1484 { |
|
1485 LOGGER_WRITE( "CSConPCConnSession::TaskUnInstallL() : name param found " ); |
|
1486 TPtrC8 silent(KParamNameSilent); |
|
1487 |
|
1488 TInt comp = Mem::Compare((TUint8*)p->data->name->content, (TInt)p->data->name->length, silent.Ptr(), silent.Length()); |
|
1489 if( comp == 0) |
|
1490 { |
|
1491 // "Silent"-param found |
|
1492 LOGGER_WRITE( "CSConPCConnSession::TaskUnInstallL() : Silent-param found " ); |
|
1493 if ( p->data->value ) |
|
1494 { |
|
1495 TPtrC8 dataValue((TUint8*)p->data->value->content, (TInt)p->data->value->length); |
|
1496 TInt value = DesToInt( dataValue ); |
|
1497 if ( value == 1 ) |
|
1498 { |
|
1499 LOGGER_WRITE( "CSConPCConnSession::TaskUnInstallL() : ESilentInstall " ); |
|
1500 task->iUninstallParams->iMode = ESilentInstall; |
|
1501 } |
|
1502 else if ( value == 0 ) |
|
1503 { |
|
1504 LOGGER_WRITE( "CSConPCConnSession::TaskUnInstallL() : EUnsilentInstall " ); |
|
1505 task->iUninstallParams->iMode = EUnsilentInstall; |
|
1506 } |
|
1507 } |
|
1508 } |
|
1509 } |
|
1510 } |
|
1511 } |
|
1512 } |
|
1513 ret = iPCDHandler->PutTaskL( task ); |
|
1514 CleanupStack::Pop( task ); |
|
1515 LOGGER_WRITE_1( "CSConPCConnSession::TaskUnInstallL() : returned %d", ret ); |
|
1516 return ret; |
|
1517 } |
|
1518 |
|
1519 // ----------------------------------------------------------------------------- |
|
1520 // CSConPCConnSession::SplitL(const TDesC& aText, const TChar aSeparator, |
|
1521 // RArray<TPtrC>& aArray) |
|
1522 // Function splits string (eg "name1, name2, name3") into substrings. |
|
1523 // ----------------------------------------------------------------------------- |
|
1524 // |
|
1525 void CSConPCConnSession::SplitL(const TDesC8& aText, const TChar aSeparator, |
|
1526 RArray<TPtrC8>& aArray) |
|
1527 { |
|
1528 TRACE_FUNC_ENTRY; |
|
1529 TPtrC8 ptr; |
|
1530 ptr.Set(aText); |
|
1531 |
|
1532 for (;;) |
|
1533 { |
|
1534 TInt pos=ptr.Locate(aSeparator); |
|
1535 if (pos==KErrNotFound) |
|
1536 { |
|
1537 aArray.AppendL(ptr); |
|
1538 break; |
|
1539 } |
|
1540 |
|
1541 TPtrC8 subStr=ptr.Left(pos); // get pos characters starting from position 0 |
|
1542 aArray.AppendL(subStr); |
|
1543 |
|
1544 if (!(ptr.Length()>pos+1)) |
|
1545 { |
|
1546 break; |
|
1547 } |
|
1548 |
|
1549 ptr.Set(ptr.Mid(pos+1));// get all characters starting from position pos+1 |
|
1550 } |
|
1551 TRACE_FUNC_EXIT; |
|
1552 } |
|
1553 |
|
1554 // ----------------------------------------------------------------------------- |
|
1555 // CSConPCConnSession::TaskListInstalledAppsL() |
|
1556 // Sends a List installed apps -task to PCCS service |
|
1557 // ----------------------------------------------------------------------------- |
|
1558 // |
|
1559 TInt CSConPCConnSession::TaskListInstalledAppsL( |
|
1560 ConML_ListInstalledAppsPtr_t aContent ) |
|
1561 { |
|
1562 TRACE_FUNC_ENTRY; |
|
1563 TInt ret ( KErrNone ); |
|
1564 TSConMethodName method ( EListInstalledApps ); |
|
1565 CSConTask* task = CSConTask::NewLC( method ); |
|
1566 if( aContent-> drives ) |
|
1567 { |
|
1568 task->iListAppsParams->iDriveList = DriveList( aContent->drives->drive); |
|
1569 } |
|
1570 if ( aContent->all ) |
|
1571 { |
|
1572 task->iListAppsParams->iAllApps = ETrue; |
|
1573 } |
|
1574 ret = iPCDHandler->PutTaskL( task ); |
|
1575 CleanupStack::Pop( task ); |
|
1576 LOGGER_WRITE_1( "CSConPCConnSession::TaskListInstalledAppsL() : returned %d", ret); |
|
1577 return ret; |
|
1578 } |
|
1579 |
|
1580 // ----------------------------------------------------------------------------- |
|
1581 // CSConPCConnSession::TaskListDataOwnersL() |
|
1582 // Sends a List data owners -task to PCCS service |
|
1583 // ----------------------------------------------------------------------------- |
|
1584 // |
|
1585 TInt CSConPCConnSession::TaskListDataOwnersL() |
|
1586 { |
|
1587 TRACE_FUNC_ENTRY; |
|
1588 TInt ret ( KErrNone ); |
|
1589 TSConMethodName method ( EListDataOwners ); |
|
1590 CSConTask* task = CSConTask::NewLC( method ); |
|
1591 ret = iPCDHandler->PutTaskL( task ); |
|
1592 CleanupStack::Pop( task ); |
|
1593 LOGGER_WRITE_1( "CSConPCConnSession::TaskListDataOwnersL() : returned %d", ret ); |
|
1594 return ret; |
|
1595 } |
|
1596 |
|
1597 // ----------------------------------------------------------------------------- |
|
1598 // CSConPCConnSession::TaskSetBURModeL() |
|
1599 // Sends a Set BUR mode -task to PCCS service |
|
1600 // ----------------------------------------------------------------------------- |
|
1601 // |
|
1602 TInt CSConPCConnSession::TaskSetBURModeL(ConML_SetBURModePtr_t aContent ) |
|
1603 { |
|
1604 TRACE_FUNC_ENTRY; |
|
1605 TInt ret ( KErrNone ); |
|
1606 TSConMethodName method ( ESetBURMode ); |
|
1607 CSConTask* task = CSConTask::NewLC( method ); |
|
1608 if ( aContent->drives ) |
|
1609 { |
|
1610 task->iBURModeParams->iDriveList = DriveList( aContent->drives->drive); |
|
1611 } |
|
1612 if ( aContent->partialType ) |
|
1613 { |
|
1614 TInt intValue = DesToInt( aContent->partialType->Data() ); |
|
1615 task->iBURModeParams->iPartialType = static_cast<TSConBurMode> (intValue) ; |
|
1616 } |
|
1617 if ( aContent->incType ) |
|
1618 { |
|
1619 TInt intValue = DesToInt( aContent->incType->Data() ); |
|
1620 task->iBURModeParams->iIncType = static_cast<TSConIncType> (intValue) ; |
|
1621 } |
|
1622 ret = iPCDHandler->PutTaskL( task ); |
|
1623 CleanupStack::Pop( task ); |
|
1624 LOGGER_WRITE_1( "CSConPCConnSession::TaskSetBURModeL() : returned %d", ret ); |
|
1625 return ret; |
|
1626 } |
|
1627 |
|
1628 // ----------------------------------------------------------------------------- |
|
1629 // CSConPCConnSession::TaskGetDataSizeL() |
|
1630 // Sends a Get data size -task to PCCS service |
|
1631 // ----------------------------------------------------------------------------- |
|
1632 // |
|
1633 TInt CSConPCConnSession::TaskGetDataSizeL(ConML_GetDataSizePtr_t aContent ) |
|
1634 { |
|
1635 TRACE_FUNC_ENTRY; |
|
1636 TInt ret ( KErrNone ); |
|
1637 TSConMethodName method ( EGetDataSize ); |
|
1638 CSConTask* task = CSConTask::NewLC( method ); |
|
1639 if ( aContent->dataOwners ) |
|
1640 { |
|
1641 for ( ConML_SIDListPtr_t p = aContent->dataOwners->sid; |
|
1642 p && p->data; p=p->next ) |
|
1643 { |
|
1644 CSConDataOwner* dataOwner = new (ELeave) CSConDataOwner(); |
|
1645 CleanupStack::PushL( dataOwner ); |
|
1646 if ( p->data->type ) |
|
1647 { |
|
1648 dataOwner->iType = TSConDOType (DesToInt( |
|
1649 p->data->type->Data() )); |
|
1650 } |
|
1651 if (p->data->uid ) |
|
1652 { |
|
1653 if( !IsJavaHash( p->data->uid->Data() ) ) |
|
1654 { |
|
1655 dataOwner->iUid = DesToUid( p->data->uid->Data() ); |
|
1656 } |
|
1657 else |
|
1658 { |
|
1659 TPtr hashPtr = DesToHashLC( p->data->uid->Data() ); |
|
1660 dataOwner->iJavaHash = HBufC::NewL( hashPtr.Size() ); |
|
1661 dataOwner->iJavaHash->Des().Copy( hashPtr ); |
|
1662 CleanupStack::PopAndDestroy(); //DesToHashLC() |
|
1663 } |
|
1664 } |
|
1665 if ( p->data->drives ) |
|
1666 { |
|
1667 dataOwner->iDriveList = DriveList ( p->data->drives->drive ); |
|
1668 } |
|
1669 if ( p->data->transferDataType ) |
|
1670 { |
|
1671 TInt intValue = DesToInt( p->data->transferDataType->Data() ); |
|
1672 dataOwner->iTransDataType = static_cast<TSConTransferDataType> (intValue); |
|
1673 } |
|
1674 task->iGetDataSizeParams->iDataOwners.AppendL( dataOwner ); |
|
1675 CleanupStack::Pop( dataOwner ); |
|
1676 } |
|
1677 } |
|
1678 ret = iPCDHandler->PutTaskL( task ); |
|
1679 CleanupStack::Pop( task ); |
|
1680 LOGGER_WRITE_1( "CSConPCConnSession::TaskGetDataSizeL() : returned %d", ret ); |
|
1681 return ret; |
|
1682 } |
|
1683 |
|
1684 // ----------------------------------------------------------------------------- |
|
1685 // CSConPCConnSession::TaskRequestDataL() |
|
1686 // Sends a Request data -task to PCCS service |
|
1687 // ----------------------------------------------------------------------------- |
|
1688 // |
|
1689 TInt CSConPCConnSession::TaskRequestDataL(ConML_RequestDataPtr_t aContent ) |
|
1690 { |
|
1691 TRACE_FUNC_ENTRY; |
|
1692 TInt ret ( KErrNone ); |
|
1693 TSConMethodName method ( ERequestData ); |
|
1694 CSConTask* task = CSConTask::NewLC( method ); |
|
1695 if ( aContent ) |
|
1696 { |
|
1697 if ( aContent->sid ) |
|
1698 { |
|
1699 for ( ConML_SIDListPtr_t p=aContent->sid; p && p->data; p=p->next ) |
|
1700 { |
|
1701 if ( p->data->type ) |
|
1702 { |
|
1703 task->iRequestDataParams->iDataOwner->iType = |
|
1704 TSConDOType ( DesToInt ( p->data->type->Data() ) ); |
|
1705 } |
|
1706 if ( p->data->uid ) |
|
1707 { |
|
1708 if( !IsJavaHash( p->data->uid->Data() ) ) |
|
1709 { |
|
1710 task->iRequestDataParams->iDataOwner->iUid = DesToUid( |
|
1711 p->data->uid->Data() ); |
|
1712 } |
|
1713 else |
|
1714 { |
|
1715 TPtr hashPtr = DesToHashLC( p->data->uid->Data() ); |
|
1716 task->iRequestDataParams->iDataOwner->iJavaHash = HBufC::NewL( hashPtr.Size() ); |
|
1717 task->iRequestDataParams->iDataOwner->iJavaHash->Des().Copy( hashPtr ); |
|
1718 CleanupStack::PopAndDestroy(); //DesToHashLC() |
|
1719 } |
|
1720 } |
|
1721 if ( p->data->drives ) |
|
1722 { |
|
1723 task->iRequestDataParams->iDataOwner->iDriveList = |
|
1724 DriveList ( p->data->drives->drive ); |
|
1725 } |
|
1726 if ( p->data->transferDataType ) |
|
1727 { |
|
1728 TInt intValue = DesToInt( p->data->transferDataType->Data() ); |
|
1729 task->iRequestDataParams->iDataOwner->iTransDataType = |
|
1730 static_cast<TSConTransferDataType> (intValue); |
|
1731 } |
|
1732 } |
|
1733 } |
|
1734 } |
|
1735 ret = iPCDHandler->PutTaskL( task ); |
|
1736 CleanupStack::Pop( task ); |
|
1737 LOGGER_WRITE_1( "CSConPCConnSession::TaskRequestDataL() : returned %d", ret ); |
|
1738 return ret; |
|
1739 } |
|
1740 |
|
1741 // ----------------------------------------------------------------------------- |
|
1742 // CSConPCConnSession::TaskUpdateDeviceInfoL() |
|
1743 // Sends a Update device info -task to PCCS service |
|
1744 // ----------------------------------------------------------------------------- |
|
1745 // |
|
1746 TInt CSConPCConnSession::TaskUpdateDeviceInfoL( |
|
1747 ConML_UpdateDeviceInfoPtr_t aContent ) |
|
1748 { |
|
1749 TRACE_FUNC_ENTRY; |
|
1750 TInt ret ( KErrNone ); |
|
1751 TSConMethodName method ( EUpdateDeviceInfo ); |
|
1752 CSConTask* task = CSConTask::NewLC( method ); |
|
1753 |
|
1754 if ( aContent->deviceInfo) |
|
1755 { |
|
1756 ConML_DeviceInfoPtr_t dPtr = aContent->deviceInfo; |
|
1757 if ( dPtr->version ) |
|
1758 { |
|
1759 task->iDevInfoParams->iVersion.Copy( dPtr->version->Data()); |
|
1760 } |
|
1761 if ( dPtr->maxObjectSize ) |
|
1762 { |
|
1763 task->iDevInfoParams->iMaxObjectSize = DesToInt( |
|
1764 dPtr->maxObjectSize->Data()); |
|
1765 } |
|
1766 if ( dPtr->supportedMethods ) |
|
1767 { |
|
1768 ConML_SupportedMethodsPtr_t smPtr = dPtr->supportedMethods; |
|
1769 if ( smPtr->install ) |
|
1770 { |
|
1771 task->iDevInfoParams->iInstallSupp = ETrue; |
|
1772 } |
|
1773 if ( smPtr->unInstall ) |
|
1774 { |
|
1775 task->iDevInfoParams->iUninstallSupp = ETrue; |
|
1776 } |
|
1777 if ( smPtr->listInstalledApps ) |
|
1778 { |
|
1779 task->iDevInfoParams->iInstAppsSupp = ETrue; |
|
1780 } |
|
1781 if ( smPtr->listDataOwners ) |
|
1782 { |
|
1783 task->iDevInfoParams->iDataOwnersSupp = ETrue; |
|
1784 } |
|
1785 if ( smPtr->setBurMode ) |
|
1786 { |
|
1787 task->iDevInfoParams->iSetBURModeSupp = ETrue; |
|
1788 } |
|
1789 if ( smPtr->getDataSize ) |
|
1790 { |
|
1791 task->iDevInfoParams->iGetSizeSupp = ETrue; |
|
1792 } |
|
1793 if ( smPtr->requestData ) |
|
1794 { |
|
1795 task->iDevInfoParams->iReqDataSupp = ETrue; |
|
1796 } |
|
1797 if ( smPtr->supplyData ) |
|
1798 { |
|
1799 task->iDevInfoParams->iSupplyDataSupp = ETrue; |
|
1800 } |
|
1801 if ( smPtr->reboot ) |
|
1802 { |
|
1803 task->iDevInfoParams->iRebootSupp = ETrue; |
|
1804 } |
|
1805 } |
|
1806 } |
|
1807 ret = iPCDHandler->PutTaskL( task ); |
|
1808 CleanupStack::Pop( task ); |
|
1809 LOGGER_WRITE_1( "CSConPCConnSession::TaskUpdateDeviceInfoL() : returned %d", ret ); |
|
1810 return ret; |
|
1811 } |
|
1812 |
|
1813 // ----------------------------------------------------------------------------- |
|
1814 // CSConPCConnSession::TaskListPublicFilesL() |
|
1815 // Sends a List public files -task to PCCS service |
|
1816 // ----------------------------------------------------------------------------- |
|
1817 // |
|
1818 TInt CSConPCConnSession::TaskListPublicFilesL( |
|
1819 ConML_ListPublicFilesPtr_t aContent ) |
|
1820 { |
|
1821 TRACE_FUNC_ENTRY; |
|
1822 TInt ret ( KErrNone ); |
|
1823 TSConMethodName method ( EListPublicFiles ); |
|
1824 CSConTask* task = CSConTask::NewLC( method ); |
|
1825 if ( aContent->sid ) |
|
1826 { |
|
1827 for ( ConML_SIDListPtr_t p = aContent->sid; p && p->data; p = p->next ) |
|
1828 { |
|
1829 CSConDataOwner* dataOwner = new (ELeave) CSConDataOwner(); |
|
1830 CleanupStack::PushL( dataOwner ); |
|
1831 if ( p->data->type ) |
|
1832 { |
|
1833 dataOwner->iType = TSConDOType ( DesToInt( |
|
1834 p->data->type->Data() ) ); |
|
1835 } |
|
1836 if ( p->data->uid ) |
|
1837 { |
|
1838 if( !IsJavaHash( p->data->uid->Data() ) ) |
|
1839 { |
|
1840 dataOwner->iUid = DesToUid( p->data->uid->Data() ); |
|
1841 } |
|
1842 else |
|
1843 { |
|
1844 TPtr hashPtr = DesToHashLC( p->data->uid->Data() ); |
|
1845 dataOwner->iJavaHash = HBufC::NewL( hashPtr.Size() ); |
|
1846 dataOwner->iJavaHash->Des().Copy( hashPtr ); |
|
1847 CleanupStack::PopAndDestroy(); //DesToHashLC() |
|
1848 } |
|
1849 } |
|
1850 if ( p->data->drives ) |
|
1851 { |
|
1852 dataOwner->iDriveList = DriveList ( p->data->drives->drive ); |
|
1853 } |
|
1854 if ( p->data->packageInfo && p->data->packageInfo->name ) |
|
1855 { |
|
1856 // Unicode conversion from 8-bit to 16-bit |
|
1857 CnvUtfConverter::ConvertToUnicodeFromUtf8( |
|
1858 dataOwner->iPackageName, |
|
1859 p->data->packageInfo->name->Data()); |
|
1860 } |
|
1861 task->iPubFilesParams->iDataOwners.AppendL( dataOwner ); |
|
1862 CleanupStack::Pop( dataOwner ); |
|
1863 } |
|
1864 } |
|
1865 ret = iPCDHandler->PutTaskL( task ); |
|
1866 CleanupStack::Pop( task ); |
|
1867 LOGGER_WRITE_1( "CSConPCConnSession::TaskListPublicFilesL() : returned %d", ret ); |
|
1868 return ret; |
|
1869 } |
|
1870 |
|
1871 // ----------------------------------------------------------------------------- |
|
1872 // CSConPCConnSession::TaskSupplyDataL() |
|
1873 // Sends a Supply data -task to PCCS service |
|
1874 // ----------------------------------------------------------------------------- |
|
1875 // |
|
1876 TInt CSConPCConnSession::TaskSupplyDataL ( ConML_SupplyDataPtr_t aContent ) |
|
1877 { |
|
1878 TRACE_FUNC_ENTRY; |
|
1879 TInt ret ( KErrNone ); |
|
1880 TSConMethodName method ( ESupplyData ); |
|
1881 CSConTask* task = CSConTask::NewLC( method ); |
|
1882 if (aContent ) |
|
1883 { |
|
1884 for ( ConML_SIDListPtr_t p = aContent->sid; p && p->data; p = p->next ) |
|
1885 { |
|
1886 if ( p->data->type ) |
|
1887 { |
|
1888 task->iSupplyDataParams->iDataOwner->iType = |
|
1889 TSConDOType ( DesToInt( p->data->type->Data() ) ); |
|
1890 } |
|
1891 if ( p->data->uid ) |
|
1892 { |
|
1893 if( !IsJavaHash( p->data->uid->Data() ) ) |
|
1894 { |
|
1895 task->iSupplyDataParams->iDataOwner->iUid = DesToUid( |
|
1896 p->data->uid->Data() ); |
|
1897 } |
|
1898 else |
|
1899 { |
|
1900 TPtr hashPtr = DesToHashLC( p->data->uid->Data() ); |
|
1901 task->iSupplyDataParams->iDataOwner->iJavaHash = HBufC::NewL( hashPtr.Size() ); |
|
1902 task->iSupplyDataParams->iDataOwner->iJavaHash->Des().Copy( hashPtr ); |
|
1903 CleanupStack::PopAndDestroy(); //DesToHashLC() |
|
1904 } |
|
1905 } |
|
1906 if ( p->data->drives ) |
|
1907 { |
|
1908 task->iSupplyDataParams->iDataOwner->iDriveList = |
|
1909 DriveList ( p->data->drives->drive ); |
|
1910 } |
|
1911 if ( p->data->transferDataType ) |
|
1912 { |
|
1913 TInt intValue = DesToInt ( p->data->transferDataType->Data() ); |
|
1914 task->iSupplyDataParams->iDataOwner->iTransDataType = |
|
1915 static_cast<TSConTransferDataType> (intValue); |
|
1916 } |
|
1917 if ( p->data->data ) |
|
1918 { |
|
1919 task->iSupplyDataParams->iRestoreData = HBufC8::NewL( |
|
1920 p->data->data->Data().Size() ); |
|
1921 *task->iSupplyDataParams->iRestoreData = p->data->data->Data(); |
|
1922 } |
|
1923 if ( p->data->moreData ) |
|
1924 { |
|
1925 task->iSupplyDataParams->iMoreData = ETrue; |
|
1926 } |
|
1927 else |
|
1928 { |
|
1929 task->iSupplyDataParams->iMoreData = EFalse; |
|
1930 } |
|
1931 } |
|
1932 } |
|
1933 ret = iPCDHandler->PutTaskL( task ); |
|
1934 CleanupStack::Pop( task ); |
|
1935 LOGGER_WRITE_1( "CSConPCConnSession::TaskSupplyDataL() : returned %d", ret ); |
|
1936 return ret; |
|
1937 } |
|
1938 |
|
1939 // ----------------------------------------------------------------------------- |
|
1940 // CSConPCConnSession::TaskGetDataOwnerStatusL() |
|
1941 // Sends a Get data owner status -task to PCCS service |
|
1942 // ----------------------------------------------------------------------------- |
|
1943 // |
|
1944 TInt CSConPCConnSession::TaskGetDataOwnerStatusL |
|
1945 ( ConML_GetDataOwnerStatusPtr_t aContent ) |
|
1946 { |
|
1947 TRACE_FUNC_ENTRY; |
|
1948 TInt ret ( KErrNone ); |
|
1949 TSConMethodName method ( EGetDataOwnerStatus ); |
|
1950 CSConTask* task = CSConTask::NewLC( method ); |
|
1951 |
|
1952 if ( aContent->dataOwners ) |
|
1953 { |
|
1954 for ( ConML_SIDListPtr_t p = aContent->dataOwners->sid; |
|
1955 p && p->data; p=p->next ) |
|
1956 { |
|
1957 CSConDataOwner* dataOwner = new (ELeave) CSConDataOwner(); |
|
1958 CleanupStack::PushL( dataOwner ); |
|
1959 if ( p->data->type ) |
|
1960 { |
|
1961 dataOwner->iType = TSConDOType (DesToInt( |
|
1962 p->data->type->Data() )); |
|
1963 } |
|
1964 if ( p->data->uid ) |
|
1965 { |
|
1966 if( !IsJavaHash( p->data->uid->Data() ) ) |
|
1967 { |
|
1968 dataOwner->iUid = DesToUid( p->data->uid->Data() ); |
|
1969 } |
|
1970 else |
|
1971 { |
|
1972 TPtr hashPtr = DesToHashLC( p->data->uid->Data() ); |
|
1973 dataOwner->iJavaHash = HBufC::NewL( hashPtr.Size() ); |
|
1974 dataOwner->iJavaHash->Des().Copy( hashPtr ); |
|
1975 CleanupStack::PopAndDestroy(); //DesToHashLC() |
|
1976 } |
|
1977 } |
|
1978 task->iGetDataOwnerParams->iDataOwners.AppendL( dataOwner ); |
|
1979 CleanupStack::Pop( dataOwner ); |
|
1980 } |
|
1981 } |
|
1982 ret = iPCDHandler->PutTaskL( task ); |
|
1983 CleanupStack::Pop( task ); |
|
1984 LOGGER_WRITE_1( "CSConPCConnSession::TaskGetDataOwnerStatusL() : returned %d", ret ); |
|
1985 return ret; |
|
1986 } |
|
1987 |
|
1988 // ----------------------------------------------------------------------------- |
|
1989 // CSConPCConnSession::TaskRebootL() |
|
1990 // Sends a Reboot -task to PCCS service |
|
1991 // ----------------------------------------------------------------------------- |
|
1992 // |
|
1993 TInt CSConPCConnSession::TaskRebootL( ) |
|
1994 { |
|
1995 TRACE_FUNC_ENTRY; |
|
1996 TInt ret ( KErrNone ); |
|
1997 TSConMethodName method ( EReboot ); |
|
1998 CSConTask* task = CSConTask::NewLC( method ); |
|
1999 ret = iPCDHandler->PutTaskL( task ); |
|
2000 CleanupStack::Pop( task ); |
|
2001 LOGGER_WRITE_1( "CSConPCConnSession::TaskRebootL() : returned %d", ret ); |
|
2002 return ret; |
|
2003 } |
|
2004 |
|
2005 // ----------------------------------------------------------------------------- |
|
2006 // CSConPCConnSession::TaskGetMetadataL() |
|
2007 // Sends a GetMetadata -task to PCCS service |
|
2008 // ----------------------------------------------------------------------------- |
|
2009 // |
|
2010 TInt CSConPCConnSession::TaskGetMetadataL( ConML_GetMetadataPtr_t aContent ) |
|
2011 { |
|
2012 TRACE_FUNC_ENTRY; |
|
2013 TInt ret ( KErrNone ); |
|
2014 TSConMethodName method ( EGetMetadata ); |
|
2015 CSConTask* task = CSConTask::NewLC( method ); |
|
2016 if( aContent ) |
|
2017 { |
|
2018 if ( aContent->filename ) |
|
2019 { |
|
2020 // Unicode conversion from 8-bit to 16-bit |
|
2021 CnvUtfConverter::ConvertToUnicodeFromUtf8(task->iGetMetadataParams->iFilename, |
|
2022 aContent->filename->Data()); |
|
2023 } |
|
2024 } |
|
2025 ret = iPCDHandler->PutTaskL( task ); |
|
2026 CleanupStack::Pop( task ); |
|
2027 LOGGER_WRITE_1( "CSConPCConnSession::TaskGetMetadataL() : returned %d", ret ); |
|
2028 return ret; |
|
2029 } |
|
2030 |
|
2031 // ----------------------------------------------------------------------------- |
|
2032 // CSConPCConnSession::TaskRebootL() |
|
2033 // Appends a status element from the reply data of PCCS |
|
2034 // ----------------------------------------------------------------------------- |
|
2035 // |
|
2036 void CSConPCConnSession::AppendStatusL( |
|
2037 ConML_ConMLPtr_t aContent, CSConStatusReply* reply ) |
|
2038 { |
|
2039 TRACE_FUNC_ENTRY; |
|
2040 |
|
2041 if ( !reply ) |
|
2042 { |
|
2043 LOGGER_WRITE( "CSConPCConnSession::AppendStatus() : No data in reply!" ); |
|
2044 return; |
|
2045 } |
|
2046 aContent->status = new ( ELeave ) ConML_Status_t(); |
|
2047 |
|
2048 if ( reply->iTasks.Count() > 0 ) |
|
2049 { |
|
2050 for ( TInt i=0; i < reply->iTasks.Count(); i ++) |
|
2051 { |
|
2052 ConML_TaskListPtr_t task = new ( ELeave ) ConML_TaskList_t(); |
|
2053 CleanupStack::PushL( task ); |
|
2054 GenericListAddL ( &aContent->status->task, task ); |
|
2055 CleanupStack::Pop(); // task |
|
2056 |
|
2057 task->data = new ( ELeave ) ConML_Task_t(); |
|
2058 task->data->id = new ( ELeave ) pcdata_t(); |
|
2059 task->data->id->SetDataL ( IntToDesLC(reply->iTasks[i]->iTaskId) ); |
|
2060 CleanupStack::PopAndDestroy(); // IntToDesLC |
|
2061 TSConMethodName method ( reply->iTasks[i]->iMethod ); |
|
2062 |
|
2063 switch ( method ) |
|
2064 { |
|
2065 case EUpdateDeviceInfo: |
|
2066 task->data->updateDeviceInfo = |
|
2067 new ( ELeave ) ConML_UpdateDeviceInfo_t(); |
|
2068 task->data->updateDeviceInfo->results = |
|
2069 new ( ELeave ) ConML_Results_t(); |
|
2070 AppendUpdateDeviceInfoResultsL( |
|
2071 task->data->updateDeviceInfo->results, |
|
2072 reply->iTasks[i]->iDevInfoParams ); |
|
2073 break; |
|
2074 |
|
2075 case ESetBURMode: |
|
2076 task->data->setBurMode = |
|
2077 new ( ELeave ) ConML_SetBURMode_t(); |
|
2078 task->data->setBurMode->results = |
|
2079 new ( ELeave) ConML_Results_t(); |
|
2080 AppendSetBURModeResultsL( |
|
2081 task->data->setBurMode->results, |
|
2082 reply->iTasks[i]->iBURModeParams ); |
|
2083 break; |
|
2084 |
|
2085 case EListInstalledApps: |
|
2086 task->data->listInstalledApps = |
|
2087 new ( ELeave ) ConML_ListInstalledApps_t(); |
|
2088 task->data->listInstalledApps->results = |
|
2089 new ( ELeave ) ConML_Results_t(); |
|
2090 AppendListInstalledAppsResultsL( |
|
2091 task->data->listInstalledApps->results, |
|
2092 reply->iTasks[i]->iListAppsParams); |
|
2093 break; |
|
2094 |
|
2095 case EInstall: |
|
2096 task->data->install = new ( ELeave ) ConML_Install_t(); |
|
2097 task->data->install->results = |
|
2098 new ( ELeave ) ConML_Results_t(); |
|
2099 AppendInstallResultsL( |
|
2100 task->data->install->results, |
|
2101 reply->iTasks[i]->iInstallParams ); |
|
2102 break; |
|
2103 |
|
2104 case EUninstall: |
|
2105 task->data->unInstall = new ( ELeave ) ConML_UnInstall_t(); |
|
2106 task->data->unInstall->results = |
|
2107 new ( ELeave ) ConML_Results_t(); |
|
2108 AppendUninstallResultsL( |
|
2109 task->data->unInstall->results, |
|
2110 reply->iTasks[i]->iUninstallParams ); |
|
2111 break; |
|
2112 |
|
2113 case EListDataOwners: |
|
2114 task->data->listDataOwners = |
|
2115 new ( ELeave ) ConML_ListDataOwners_t(); |
|
2116 task->data->listDataOwners->results = |
|
2117 new ( ELeave ) ConML_Results_t(); |
|
2118 AppendListDataOwnersResultsL( |
|
2119 task->data->listDataOwners->results, |
|
2120 reply->iTasks[i]->iListDataOwnersParams ); |
|
2121 break; |
|
2122 |
|
2123 case EGetDataOwnerStatus: |
|
2124 task->data->getDataOwnerStatus = |
|
2125 new ( ELeave ) ConML_GetDataOwnerStatus_t(); |
|
2126 task->data->getDataOwnerStatus->results = |
|
2127 new ( ELeave ) ConML_Results_t(); |
|
2128 AppendGetDataOwnerStatusResultsL( |
|
2129 task->data->getDataOwnerStatus->results, |
|
2130 reply->iTasks[i]->iGetDataOwnerParams); |
|
2131 break; |
|
2132 |
|
2133 case EGetDataSize: |
|
2134 task->data->getDataSize = |
|
2135 new ( ELeave ) ConML_GetDataSize_t(); |
|
2136 task->data->getDataSize->results = |
|
2137 new ( ELeave ) ConML_Results_t(); |
|
2138 AppendGetDataSizeResultsL( |
|
2139 task->data->getDataSize->results, |
|
2140 reply->iTasks[i]->iGetDataSizeParams ); |
|
2141 break; |
|
2142 |
|
2143 case EListPublicFiles: |
|
2144 task->data->listPublicFiles = |
|
2145 new ( ELeave ) ConML_ListPublicFiles_t(); |
|
2146 task->data->listPublicFiles->results = |
|
2147 new ( ELeave ) ConML_Results_t(); |
|
2148 AppendListPublicFilesResultsL ( |
|
2149 task->data->listPublicFiles->results, |
|
2150 reply->iTasks[i]->iPubFilesParams ); |
|
2151 break; |
|
2152 |
|
2153 case ERequestData: |
|
2154 task->data->requestData = |
|
2155 new ( ELeave ) ConML_RequestData_t(); |
|
2156 task->data->requestData->results = |
|
2157 new ( ELeave ) ConML_Results_t(); |
|
2158 AppendRequestDataResultsL( |
|
2159 task->data->requestData->results, |
|
2160 reply->iTasks[i]->iRequestDataParams ); |
|
2161 break; |
|
2162 |
|
2163 case ESupplyData: |
|
2164 task->data->supplyData = |
|
2165 new ( ELeave ) ConML_SupplyData_t(); |
|
2166 task->data->supplyData->results = |
|
2167 new ( ELeave ) ConML_Results_t(); |
|
2168 AppendSupplyDataResultsL ( |
|
2169 task->data->supplyData->results, |
|
2170 reply->iTasks[i]->iSupplyDataParams ); |
|
2171 break; |
|
2172 |
|
2173 case EGetMetadata: |
|
2174 task->data->getMetadata = |
|
2175 new ( ELeave ) ConML_GetMetadata_t(); |
|
2176 task->data->getMetadata->results = |
|
2177 new ( ELeave ) ConML_Results_t(); |
|
2178 AppendGetMetadataResultsL ( |
|
2179 task->data->getMetadata->results, |
|
2180 reply->iTasks[i]->iGetMetadataParams ); |
|
2181 break; |
|
2182 |
|
2183 default: |
|
2184 LOGGER_WRITE_1( "CSConPCConnSession:: AppendStatus() : Unknown method %d ", method ); |
|
2185 break; |
|
2186 } |
|
2187 } |
|
2188 } |
|
2189 else |
|
2190 { |
|
2191 LOGGER_WRITE( "CSConPCConnSession::AppendStatus() : No Task " ); |
|
2192 } |
|
2193 TRACE_FUNC_EXIT; |
|
2194 } |
|
2195 |
|
2196 // ----------------------------------------------------------------------------- |
|
2197 // CSConPCConnSession::AppendUpdateDeviceInfoResultsL() |
|
2198 // Appends a update device info -element from the reply data of PCCS |
|
2199 // ----------------------------------------------------------------------------- |
|
2200 // |
|
2201 void CSConPCConnSession::AppendUpdateDeviceInfoResultsL |
|
2202 ( ConML_ResultsPtr_t aContent, CSConUpdateDeviceInfo* aResult ) |
|
2203 { |
|
2204 TRACE_FUNC_ENTRY; |
|
2205 if ( aResult ) |
|
2206 { |
|
2207 if ( aResult->iComplete ) |
|
2208 { |
|
2209 aContent->complete = new ( ELeave ) pcdata_t(); |
|
2210 } |
|
2211 AppendProgressL ( aContent, aResult->iProgress ); |
|
2212 |
|
2213 aContent->deviceInfo = new ( ELeave ) ConML_DeviceInfo_t(); |
|
2214 aContent->deviceInfo->version = new ( ELeave ) pcdata_t(); |
|
2215 aContent->deviceInfo->version->SetDataL ( aResult->iVersion ); |
|
2216 |
|
2217 aContent->deviceInfo->supportedMethods = |
|
2218 new ( ELeave ) ConML_SupportedMethods_t(); |
|
2219 |
|
2220 if ( aResult->iInstallSupp ) |
|
2221 { |
|
2222 aContent->deviceInfo->supportedMethods->install = |
|
2223 new ( ELeave ) pcdata_t(); |
|
2224 } |
|
2225 if ( aResult->iUninstallSupp ) |
|
2226 { |
|
2227 aContent->deviceInfo->supportedMethods->unInstall = |
|
2228 new ( ELeave ) pcdata_t(); |
|
2229 } |
|
2230 if ( aResult->iInstAppsSupp ) |
|
2231 { |
|
2232 aContent->deviceInfo->supportedMethods->listInstalledApps = |
|
2233 new ( ELeave ) pcdata_t(); |
|
2234 } |
|
2235 if ( aResult->iDataOwnersSupp ) |
|
2236 { |
|
2237 aContent->deviceInfo->supportedMethods->listDataOwners = |
|
2238 new ( ELeave ) pcdata_t(); |
|
2239 } |
|
2240 if ( aResult->iSetBURModeSupp ) |
|
2241 { |
|
2242 aContent->deviceInfo->supportedMethods->setBurMode = |
|
2243 new ( ELeave ) pcdata_t(); |
|
2244 } |
|
2245 if ( aResult->iGetSizeSupp ) |
|
2246 { |
|
2247 aContent->deviceInfo->supportedMethods->getDataSize = |
|
2248 new ( ELeave ) pcdata_t(); |
|
2249 } |
|
2250 if ( aResult->iReqDataSupp ) |
|
2251 { |
|
2252 aContent->deviceInfo->supportedMethods->requestData = |
|
2253 new (ELeave ) pcdata_t(); |
|
2254 } |
|
2255 if ( aResult->iSupplyDataSupp ) |
|
2256 { |
|
2257 aContent->deviceInfo->supportedMethods->supplyData = |
|
2258 new ( ELeave ) pcdata_t(); |
|
2259 } |
|
2260 if ( aResult->iRebootSupp ) |
|
2261 { |
|
2262 aContent->deviceInfo->supportedMethods->reboot = |
|
2263 new ( ELeave ) pcdata_t(); |
|
2264 } |
|
2265 aContent->deviceInfo->maxObjectSize = new ( ELeave ) pcdata_t(); |
|
2266 aContent->deviceInfo->maxObjectSize->SetDataL ( IntToDesLC( |
|
2267 aResult->iMaxObjectSize )); |
|
2268 CleanupStack::PopAndDestroy(); // IntToDesLC |
|
2269 } |
|
2270 TRACE_FUNC_EXIT; |
|
2271 } |
|
2272 |
|
2273 // ----------------------------------------------------------------------------- |
|
2274 // CSConPCConnSession::AppendSetBURModeResultsL() |
|
2275 // Appends a Set BUR mode -element from the reply data of PCCS |
|
2276 // ----------------------------------------------------------------------------- |
|
2277 // |
|
2278 void CSConPCConnSession::AppendSetBURModeResultsL ( |
|
2279 ConML_ResultsPtr_t aContent, CSConSetBURMode* aResult ) |
|
2280 { |
|
2281 TRACE_FUNC_ENTRY; |
|
2282 if ( aResult ) |
|
2283 { |
|
2284 if ( aResult->iComplete ) |
|
2285 { |
|
2286 aContent->complete = new ( ELeave ) pcdata_t(); |
|
2287 } |
|
2288 AppendProgressL ( aContent, aResult->iProgress ); |
|
2289 } |
|
2290 TRACE_FUNC_EXIT; |
|
2291 } |
|
2292 |
|
2293 // ----------------------------------------------------------------------------- |
|
2294 // CSConPCConnSession::AppendListInstalledAppsResultsL() |
|
2295 // Appends a List installed apps -element from the reply data of PCCS |
|
2296 // ----------------------------------------------------------------------------- |
|
2297 // |
|
2298 void CSConPCConnSession::AppendListInstalledAppsResultsL ( |
|
2299 ConML_ResultsPtr_t aContent, CSConListInstApps* aResult ) |
|
2300 { |
|
2301 TRACE_FUNC_ENTRY; |
|
2302 |
|
2303 if ( aResult ) |
|
2304 { |
|
2305 if ( aResult->iComplete ) |
|
2306 { |
|
2307 aContent->complete = new ( ELeave ) pcdata_t(); |
|
2308 } |
|
2309 AppendProgressL ( aContent, aResult->iProgress ); |
|
2310 |
|
2311 if ( aResult->iApps.Count() > 0 ) |
|
2312 { |
|
2313 // 6 * KMaxFileName should be enought |
|
2314 // ( 5 items of TFileName and uid + type + size + 7* "#" ) |
|
2315 HBufC8* buf = HBufC8::NewLC( 6 * KMaxFileName ); |
|
2316 TPtr8 ptrBuf = buf->Des(); |
|
2317 |
|
2318 aContent->applications = new ( ELeave ) ConML_Applications_t(); |
|
2319 for ( TInt i=0; i<aResult->iApps.Count(); i++) |
|
2320 { |
|
2321 ConML_ApplicationListPtr_t app = |
|
2322 new ( ELeave )ConML_ApplicationList_t(); |
|
2323 CleanupStack::PushL ( app ); |
|
2324 GenericListAddL ( &aContent->applications->application, app ); |
|
2325 CleanupStack::Pop(); // app |
|
2326 |
|
2327 app->data = new ( ELeave ) ConML_Application_t(); |
|
2328 app->data->name = new ( ELeave ) pcdata_t(); |
|
2329 app->data->name->SetDataL( BufToDesLC( |
|
2330 aResult->iApps[i]->iName)); |
|
2331 CleanupStack::PopAndDestroy(); // BufToDesLC |
|
2332 |
|
2333 // create uid: UID # Type # Size # Version # Vendor # Parent app. name # WidgetBundleId # |
|
2334 LOGGER_WRITE( "CSConPCConnSession::AppendListInstalledAppsResultsL() : Create Uid" ); |
|
2335 |
|
2336 ptrBuf.Copy( UidToDesLC( aResult->iApps[i]->iUid ) ); |
|
2337 CleanupStack::PopAndDestroy(); // UidToDesLC |
|
2338 |
|
2339 ptrBuf.Append( KSConAppInfoSeparator ); |
|
2340 |
|
2341 ptrBuf.Append( IntToDesLC(aResult->iApps[i]->iType )); |
|
2342 CleanupStack::PopAndDestroy(); // IntToDesLC |
|
2343 |
|
2344 ptrBuf.Append( KSConAppInfoSeparator ); |
|
2345 |
|
2346 ptrBuf.Append( IntToDesLC(aResult->iApps[i]->iSize ) ); |
|
2347 CleanupStack::PopAndDestroy(); // IntToDesLC |
|
2348 |
|
2349 ptrBuf.Append( KSConAppInfoSeparator ); |
|
2350 ptrBuf.Append( aResult->iApps[i]->iVersion ); |
|
2351 |
|
2352 ptrBuf.Append( KSConAppInfoSeparator ); |
|
2353 ptrBuf.Append( BufToDesLC( aResult->iApps[i]->iVendor ) ); |
|
2354 CleanupStack::PopAndDestroy(); // BufToDesLC |
|
2355 |
|
2356 ptrBuf.Append( KSConAppInfoSeparator ); |
|
2357 ptrBuf.Append( BufToDesLC( aResult->iApps[i]->iParentName ) ); |
|
2358 CleanupStack::PopAndDestroy(); // BufToDesLC |
|
2359 |
|
2360 ptrBuf.Append( KSConAppInfoSeparator ); |
|
2361 if (aResult->iApps[i]->iWidgetBundleId) |
|
2362 { |
|
2363 ptrBuf.Append( BufToDesLC( *aResult->iApps[i]->iWidgetBundleId ) ); |
|
2364 CleanupStack::PopAndDestroy(); // BufToDesLC |
|
2365 } |
|
2366 |
|
2367 ptrBuf.Append( KSConAppInfoSeparator ); |
|
2368 |
|
2369 LOGGER_WRITE( "CSConPCConnSession::AppendListInstalledAppsResultsL() : set data" ); |
|
2370 app->data->uid = new ( ELeave ) pcdata_t(); |
|
2371 app->data->uid->SetDataL( *buf ); |
|
2372 |
|
2373 LOGGER_WRITE( "CSConPCConnSession::AppendListInstalledAppsResultsL() : Info added" ); |
|
2374 } |
|
2375 CleanupStack::PopAndDestroy(buf); |
|
2376 } |
|
2377 } |
|
2378 TRACE_FUNC_EXIT; |
|
2379 } |
|
2380 |
|
2381 // ----------------------------------------------------------------------------- |
|
2382 // CSConPCConnSession::AppendListPublicFilesResultsL() |
|
2383 // Appends a List public files -element from the reply data of PCCS |
|
2384 // ----------------------------------------------------------------------------- |
|
2385 // |
|
2386 void CSConPCConnSession::AppendListPublicFilesResultsL ( |
|
2387 ConML_ResultsPtr_t aContent, CSConListPublicFiles* aResult ) |
|
2388 { |
|
2389 TRACE_FUNC_ENTRY; |
|
2390 if ( aResult ) |
|
2391 { |
|
2392 if ( aResult->iComplete ) |
|
2393 { |
|
2394 aContent->complete = new ( ELeave ) pcdata_t(); |
|
2395 } |
|
2396 AppendProgressL ( aContent, aResult->iProgress ); |
|
2397 |
|
2398 if ( aResult->iFiles.Count() > 0 ) |
|
2399 { |
|
2400 aContent->files = new ( ELeave ) ConML_Files_t(); |
|
2401 for ( TInt i=0;i<aResult->iFiles.Count(); i++ ) |
|
2402 { |
|
2403 ConML_FileListPtr_t file = new ( ELeave ) ConML_FileList_t(); |
|
2404 CleanupStack::PushL( file ); |
|
2405 GenericListAddL ( &aContent->files->file, file ); |
|
2406 CleanupStack::Pop(); // file |
|
2407 |
|
2408 file->data = new ( ELeave ) ConML_File_t(); |
|
2409 file->data->name = new ( ELeave ) pcdata_t(); |
|
2410 file->data->name->SetDataL( BufToDesLC ( |
|
2411 aResult->iFiles[i]->iPath ) ); |
|
2412 CleanupStack::PopAndDestroy(); // BufToDesLC |
|
2413 |
|
2414 file->data->modified = new ( ELeave ) pcdata_t(); |
|
2415 file->data->modified->SetDataL( BufToDesLC ( |
|
2416 aResult->iFiles[i]->iModified ) ); |
|
2417 CleanupStack::PopAndDestroy(); // BufToDesLC |
|
2418 |
|
2419 file->data->size = new ( ELeave ) pcdata_t(); |
|
2420 file->data->size->SetDataL( IntToDesLC ( |
|
2421 aResult->iFiles[i]->iSize ) ); |
|
2422 CleanupStack::PopAndDestroy(); // IntToDesLC |
|
2423 |
|
2424 file->data->userPerm = new ( ELeave ) pcdata_t(); |
|
2425 switch ( aResult->iFiles[i]->iUserPerm ) |
|
2426 { |
|
2427 case EPermReadOnly: |
|
2428 file->data->userPerm->SetDataL ( KSConPermReadOnly ); |
|
2429 break; |
|
2430 |
|
2431 case EPermNormal: |
|
2432 file->data->userPerm->SetDataL ( KSConPermNormal ); |
|
2433 break; |
|
2434 |
|
2435 default: |
|
2436 LOGGER_WRITE( "CSConPCConnSession:: AppendListPublicFilesResultsL() : Unknown userPerm! " ); |
|
2437 break; |
|
2438 } |
|
2439 } |
|
2440 } |
|
2441 } |
|
2442 TRACE_FUNC_EXIT; |
|
2443 } |
|
2444 |
|
2445 // ----------------------------------------------------------------------------- |
|
2446 // CSConPCConnSession::AppendRequestDataResultsL() |
|
2447 // Appends a Request data -element from the reply data of PCCS |
|
2448 // ----------------------------------------------------------------------------- |
|
2449 // |
|
2450 void CSConPCConnSession::AppendRequestDataResultsL( |
|
2451 ConML_ResultsPtr_t aContent, CSConRequestData* aResult ) |
|
2452 { |
|
2453 TRACE_FUNC_ENTRY; |
|
2454 if ( aResult ) |
|
2455 { |
|
2456 if ( aResult->iComplete ) |
|
2457 { |
|
2458 aContent->complete = new ( ELeave ) pcdata_t(); |
|
2459 } |
|
2460 AppendProgressL ( aContent, aResult->iProgress ); |
|
2461 |
|
2462 if ( aResult->iMoreData ) |
|
2463 { |
|
2464 aContent->moreData = new ( ELeave ) pcdata_t(); |
|
2465 } |
|
2466 if ( aResult->iBackupData ) |
|
2467 { |
|
2468 aContent->data = new ( ELeave ) pcdata_t(); |
|
2469 aContent->data->SetDataL( aResult->iBackupData->Des() ); |
|
2470 } |
|
2471 } |
|
2472 TRACE_FUNC_EXIT; |
|
2473 } |
|
2474 |
|
2475 // ----------------------------------------------------------------------------- |
|
2476 // CSConPCConnSession::AppendSupplyDataResultsL() |
|
2477 // Appends a Supply data -element from the reply data of PCCS |
|
2478 // ----------------------------------------------------------------------------- |
|
2479 // |
|
2480 void CSConPCConnSession::AppendSupplyDataResultsL( |
|
2481 ConML_ResultsPtr_t aContent, CSConSupplyData* aResult ) |
|
2482 { |
|
2483 TRACE_FUNC_ENTRY; |
|
2484 if ( aResult ) |
|
2485 { |
|
2486 if ( aResult->iComplete ) |
|
2487 { |
|
2488 aContent->complete = new ( ELeave ) pcdata_t(); |
|
2489 } |
|
2490 AppendProgressL( aContent, aResult->iProgress ); |
|
2491 } |
|
2492 TRACE_FUNC_EXIT; |
|
2493 } |
|
2494 |
|
2495 // ----------------------------------------------------------------------------- |
|
2496 // CSConPCConnSession::AppendInstallResultsL() |
|
2497 // Appends an Install -element from the reply data of PCCS |
|
2498 // ----------------------------------------------------------------------------- |
|
2499 // |
|
2500 void CSConPCConnSession::AppendInstallResultsL( |
|
2501 ConML_ResultsPtr_t aContent, CSConInstall* aResult ) |
|
2502 { |
|
2503 TRACE_FUNC_ENTRY; |
|
2504 if ( aResult ) |
|
2505 { |
|
2506 if ( aResult->iComplete ) |
|
2507 { |
|
2508 aContent->complete = new ( ELeave ) pcdata_t(); |
|
2509 } |
|
2510 AppendProgressL( aContent, aResult->iProgress ); |
|
2511 |
|
2512 if ( aResult->iData && aResult->iData->Length() > 0 ) |
|
2513 { |
|
2514 aContent->data = new ( ELeave ) pcdata_t(); |
|
2515 aContent->data->SetDataL( aResult->iData->Des() ); |
|
2516 } |
|
2517 } |
|
2518 TRACE_FUNC_EXIT; |
|
2519 } |
|
2520 |
|
2521 // ----------------------------------------------------------------------------- |
|
2522 // CSConPCConnSession::AppendUninstallResultsL() |
|
2523 // Appends an Uninstall -element from the reply data of PCCS |
|
2524 // ----------------------------------------------------------------------------- |
|
2525 // |
|
2526 void CSConPCConnSession::AppendUninstallResultsL( |
|
2527 ConML_ResultsPtr_t aContent, CSConUninstall* aResult ) |
|
2528 { |
|
2529 TRACE_FUNC_ENTRY; |
|
2530 if ( aResult ) |
|
2531 { |
|
2532 if ( aResult->iComplete ) |
|
2533 { |
|
2534 LOGGER_WRITE( "CSConPCConnSession::AppendUninstallResultsL() Complete" ); |
|
2535 aContent->complete = new ( ELeave ) pcdata_t(); |
|
2536 } |
|
2537 LOGGER_WRITE_1( "CSConPCConnSession::AppendUninstallResultsL() iProgress: %d", aResult->iProgress ); |
|
2538 AppendProgressL( aContent, aResult->iProgress ); |
|
2539 |
|
2540 if ( aResult->iData && aResult->iData->Length() > 0 ) |
|
2541 { |
|
2542 aContent->data = new ( ELeave ) pcdata_t(); |
|
2543 aContent->data->SetDataL( aResult->iData->Des() ); |
|
2544 } |
|
2545 } |
|
2546 TRACE_FUNC_EXIT; |
|
2547 } |
|
2548 |
|
2549 // ----------------------------------------------------------------------------- |
|
2550 // CSConPCConnSession::AppendListDataOwnersResultsL() |
|
2551 // Appends a List data owners -element from the reply data of PCCS |
|
2552 // ----------------------------------------------------------------------------- |
|
2553 // |
|
2554 void CSConPCConnSession::AppendListDataOwnersResultsL ( |
|
2555 ConML_ResultsPtr_t aContent, CSConListDataOwners* aResult ) |
|
2556 { |
|
2557 TRACE_FUNC_ENTRY; |
|
2558 if ( aResult ) |
|
2559 { |
|
2560 if ( aResult->iComplete ) |
|
2561 { |
|
2562 aContent->complete = new ( ELeave ) pcdata_t(); |
|
2563 } |
|
2564 AppendProgressL( aContent, aResult->iProgress ); |
|
2565 |
|
2566 if ( aResult->iDataOwners.Count() > 0 ) |
|
2567 { |
|
2568 aContent->dataOwners = new ( ELeave ) ConML_DataOwners_t(); |
|
2569 for ( TInt i=0; i < aResult->iDataOwners.Count(); i ++) |
|
2570 { |
|
2571 ConML_SIDListPtr_t sid = new ( ELeave ) ConML_SIDList_t(); |
|
2572 CleanupStack::PushL( sid ); |
|
2573 GenericListAddL ( &aContent->dataOwners->sid, sid ); |
|
2574 CleanupStack::Pop(); |
|
2575 |
|
2576 sid->data = new ( ELeave ) ConML_SID_t(); |
|
2577 |
|
2578 sid->data->type = new ( ELeave ) pcdata_t(); |
|
2579 sid->data->type->SetDataL ( IntToDesLC ( |
|
2580 aResult->iDataOwners[i]->iType) ); |
|
2581 CleanupStack::PopAndDestroy(); // IntToDesLC |
|
2582 |
|
2583 sid->data->uid = new ( ELeave ) pcdata_t(); |
|
2584 |
|
2585 if( aResult->iDataOwners[i]->iUid.iUid ) |
|
2586 { |
|
2587 sid->data->uid->SetDataL ( UidToDesLC ( |
|
2588 aResult->iDataOwners[i]->iUid ) ); |
|
2589 CleanupStack::PopAndDestroy(); // UidToDesLC |
|
2590 } |
|
2591 |
|
2592 if( aResult->iDataOwners[i]->iJavaHash ) |
|
2593 { |
|
2594 sid->data->uid->SetDataL ( HashToDesLC ( |
|
2595 aResult->iDataOwners[i]->iJavaHash->Des() ) ); |
|
2596 CleanupStack::PopAndDestroy(); // HashToDesLC |
|
2597 } |
|
2598 |
|
2599 if ( HasDrives ( aResult->iDataOwners[i]->iDriveList ) ) |
|
2600 { |
|
2601 sid->data->drives = new ( ELeave ) ConML_Drives_t(); |
|
2602 AppendDrivesL ( sid->data->drives, |
|
2603 aResult->iDataOwners[i]->iDriveList ); |
|
2604 } |
|
2605 |
|
2606 if ( aResult->iDataOwners[i]->iPackageName.Length() > 0 ) |
|
2607 { |
|
2608 sid->data->packageInfo = |
|
2609 new ( ELeave ) ConML_PackageInfo_t(); |
|
2610 sid->data->packageInfo->name = new ( ELeave ) pcdata_t(); |
|
2611 sid->data->packageInfo->name->SetDataL ( BufToDesLC ( |
|
2612 aResult->iDataOwners[i]->iPackageName ) ); |
|
2613 |
|
2614 CleanupStack::PopAndDestroy(); // BufToDesLC |
|
2615 } |
|
2616 |
|
2617 if ( aResult->iDataOwners[i]->iHasFiles || |
|
2618 aResult->iDataOwners[i]->iSupportsInc || |
|
2619 aResult->iDataOwners[i]->iDelayToPrep || |
|
2620 aResult->iDataOwners[i]->iReqReboot ) |
|
2621 { |
|
2622 sid->data->burOptions = new ( ELeave ) ConML_BUROptions_t(); |
|
2623 if ( aResult->iDataOwners[i]->iHasFiles ) |
|
2624 { |
|
2625 sid->data->burOptions->hasFiles = |
|
2626 new ( ELeave ) pcdata_t(); |
|
2627 sid->data->burOptions->hasFiles->SetDataL( IntToDesLC( |
|
2628 aResult->iDataOwners[i]->iHasFiles )); |
|
2629 |
|
2630 CleanupStack::PopAndDestroy(); // IntToDesLC |
|
2631 } |
|
2632 if ( aResult->iDataOwners[i]->iSupportsInc ) |
|
2633 { |
|
2634 sid->data->burOptions->supportsInc = |
|
2635 new ( ELeave ) pcdata_t(); |
|
2636 } |
|
2637 if ( aResult->iDataOwners[i]->iDelayToPrep ) |
|
2638 { |
|
2639 sid->data->burOptions->delayToPrepareData = |
|
2640 new ( ELeave ) pcdata_t(); |
|
2641 } |
|
2642 if ( aResult->iDataOwners[i]->iReqReboot ) |
|
2643 { |
|
2644 sid->data->burOptions->requiresReboot = |
|
2645 new ( ELeave ) pcdata_t(); |
|
2646 } |
|
2647 } |
|
2648 } |
|
2649 } |
|
2650 } |
|
2651 TRACE_FUNC_EXIT; |
|
2652 } |
|
2653 |
|
2654 // ----------------------------------------------------------------------------- |
|
2655 // CSConPCConnSession::AppendGetDataOwnerStatusResultsL() |
|
2656 // Appends a Get data owner status -element from the reply data of PCCS |
|
2657 // ----------------------------------------------------------------------------- |
|
2658 // |
|
2659 void CSConPCConnSession::AppendGetDataOwnerStatusResultsL |
|
2660 ( ConML_ResultsPtr_t aContent, CSConGetDataOwnerStatus* aResult ) |
|
2661 { |
|
2662 TRACE_FUNC_ENTRY; |
|
2663 if ( aResult ) |
|
2664 { |
|
2665 if ( aResult->iComplete ) |
|
2666 { |
|
2667 aContent->complete = new ( ELeave ) pcdata_t(); |
|
2668 } |
|
2669 AppendProgressL( aContent, aResult->iProgress ); |
|
2670 |
|
2671 if ( aResult->iDataOwners.Count() > 0 ) |
|
2672 { |
|
2673 aContent->dataOwners = new ( ELeave ) ConML_DataOwners_t(); |
|
2674 for ( TInt i=0; i < aResult->iDataOwners.Count(); i ++) |
|
2675 { |
|
2676 ConML_SIDListPtr_t sid = new ( ELeave ) ConML_SIDList_t(); |
|
2677 CleanupStack::PushL( sid ); |
|
2678 GenericListAddL ( &aContent->dataOwners->sid, sid ); |
|
2679 CleanupStack::Pop(); |
|
2680 |
|
2681 sid->data = new ( ELeave ) ConML_SID_t(); |
|
2682 |
|
2683 sid->data->type = new ( ELeave ) pcdata_t(); |
|
2684 sid->data->type->SetDataL ( IntToDesLC ( |
|
2685 aResult->iDataOwners[i]->iType) ); |
|
2686 CleanupStack::PopAndDestroy(); // IntToDesLC |
|
2687 |
|
2688 sid->data->uid = new ( ELeave ) pcdata_t(); |
|
2689 sid->data->uid->SetDataL ( UidToDesLC ( |
|
2690 aResult->iDataOwners[i]->iUid ) ); |
|
2691 CleanupStack::PopAndDestroy(); // UidToDesLC |
|
2692 |
|
2693 sid->data->dataOwnerStatus = new ( ELeave ) pcdata_t(); |
|
2694 sid->data->dataOwnerStatus->SetDataL ( IntToDesLC( |
|
2695 aResult->iDataOwners[i]->iDataOwnStatus )); |
|
2696 |
|
2697 CleanupStack::PopAndDestroy(); // IntToDesLC |
|
2698 } |
|
2699 } |
|
2700 } |
|
2701 TRACE_FUNC_EXIT; |
|
2702 } |
|
2703 |
|
2704 // ----------------------------------------------------------------------------- |
|
2705 // CSConPCConnSession::AppendGetDataSizeResultsL() |
|
2706 // Appends a Get data owner size -element from the reply data of PCCS |
|
2707 // ----------------------------------------------------------------------------- |
|
2708 // |
|
2709 void CSConPCConnSession::AppendGetDataSizeResultsL ( |
|
2710 ConML_ResultsPtr_t aContent, CSConGetDataSize* aResult ) |
|
2711 { |
|
2712 TRACE_FUNC_ENTRY; |
|
2713 if ( aResult ) |
|
2714 { |
|
2715 if ( aResult->iComplete ) |
|
2716 { |
|
2717 aContent->complete = new ( ELeave ) pcdata_t(); |
|
2718 } |
|
2719 AppendProgressL( aContent, aResult->iProgress ); |
|
2720 |
|
2721 if ( aResult->iDataOwners.Count() > 0 ) |
|
2722 { |
|
2723 aContent->dataOwners = new ( ELeave ) ConML_DataOwners_t(); |
|
2724 |
|
2725 for ( TInt i=0; i< aResult->iDataOwners.Count(); i++ ) |
|
2726 { |
|
2727 ConML_SIDListPtr_t sid = new ( ELeave ) ConML_SIDList_t(); |
|
2728 CleanupStack::PushL( sid ); |
|
2729 GenericListAddL ( &aContent->dataOwners->sid, sid ); |
|
2730 CleanupStack::Pop(); |
|
2731 |
|
2732 sid->data = new ( ELeave ) ConML_SID_t(); |
|
2733 |
|
2734 sid->data->type = new ( ELeave ) pcdata_t(); |
|
2735 sid->data->type->SetDataL ( IntToDesLC ( |
|
2736 aResult->iDataOwners[i]->iType) ); |
|
2737 CleanupStack::PopAndDestroy(); // IntToDesLC |
|
2738 |
|
2739 sid->data->uid = new ( ELeave ) pcdata_t(); |
|
2740 |
|
2741 if( aResult->iDataOwners[i]->iUid.iUid ) |
|
2742 { |
|
2743 sid->data->uid->SetDataL ( UidToDesLC ( |
|
2744 aResult->iDataOwners[i]->iUid ) ); |
|
2745 CleanupStack::PopAndDestroy(); // UidToDesLC |
|
2746 } |
|
2747 |
|
2748 if( aResult->iDataOwners[i]->iJavaHash ) |
|
2749 { |
|
2750 sid->data->uid->SetDataL ( HashToDesLC ( |
|
2751 aResult->iDataOwners[i]->iJavaHash->Des() ) ); |
|
2752 CleanupStack::PopAndDestroy(); // HashToDesLC |
|
2753 } |
|
2754 |
|
2755 if ( HasDrives ( aResult->iDataOwners[i]->iDriveList ) ) |
|
2756 { |
|
2757 sid->data->drives = new ( ELeave ) ConML_Drives_t(); |
|
2758 AppendDrivesL ( sid->data->drives, |
|
2759 aResult->iDataOwners[i]->iDriveList ); |
|
2760 } |
|
2761 |
|
2762 sid->data->size = new ( ELeave ) pcdata_t(); |
|
2763 sid->data->size->SetDataL( IntToDesLC( |
|
2764 aResult->iDataOwners[i]->iSize ) ); |
|
2765 CleanupStack::PopAndDestroy(); // IntToDesLC |
|
2766 |
|
2767 sid->data->transferDataType = new ( ELeave ) pcdata_t(); |
|
2768 sid->data->transferDataType->SetDataL( IntToDesLC( |
|
2769 aResult->iDataOwners[i]->iTransDataType ) ); |
|
2770 |
|
2771 CleanupStack::PopAndDestroy(); // IntToDesLC |
|
2772 } |
|
2773 } |
|
2774 } |
|
2775 TRACE_FUNC_EXIT; |
|
2776 } |
|
2777 |
|
2778 // ----------------------------------------------------------------------------- |
|
2779 // CSConPCConnSession::AppendGetMetadataResultsL() |
|
2780 // Appends a GetMetadata -element from the reply data of PCCS |
|
2781 // ----------------------------------------------------------------------------- |
|
2782 // |
|
2783 void CSConPCConnSession::AppendGetMetadataResultsL( |
|
2784 ConML_ResultsPtr_t aContent, CSConGetMetadata* aResult ) |
|
2785 { |
|
2786 TRACE_FUNC_ENTRY; |
|
2787 |
|
2788 if ( aResult ) |
|
2789 { |
|
2790 if ( aResult->iComplete ) |
|
2791 { |
|
2792 aContent->complete = new ( ELeave ) pcdata_t(); |
|
2793 |
|
2794 // add filename only if task is completed |
|
2795 aContent->filename = new ( ELeave ) pcdata_t(); |
|
2796 aContent->filename->SetDataL( BufToDesLC(aResult->iFilename ) ); |
|
2797 CleanupStack::PopAndDestroy(); // BufToDesLC |
|
2798 } |
|
2799 AppendProgressL( aContent, aResult->iProgress ); |
|
2800 |
|
2801 if ( aResult->iData ) |
|
2802 { |
|
2803 aContent->data = new ( ELeave ) pcdata_t(); |
|
2804 aContent->data->SetDataL( aResult->iData->Des() ); |
|
2805 } |
|
2806 |
|
2807 if ( aResult->iMoreData ) |
|
2808 { |
|
2809 aContent->moreData = new ( ELeave ) pcdata_t(); |
|
2810 } |
|
2811 } |
|
2812 TRACE_FUNC_EXIT; |
|
2813 } |
|
2814 |
|
2815 // ----------------------------------------------------------------------------- |
|
2816 // CSConPCConnSession::AppendProgressL() |
|
2817 // Appends a Progress -element from the reply data of PCCS |
|
2818 // ----------------------------------------------------------------------------- |
|
2819 // |
|
2820 void CSConPCConnSession::AppendProgressL ( |
|
2821 ConML_ResultsPtr_t aContent, TInt progress ) |
|
2822 { |
|
2823 TRACE_FUNC_ENTRY; |
|
2824 aContent->progress = new ( ELeave ) ConML_Progress_t(); |
|
2825 aContent->progress->value = new ( ELeave ) pcdata_t(); |
|
2826 aContent->progress->value->SetDataL ( IntToDesLC ( progress )); |
|
2827 CleanupStack::PopAndDestroy(); // IntToDesLC |
|
2828 TRACE_FUNC_EXIT; |
|
2829 } |
|
2830 |
|
2831 // ----------------------------------------------------------------------------- |
|
2832 // CSConPCConnSession::AppendDrivesL() |
|
2833 // Appends a Drives -element from the reply data of PCCS |
|
2834 // ----------------------------------------------------------------------------- |
|
2835 // |
|
2836 void CSConPCConnSession::AppendDrivesL( |
|
2837 ConML_DrivesPtr_t aContent, TDriveList aDrives ) |
|
2838 { |
|
2839 TRACE_FUNC_ENTRY; |
|
2840 |
|
2841 for ( TInt i = 0; i<KMaxDrives; i++ ) |
|
2842 { |
|
2843 if ( aDrives[i] ) |
|
2844 { |
|
2845 ConML_DriveListPtr_t drive = new ( ELeave ) ConML_DriveList_t(); |
|
2846 CleanupStack::PushL ( drive ); |
|
2847 GenericListAddL ( &aContent->drive, drive ); |
|
2848 CleanupStack::Pop(); // drive |
|
2849 |
|
2850 drive->data = new ( ELeave ) ConML_Drive_t(); |
|
2851 drive->data->name = new ( ELeave ) pcdata_t(); |
|
2852 drive->data->name->SetDataL( DriveNumToDesLC(i+KSConFirstDrive )); |
|
2853 CleanupStack::PopAndDestroy(); // IntToDesLC |
|
2854 } |
|
2855 } |
|
2856 TRACE_FUNC_EXIT; |
|
2857 } |
|
2858 |
|
2859 // ----------------------------------------------------------------------------- |
|
2860 // CSConPCConnSession::DriveList() |
|
2861 // Converts an Drives -element to TDriveList |
|
2862 // ----------------------------------------------------------------------------- |
|
2863 // |
|
2864 TDriveList CSConPCConnSession::DriveList( ConML_DriveListPtr_t aContent ) |
|
2865 { |
|
2866 TBuf8<KMaxDrives> driveBuf; |
|
2867 TDriveList driveList; |
|
2868 |
|
2869 for ( ConML_DriveListPtr_t p = aContent; p && p->data; p = p->next ) |
|
2870 { |
|
2871 if ( p->data->name ) |
|
2872 { |
|
2873 driveBuf.Append( p->data->name->Data() ); |
|
2874 } |
|
2875 } |
|
2876 |
|
2877 for ( TInt i = 0; i<KMaxDrives; i++ ) |
|
2878 { |
|
2879 if ( driveBuf.Locate ( TChar( i + KSConFirstDrive ) ) != KErrNotFound ) |
|
2880 { |
|
2881 driveList.Append( KSConDriveExists ); |
|
2882 } |
|
2883 else |
|
2884 { |
|
2885 driveList.Append( KSConNoDrive ); |
|
2886 } |
|
2887 } |
|
2888 return driveList; |
|
2889 } |
|
2890 |
|
2891 |
|
2892 // ----------------------------------------------------------------------------- |
|
2893 // CSConPCConnSession::IntToDesLC() |
|
2894 // Converts an integer to descriptor |
|
2895 // ----------------------------------------------------------------------------- |
|
2896 // |
|
2897 TDesC8& CSConPCConnSession::IntToDesLC(const TInt& anInt) |
|
2898 { |
|
2899 HBufC8* buf = HBufC8::NewLC(20); |
|
2900 TPtr8 ptrBuf = buf->Des(); |
|
2901 ptrBuf.Num(anInt); |
|
2902 return *buf; |
|
2903 } |
|
2904 |
|
2905 // ----------------------------------------------------------------------------- |
|
2906 // CSConPCConnSession::DriveNumToDesLC() |
|
2907 // Convers a drive number to equivalent drive letter |
|
2908 // ----------------------------------------------------------------------------- |
|
2909 // |
|
2910 TDesC8& CSConPCConnSession::DriveNumToDesLC( const TInt& anInt ) |
|
2911 { |
|
2912 TChar mark ( anInt ); |
|
2913 HBufC8* buf = HBufC8::NewLC(1); |
|
2914 TPtr8 ptrBuf = buf->Des(); |
|
2915 ptrBuf.Append(mark); |
|
2916 return *buf; |
|
2917 } |
|
2918 |
|
2919 // ----------------------------------------------------------------------------- |
|
2920 // CSConPCConnSession::BufToDesLC() |
|
2921 // converts a buffer to descriptor |
|
2922 // ----------------------------------------------------------------------------- |
|
2923 // |
|
2924 TDesC8& CSConPCConnSession::BufToDesLC( const TDesC& aBuf) |
|
2925 { |
|
2926 HBufC8* buf = CnvUtfConverter::ConvertFromUnicodeToUtf8L( aBuf ); |
|
2927 CleanupStack::PushL( buf ); |
|
2928 return *buf; |
|
2929 } |
|
2930 |
|
2931 // ----------------------------------------------------------------------------- |
|
2932 // CSConPCConnSession::UidToDesLC() |
|
2933 // converts an UID to a descriptor |
|
2934 // ----------------------------------------------------------------------------- |
|
2935 // |
|
2936 TDesC8& CSConPCConnSession::UidToDesLC( const TUid& aUid ) |
|
2937 { |
|
2938 HBufC8* buf = HBufC8::NewLC(10); |
|
2939 TPtr8 ptrBuf = buf->Des(); |
|
2940 ptrBuf.Copy (aUid.Name().Mid(1, 8) ); |
|
2941 return *buf; |
|
2942 } |
|
2943 |
|
2944 // ----------------------------------------------------------------------------- |
|
2945 // CSConPCConnSession::DesToUid() |
|
2946 // converts a descriptor to a UID value |
|
2947 // ----------------------------------------------------------------------------- |
|
2948 // |
|
2949 TUid CSConPCConnSession::DesToUid ( const TDesC8& aDes ) |
|
2950 { |
|
2951 TLex8 lex( aDes ); |
|
2952 TUint32 value; |
|
2953 lex.Val( value, EHex ); |
|
2954 TUid uid = TUid::Uid( value ); |
|
2955 return uid; |
|
2956 } |
|
2957 |
|
2958 // ----------------------------------------------------------------------------- |
|
2959 // CSConPCConnSession::DesToInt() |
|
2960 // converts a descriptor to a integer value |
|
2961 // ----------------------------------------------------------------------------- |
|
2962 // |
|
2963 TInt CSConPCConnSession::DesToInt( const TDesC8& aDes) |
|
2964 { |
|
2965 TLex8 lex(aDes); |
|
2966 TInt value = 0; |
|
2967 lex.Val(value); |
|
2968 return value; |
|
2969 } |
|
2970 |
|
2971 // ----------------------------------------------------------------------------- |
|
2972 // CSConPCConnSession::HasDrives() |
|
2973 // Returns ETrue if at least one drive is found from the given TDriveList |
|
2974 // ----------------------------------------------------------------------------- |
|
2975 // |
|
2976 TBool CSConPCConnSession::HasDrives( TDriveList& aDrive ) |
|
2977 { |
|
2978 TBool hasDrives ( EFalse ); |
|
2979 for ( TInt i = 0; i<KMaxDrives; i++ ) |
|
2980 { |
|
2981 if ( aDrive[i] ) |
|
2982 { |
|
2983 hasDrives = ETrue; |
|
2984 } |
|
2985 } |
|
2986 return hasDrives; |
|
2987 } |
|
2988 // ----------------------------------------------------------------------------- |
|
2989 // CSConPCConnSession::HashToDesLC() |
|
2990 // converts a Java hash to descriptor |
|
2991 // ----------------------------------------------------------------------------- |
|
2992 // |
|
2993 TDesC8& CSConPCConnSession::HashToDesLC( const TDesC& aBuf) |
|
2994 { |
|
2995 HBufC8* buf = HBufC8::NewLC(aBuf.Size()+5); |
|
2996 TPtr8 ptrBuf = buf->Des(); |
|
2997 // Unicode conversion from 16-bit to 8-bit |
|
2998 CnvUtfConverter::ConvertFromUnicodeToUtf8(ptrBuf, aBuf); |
|
2999 //Add JAVA_ identifier to the begining of the hash |
|
3000 ptrBuf.Insert(0, KSConJavaHashId); |
|
3001 return *buf; |
|
3002 } |
|
3003 // ----------------------------------------------------------------------------- |
|
3004 // CSConPCConnSession::DesToHashLC() |
|
3005 // converts descriptor to Java hash |
|
3006 // ----------------------------------------------------------------------------- |
|
3007 // |
|
3008 TPtr CSConPCConnSession::DesToHashLC( const TDesC8& aDes ) |
|
3009 { |
|
3010 HBufC* buf = HBufC::NewLC(aDes.Size()); |
|
3011 TPtr ptrBuf = buf->Des(); |
|
3012 // Unicode conversion from 8-bit to 16-bit |
|
3013 CnvUtfConverter::ConvertToUnicodeFromUtf8(ptrBuf, aDes); |
|
3014 //Delete JAVA_ |
|
3015 ptrBuf.Delete(0, KSConJavaHashId().Length()); |
|
3016 return ptrBuf; |
|
3017 } |
|
3018 // ----------------------------------------------------------------------------- |
|
3019 // CSConPCConnSession::IsJavaHash() |
|
3020 // Returns ETrue if descriptor is Java hash, else EFalse |
|
3021 // ----------------------------------------------------------------------------- |
|
3022 // |
|
3023 TBool CSConPCConnSession::IsJavaHash( const TDesC8& aDes ) |
|
3024 { |
|
3025 if ( aDes.FindC(KSConJavaHashId) == 0 ) |
|
3026 { |
|
3027 return ETrue; |
|
3028 } |
|
3029 else |
|
3030 { |
|
3031 return EFalse; |
|
3032 } |
|
3033 } |
|
3034 |
|