1 /* |
|
2 * Copyright (c) 2008 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: AV Controller UPnP actions handler |
|
15 * Version : %version: tr1ido#1.1.10 % << Don't touch! |
|
16 * |
|
17 */ |
|
18 |
|
19 #include <utf.h> |
|
20 #include "upnpavdevice.h" |
|
21 #include "upnpavcontroller.h" |
|
22 #include "upnpfileuploadsession.h" |
|
23 |
|
24 #include "cmsmtransferobserver.h" |
|
25 #include "cmdmmain.h" |
|
26 #include "cmstorelistitem.h" |
|
27 #include "cmsqlmainfactory.h" |
|
28 #include "mcmsqlmain.h" |
|
29 #include "cmsmtransferengine.h" |
|
30 #include "msdebug.h" |
|
31 |
|
32 // CONSTANTS |
|
33 const TInt KGranularity = 10; |
|
34 //If once total size bigger than 30MB may cause timeout when uploading |
|
35 const TInt KCopySizePerTime = 30 * KMega; |
|
36 //If once total count more than 20 files may cause timeout when uploading |
|
37 const TInt KCopyCountPerTime = 20; |
|
38 |
|
39 #ifdef _DEBUG |
|
40 _LIT( KCmStoreManager, "CmStoreManager" ); |
|
41 #endif // _DEBUG |
|
42 |
|
43 // --------------------------------------------------------------------------- |
|
44 // CCmSmTransferEngine::NewL |
|
45 // --------------------------------------------------------------------------- |
|
46 // |
|
47 CCmSmTransferEngine* CCmSmTransferEngine::NewL( |
|
48 MCmSmTransferObserver* aObserver, CCmDmMain* aDBMngr, |
|
49 RPointerArray<CCmStoreListItem>& aItems, RArray<TInt>& aItemIds ) |
|
50 { |
|
51 LOG(_L("[STORE MNGR]\t CCmSmTransferEngine::NewL() start")); |
|
52 CCmSmTransferEngine* self = CCmSmTransferEngine::NewLC( aObserver, |
|
53 aDBMngr, aItems, aItemIds ); |
|
54 CleanupStack::Pop( self ); |
|
55 LOG(_L("[STORE MNGR]\t CCmSmTransferEngine::NewL() end")); |
|
56 return self; |
|
57 } |
|
58 |
|
59 // --------------------------------------------------------------------------- |
|
60 // CCmSmTransferEngine::NewLC |
|
61 // --------------------------------------------------------------------------- |
|
62 // |
|
63 CCmSmTransferEngine* CCmSmTransferEngine::NewLC( |
|
64 MCmSmTransferObserver* aObserver, CCmDmMain* aDBMngr, |
|
65 RPointerArray<CCmStoreListItem>& aItems, RArray<TInt>& aItemIds ) |
|
66 { |
|
67 LOG(_L("[STORE MNGR]\t CCmSmTransferEngine::NewLC() start")); |
|
68 CCmSmTransferEngine* self = new ( ELeave ) CCmSmTransferEngine( aObserver, |
|
69 aDBMngr, aItems, aItemIds ); |
|
70 CleanupStack::PushL( self ); |
|
71 self->ConstructL(); |
|
72 LOG(_L("[STORE MNGR]\t CCmSmTransferEngine::NewLC() end")); |
|
73 return self; |
|
74 } |
|
75 |
|
76 // --------------------------------------------------------------------------- |
|
77 // CCmSmTransferEngine::~CCmSmTransferEngine |
|
78 // --------------------------------------------------------------------------- |
|
79 // |
|
80 CCmSmTransferEngine::~CCmSmTransferEngine() |
|
81 { |
|
82 LOG(_L("[STORE MNGR]\t CCmSmTransferEngine::~CCmSmTransferEngine()")); |
|
83 CancelCopy(); |
|
84 if( iFilesToBeRemoved ) |
|
85 { |
|
86 iFilesToBeRemoved->Reset(); |
|
87 delete iFilesToBeRemoved; |
|
88 } |
|
89 if( iFilesToBeShrinked ) |
|
90 { |
|
91 iFilesToBeShrinked->Reset(); |
|
92 delete iFilesToBeShrinked; |
|
93 } |
|
94 iToBeDeleted.Close(); |
|
95 iObserver = NULL; |
|
96 iDBManager = NULL; |
|
97 iDbWrapper->Close(); |
|
98 iFSession.Close(); |
|
99 } |
|
100 |
|
101 // --------------------------------------------------------------------------- |
|
102 // CCmSmTransferEngine::CCmSmTransferEngine |
|
103 // --------------------------------------------------------------------------- |
|
104 // |
|
105 CCmSmTransferEngine::CCmSmTransferEngine( MCmSmTransferObserver* aObserver, |
|
106 CCmDmMain* aDBMngr, RPointerArray<CCmStoreListItem>& aItems, |
|
107 RArray<TInt>& aItemIds ) |
|
108 : iObserver( aObserver ), iDBManager( aDBMngr ), iDevice( NULL ), |
|
109 iItems( aItems ), iItemIds(aItemIds) |
|
110 { |
|
111 LOG(_L("[STORE MNGR]\t CCmSmTransferEngine::CCmSmTransferEngine")); |
|
112 } |
|
113 |
|
114 // --------------------------------------------------------------------------- |
|
115 // CCmSmTransferEngine::ConstructL |
|
116 // --------------------------------------------------------------------------- |
|
117 // |
|
118 void CCmSmTransferEngine::ConstructL() |
|
119 { |
|
120 LOG(_L("[STORE MNGR]\t CCmSmTransferEngine::ConstructL")); |
|
121 |
|
122 User::LeaveIfError( iFSession.Connect() ); |
|
123 iFilesToBeRemoved = new ( ELeave ) CDesCArrayFlat( KGranularity ); |
|
124 iFilesToBeShrinked = new ( ELeave ) CDesCArrayFlat( KGranularity ); |
|
125 iDbWrapper = CCmSqlMainFactory::NewCmSqlMainL( iFSession ); |
|
126 } |
|
127 |
|
128 // --------------------------------------------------------------------------- |
|
129 // CCmSmTransferEngine::SetAvController |
|
130 // --------------------------------------------------------------------------- |
|
131 // |
|
132 void CCmSmTransferEngine::SetAvController( MUPnPAVController* aAVController ) |
|
133 { |
|
134 LOG(_L("[STORE MNGR]\t CCmSmTransferEngine::SetAvController")); |
|
135 |
|
136 iAVController = aAVController; |
|
137 iUploadSession = NULL; |
|
138 } |
|
139 |
|
140 // --------------------------------------------------------------------------- |
|
141 // CCmSmTransferEngine::GetMediaServersL |
|
142 // --------------------------------------------------------------------------- |
|
143 // |
|
144 void CCmSmTransferEngine::GetMediaServersL( |
|
145 CUpnpAVDeviceList*& aDevices ) |
|
146 { |
|
147 LOG(_L("[STORE MNGR]\t CCmSmTransferEngine::GetMediaServersL()")); |
|
148 |
|
149 aDevices = iAVController->GetMediaServersL(); |
|
150 } |
|
151 |
|
152 // --------------------------------------------------------------------------- |
|
153 // CCmSmTransferEngine::ResetFileArrays |
|
154 // --------------------------------------------------------------------------- |
|
155 // |
|
156 void CCmSmTransferEngine::ResetFileArrays() |
|
157 { |
|
158 LOG(_L("[STORE MNGR]\t CCmSmTransferEngine::ResetFileArrays")); |
|
159 |
|
160 if( iFilesToBeRemoved ) |
|
161 { |
|
162 iFilesToBeRemoved->Reset(); |
|
163 } |
|
164 if( iFilesToBeShrinked ) |
|
165 { |
|
166 iFilesToBeShrinked->Reset(); |
|
167 } |
|
168 iToBeDeleted.Reset(); |
|
169 iToBeDeleted.Close(); |
|
170 } |
|
171 |
|
172 // --------------------------------------------------------------------------- |
|
173 // CCmSmTransferEngine::CancelCopy |
|
174 // --------------------------------------------------------------------------- |
|
175 // |
|
176 void CCmSmTransferEngine::CancelCopy() |
|
177 { |
|
178 LOG(_L("[STORE MNGR]\t CCmSmTransferEngine::CancelCopy()")); |
|
179 |
|
180 if ( iAVController ) |
|
181 { |
|
182 iAVController->StopUploadSession( *iUploadSession ); |
|
183 iUploadSession = NULL; |
|
184 } |
|
185 } |
|
186 |
|
187 // --------------------------------------------------------------------------- |
|
188 // CCmSmTransferEngine::CopyFilesL |
|
189 // --------------------------------------------------------------------------- |
|
190 // |
|
191 void CCmSmTransferEngine::CopyFilesL( TUint8 aDevId, |
|
192 CUpnpAVDevice* aDevice ) |
|
193 { |
|
194 LOG(_L("[STORE MNGR]\t CCmSmTransferEngine::CopyFilesL")); |
|
195 |
|
196 if( iAVController ) |
|
197 { |
|
198 iAVController->StopUploadSession( *iUploadSession ); |
|
199 iUploadSession = NULL; |
|
200 } |
|
201 iDevId = aDevId; |
|
202 iIndex = iItemIds.Count() - 1; |
|
203 iDevice = aDevice; |
|
204 ResetFileArrays(); |
|
205 iTransferredData = KErrNone; |
|
206 iTotalTransferredData = KErrNone; |
|
207 |
|
208 if( aDevice ) |
|
209 { |
|
210 ConnectedToDeviceL( *aDevice ); |
|
211 CopySingleFileL(); |
|
212 } |
|
213 else |
|
214 { |
|
215 LOG(_L("[STORE MNGR]\t CCmSmTransferEngine::CopyFilesL \ |
|
216 aDevice == NULL")); |
|
217 FinishCopy(); |
|
218 } |
|
219 } |
|
220 |
|
221 // --------------------------------------------------------------------------- |
|
222 // CCmSmTransferEngine::DataAmount |
|
223 // --------------------------------------------------------------------------- |
|
224 // |
|
225 TInt CCmSmTransferEngine::DataAmount() const |
|
226 { |
|
227 LOG(_L("[STORE MNGR]\t CCmSmTransferEngine::DataAmount")); |
|
228 |
|
229 return iTotalTransferredData; |
|
230 } |
|
231 |
|
232 // --------------------------------------------------------------------------- |
|
233 // CCmSmTransferEngine::FilesToBeRemoved |
|
234 // --------------------------------------------------------------------------- |
|
235 // |
|
236 CDesCArray& CCmSmTransferEngine::FilesToBeRemoved() |
|
237 { |
|
238 LOG(_L("[STORE MNGR]\t CCmSmTransferEngine::FilesToBeRemoved")); |
|
239 |
|
240 /** Files to be removed */ |
|
241 return *iFilesToBeRemoved; |
|
242 } |
|
243 |
|
244 // --------------------------------------------------------------------------- |
|
245 // CCmSmTransferEngine::DeleteToBeRemoved |
|
246 // --------------------------------------------------------------------------- |
|
247 // |
|
248 void CCmSmTransferEngine::DeleteToBeRemoved() |
|
249 { |
|
250 LOG(_L("[STORE MNGR]\t CCmSmTransferEngine::DeleteToBeRemoved")); |
|
251 |
|
252 iFilesToBeRemoved->Reset(); |
|
253 } |
|
254 |
|
255 // --------------------------------------------------------------------------- |
|
256 // CCmSmTransferEngine::FilesToBeShrinked |
|
257 // --------------------------------------------------------------------------- |
|
258 // |
|
259 CDesCArray& CCmSmTransferEngine::FilesToBeShrinked() |
|
260 { |
|
261 LOG(_L("[STORE MNGR]\t CCmSmTransferEngine::FilesToBeShrinked")); |
|
262 |
|
263 /** Files to be shrinked */ |
|
264 return *iFilesToBeShrinked; |
|
265 } |
|
266 |
|
267 // --------------------------------------------------------------------------- |
|
268 // CCmSmTransferEngine::DeleteToBeShrinked |
|
269 // --------------------------------------------------------------------------- |
|
270 // |
|
271 void CCmSmTransferEngine::DeleteToBeShrinked() |
|
272 { |
|
273 LOG(_L("[STORE MNGR]\t CCmSmTransferEngine::DeleteToBeShrinked")); |
|
274 |
|
275 iFilesToBeShrinked->Reset(); |
|
276 } |
|
277 |
|
278 // --------------------------------------------------------------------------- |
|
279 // CCmSmTransferEngine::ToBeDeleted |
|
280 // --------------------------------------------------------------------------- |
|
281 // |
|
282 RArray<TInt>& CCmSmTransferEngine::ToBeDeleted() |
|
283 { |
|
284 TRACE(Print(_L("[STORE MNGR] CCmSmTransferEngine::DeleteToBeShrinked \ |
|
285 To be deleted count = %d"), |
|
286 iToBeDeleted.Count() )); |
|
287 return iToBeDeleted; |
|
288 } |
|
289 |
|
290 // --------------------------------------------------------------------------- |
|
291 // CCmSmTransferEngine::TransferStarted |
|
292 // --------------------------------------------------------------------------- |
|
293 // |
|
294 #ifdef _DEBUG |
|
295 void CCmSmTransferEngine::TransferStarted( TInt aKey, TInt aStatus ) |
|
296 { |
|
297 #else |
|
298 void CCmSmTransferEngine::TransferStarted( TInt /*aKey*/, TInt /*aStatus*/ ) |
|
299 { |
|
300 #endif |
|
301 LOG(_L("[STORE MNGR]\t CCmSmTransferEngine::TransferStarted()")); |
|
302 TRACE(Print( _L("[STORE MNGR] Started transferin file aKey = %D"),aKey)); |
|
303 TRACE(Print( _L("[STORE MNGR] Started transferin file aStatus = %D"), |
|
304 aStatus )); |
|
305 } |
|
306 |
|
307 // --------------------------------------------------------------------------- |
|
308 // CCmSmTransferEngine::TransferCompleted |
|
309 // --------------------------------------------------------------------------- |
|
310 // |
|
311 void CCmSmTransferEngine::TransferCompleted( TInt aKey, TInt aStatus, |
|
312 const TDesC& /*aFilePath*/ ) |
|
313 { |
|
314 TRACE(Print(_L("[STORE MNGR]\t CCmSmTransferEngine::TransferCompleted() \ |
|
315 aStatus %d"), aStatus )); |
|
316 TRACE(Print( _L("[STORE MNGR] Transfered file = %d"), aKey )); |
|
317 |
|
318 iObserver->TransferStatus( ECmSmFileTransferred ); |
|
319 TInt err( KErrNone ); |
|
320 if( !aStatus ) |
|
321 { |
|
322 TTime time; |
|
323 time.HomeTime(); |
|
324 if( iItems[ iItemIds[ aKey ] ] ) |
|
325 { |
|
326 TRAP( err, AddStoredL( iItems[iItemIds[aKey]]->Path(), |
|
327 iDevice->Uuid(), time ) ); |
|
328 TRACE(Print( _L("[STORE MNGR] AddStoredL err = %d"), err )); |
|
329 } |
|
330 TRAP( err, HandleItemStatusL( aKey ) ); |
|
331 TRACE(Print( _L("[STORE MNGR] HandleItemStatusL err = %d"), err )); |
|
332 } |
|
333 TInt index( iTransferQueue.FindInOrder( aKey ) ); |
|
334 if( KErrNotFound != index ) |
|
335 { |
|
336 iTransferQueue.Remove( index ); |
|
337 if( !iTransferQueue.Count() ) |
|
338 { |
|
339 LOG( _L("[STORE MNGR] Transfer successfully completed")); |
|
340 LOG( _L("[STORE MNGR] Queue empty!")); |
|
341 iObserver->TransferStatus( ECmSmTransferCompleted ); |
|
342 iTransferQueue.Reset(); |
|
343 } |
|
344 } |
|
345 else |
|
346 { |
|
347 LOG( _L("[STORE MNGR] Transfer successfully completed")); |
|
348 iObserver->TransferStatus( ECmSmTransferCompleted ); |
|
349 } |
|
350 } |
|
351 |
|
352 // --------------------------------------------------------------------------- |
|
353 // CCmSmTransferEngine::TransferProgress |
|
354 // --------------------------------------------------------------------------- |
|
355 // |
|
356 void CCmSmTransferEngine::TransferProgress( TInt /*aKey*/, TInt aBytes, |
|
357 TInt aTotalBytes ) |
|
358 { |
|
359 LOG(_L("[STORE MNGR]\t CCmSmTransferEngine::TransferProgress")); |
|
360 |
|
361 iTransferredData = ( aBytes / KKilo ); // Convert to kilobytes |
|
362 |
|
363 // Check if file has been transferred completely |
|
364 if ( aBytes == aTotalBytes ) |
|
365 { |
|
366 iTotalTransferredData += ( aTotalBytes / KKilo ); |
|
367 } |
|
368 } |
|
369 |
|
370 // --------------------------------------------------------------------------- |
|
371 // CCmSmTransferEngine::MediaServerDisappeared |
|
372 // --------------------------------------------------------------------------- |
|
373 // |
|
374 void CCmSmTransferEngine::MediaServerDisappeared( |
|
375 TUPnPDeviceDisconnectedReason /*aReason*/ ) |
|
376 { |
|
377 TRACE(Print( _L("[STORE MNGR] CCmSmTransferEngine::\ |
|
378 MediaServerDisappeared WLANLost") )); |
|
379 CancelCopy(); |
|
380 iObserver->TransferStatus( ECmSmWlanLost ); |
|
381 DeleteToBeRemoved(); |
|
382 DeleteToBeShrinked(); |
|
383 iToBeDeleted.Reset(); |
|
384 iToBeDeleted.Close(); |
|
385 } |
|
386 |
|
387 // --------------------------------------------------------------------------- |
|
388 // CCmSmTransferEngine::CancelOperation |
|
389 // --------------------------------------------------------------------------- |
|
390 // |
|
391 void CCmSmTransferEngine::CancelOperation() |
|
392 { |
|
393 LOG(_L("[STORE MNGR]\t CCmSmTransferEngine::CancelOperation")); |
|
394 |
|
395 CancelCopy(); |
|
396 DeleteToBeRemoved(); |
|
397 DeleteToBeShrinked(); |
|
398 iToBeDeleted.Reset(); |
|
399 iToBeDeleted.Close(); |
|
400 iObserver->TransferStatus(ECmSmTransferCanceled); |
|
401 } |
|
402 |
|
403 // --------------------------------------------------------------------------- |
|
404 // CCmSmTransferEngine::CopySingleFileL |
|
405 // --------------------------------------------------------------------------- |
|
406 // |
|
407 void CCmSmTransferEngine::CopySingleFileL() |
|
408 { |
|
409 LOG( _L("[STORE MNGR] COTSTransferEngine::CopySingleFileL")); |
|
410 |
|
411 /** File transfer started */ |
|
412 iTransferStarted.HomeTime(); |
|
413 // Files left in queue |
|
414 iTransferQueue.Reset(); |
|
415 iCopyStatus = ECmSmCopyNever; |
|
416 //start uploading |
|
417 CopyFilesOnceL(); |
|
418 |
|
419 if( iItems.Count() == KErrNone ) |
|
420 { |
|
421 iCopyStatus = ECmSmCopySuccess; |
|
422 LOG( _L("[STORE MNGR] Transfer successfully completed")); |
|
423 __ASSERT_DEBUG(( iIndex + 1 == 0 ),\ |
|
424 User::Panic( KCmStoreManager, ECmSmTransferQueueMessedUp )); |
|
425 FinishCopy(); |
|
426 } |
|
427 if( ECmSmCopyNever == iCopyStatus ) |
|
428 { |
|
429 FinishCopy(); |
|
430 } |
|
431 } |
|
432 |
|
433 // --------------------------------------------------------------------------- |
|
434 // CCmSmTransferEngine::ContinueCopyFilesL |
|
435 // --------------------------------------------------------------------------- |
|
436 // |
|
437 void CCmSmTransferEngine::ContinueCopyFilesL() |
|
438 { |
|
439 LOG(_L("[STORE MNGR]\t CCmSmTransferEngine::ContinueCopyFilesL")); |
|
440 |
|
441 CopyFilesOnceL(); |
|
442 |
|
443 if ( iIndex == KErrNotFound && ECmSmCopyContinued == iCopyStatus ) |
|
444 { |
|
445 iCopyStatus = ECmSmCopyNever; |
|
446 } |
|
447 if( ECmSmCopyNever == iCopyStatus ) |
|
448 { |
|
449 FinishCopy(); |
|
450 } |
|
451 } |
|
452 |
|
453 // --------------------------------------------------------------------------- |
|
454 // CCmSmTransferEngine::CopyFilesOnceL |
|
455 // --------------------------------------------------------------------------- |
|
456 // |
|
457 void CCmSmTransferEngine::CopyFilesOnceL() |
|
458 { |
|
459 LOG(_L("[STORE MNGR]\t CCmSmTransferEngine::CopyFilesOnceL")); |
|
460 |
|
461 TInt copySize( 0 ); |
|
462 TInt copyCt( 0 ); |
|
463 if( iItemIds.Count() ) |
|
464 { |
|
465 while( 0 <= iIndex && |
|
466 copySize < KCopySizePerTime && |
|
467 copyCt < KCopyCountPerTime ) |
|
468 { |
|
469 if( iItemIds[iIndex] < iItems.Count() ) |
|
470 { |
|
471 TFileName tempFileName; |
|
472 tempFileName.Copy( iItems[iItemIds[iIndex]]->Path() ); |
|
473 TRACE(Print( _L("[STORE MNGR] Filename S.L 16-bit = %S,%d"), |
|
474 &tempFileName, iUploadSession )); |
|
475 if( !IsDuplicateL( iIndex ) ) |
|
476 { |
|
477 TRAPD( err, iUploadSession->StartUploadL( |
|
478 tempFileName, iIndex ) ); |
|
479 |
|
480 if( !err ) |
|
481 { |
|
482 iCopyStatus = ECmSmCopySuccess; |
|
483 } |
|
484 |
|
485 TRAP( err, |
|
486 iUploadSession->StartTrackingProgressL( iIndex ) ); |
|
487 tempFileName.Zero(); |
|
488 if( !err ) |
|
489 { |
|
490 iTransferQueue.InsertInOrder( iIndex ); |
|
491 } |
|
492 copySize += iItems[iItemIds[iIndex]]->Size(); |
|
493 copyCt++; |
|
494 } |
|
495 else |
|
496 { |
|
497 LOG( _L("[STORE MNGR] File already \ |
|
498 on server!Skip file!")); |
|
499 |
|
500 TTime time; |
|
501 time.HomeTime(); |
|
502 AddStoredL( iItems[iItemIds[iIndex]]->Path(), |
|
503 iDevice->Uuid(), time ); |
|
504 HandleItemStatusL( iIndex ); |
|
505 } |
|
506 } |
|
507 iIndex--; |
|
508 if( ( copySize >= KCopySizePerTime || |
|
509 copyCt >= KCopyCountPerTime ) && |
|
510 iIndex != KErrNotFound ) |
|
511 { |
|
512 if( ECmSmCopySuccess != iCopyStatus ) |
|
513 { |
|
514 iCopyStatus = ECmSmCopyContinued; |
|
515 } |
|
516 iObserver->TransferStatus( ECmSmTransferContinued ); |
|
517 } |
|
518 } |
|
519 } |
|
520 } |
|
521 |
|
522 // --------------------------------------------------------------------------- |
|
523 // CCmSmTransferEngine::FinishCopy |
|
524 // --------------------------------------------------------------------------- |
|
525 // |
|
526 void CCmSmTransferEngine::FinishCopy() |
|
527 { |
|
528 LOG( _L("[STORE MNGR] CCmSmTransferEngine::FinishCopy \ |
|
529 No files to be transfered!")); |
|
530 iObserver->TransferStatus( ECmSmTransferCompleted ); |
|
531 CancelCopy(); |
|
532 } |
|
533 |
|
534 // --------------------------------------------------------------------------- |
|
535 // CCmSmTransferEngine::ConnectedToDeviceL |
|
536 // --------------------------------------------------------------------------- |
|
537 // |
|
538 void CCmSmTransferEngine::ConnectedToDeviceL( const CUpnpAVDevice& aDevice ) |
|
539 { |
|
540 LOG( _L("[STORE MNGR] CCmSmTransferEngine::ConnectedToDeviceL")); |
|
541 |
|
542 CancelCopy(); |
|
543 iUploadSession = &iAVController->StartUploadSessionL( aDevice ); |
|
544 iUploadSession->SetObserver( *this ); |
|
545 #ifdef _DEBUG |
|
546 CUpnpAVDevice& device = const_cast< CUpnpAVDevice& >( aDevice ); |
|
547 HBufC* data16bitBuf = HBufC::NewLC( device.FriendlyName().Length() ); |
|
548 TPtr data16bitPtr = data16bitBuf->Des(); |
|
549 TInt conversionError = |
|
550 CnvUtfConverter::ConvertToUnicodeFromUtf8( data16bitPtr, |
|
551 device.FriendlyName() ); |
|
552 |
|
553 TRACE(Print( _L("[STORE MNGR] conversionError = %d"), conversionError )); |
|
554 TRACE(Print( _L("[STORE MNGR] Target device name: %S"), |
|
555 &data16bitPtr )); |
|
556 |
|
557 CleanupStack::PopAndDestroy( data16bitBuf ); |
|
558 |
|
559 data16bitBuf = HBufC::NewLC( device.FriendlyName().Length() ); |
|
560 |
|
561 data16bitPtr = data16bitBuf->Des(); |
|
562 conversionError = |
|
563 CnvUtfConverter::ConvertToUnicodeFromUtf8( data16bitPtr, |
|
564 device.FriendlyName() ); |
|
565 TRACE(Print( _L("[STORE MNGR] conversionError = %d"), conversionError )); |
|
566 TRACE(Print( _L("[STORE MNGR] Targer device id: %S"), |
|
567 &data16bitPtr )); |
|
568 |
|
569 CleanupStack::PopAndDestroy( data16bitBuf ); |
|
570 #endif |
|
571 |
|
572 LOG( _L("[STORE MNGR] ****** Connected to target device ******")); |
|
573 LOG( _L("[STORE MNGR] CCmSmTransferEngine::ConnectedToDeviceL end")); |
|
574 } |
|
575 |
|
576 // --------------------------------------------------------------------------- |
|
577 // CCmSmTransferEngine::AddStoredL |
|
578 // --------------------------------------------------------------------------- |
|
579 // |
|
580 void CCmSmTransferEngine::AddStoredL( const TDesC& aFileName, |
|
581 const TDesC8& aUDN, TTime aTimeStamp ) |
|
582 { |
|
583 LOG(_L("[STORE MNGR]\t CCmSmTransferEngine::AddStoredL")); |
|
584 |
|
585 iDBManager->AddStoredL( aFileName, aUDN, aTimeStamp ); |
|
586 } |
|
587 |
|
588 // --------------------------------------------------------------------------- |
|
589 // CCmSmTransferEngine::HandleItemStatusL |
|
590 // --------------------------------------------------------------------------- |
|
591 // |
|
592 void CCmSmTransferEngine::HandleItemStatusL( const TInt aKey ) |
|
593 { |
|
594 LOG(_L("[STORE MNGR]\t CCmSmTransferEngine::HandleItemStatusL")); |
|
595 |
|
596 RArray<TCmListItemStatus> statusValues; // ownership transferred |
|
597 RArray<TInt> devIds; // ownership transferred |
|
598 |
|
599 TInt index( KErrNotFound ); |
|
600 TCmListItemStatus status( ECmStored ); |
|
601 |
|
602 if( iItemIds[aKey] < iItems.Count() ) |
|
603 { |
|
604 devIds = iItems[iItemIds[aKey]]->DevIds(); |
|
605 statusValues = iItems[iItemIds[aKey]]->StatusValues(); |
|
606 index = devIds.Find( iDevId ); |
|
607 } |
|
608 |
|
609 if( KErrNotFound != index ) |
|
610 { |
|
611 status = statusValues[index]; |
|
612 } |
|
613 TInt countOfStatusVal( KErrNone ); |
|
614 TRACE(Print( _L("[STORE MNGR] Status = %d"), |
|
615 (TInt)status )); |
|
616 TRACE(Print( _L("[STORE MNGR] statusValues.Count() = %d"), |
|
617 statusValues.Count() )); |
|
618 for( TInt i = 0 ; i < statusValues.Count(); i++ ) |
|
619 { |
|
620 if( statusValues[i] == status ) |
|
621 { |
|
622 countOfStatusVal++; |
|
623 } |
|
624 } |
|
625 |
|
626 TRACE(Print( _L("[STORE MNGR] countOfStatusVal = %d"), |
|
627 countOfStatusVal )); |
|
628 if( iItemIds[aKey] < iItems.Count() ) |
|
629 { |
|
630 switch( status ) |
|
631 { |
|
632 case ECmToBeRemoved: |
|
633 { |
|
634 LOG(_L("[STORE MNGR]\t To be removed")); |
|
635 if ( 2 > countOfStatusVal ) |
|
636 { |
|
637 iItems[iItemIds[aKey]]-> |
|
638 UpdateFileStatusL( iDevId, ECmStored ); |
|
639 // Let's mark item to be deleted from the db |
|
640 iToBeDeleted.InsertInOrder( iItemIds[aKey] ); |
|
641 iFilesToBeRemoved->AppendL( |
|
642 iItems[iItemIds[aKey]]->Path() ); |
|
643 } |
|
644 else |
|
645 { |
|
646 iItems[iItemIds[aKey]]-> |
|
647 UpdateFileStatusL( iDevId, ECmStored ); |
|
648 } |
|
649 break; |
|
650 } |
|
651 case ECmToBeShrinked: |
|
652 { |
|
653 LOG(_L("[STORE MNGR]\t To be shrinked")); |
|
654 if ( 2 > countOfStatusVal) |
|
655 { |
|
656 iItems[iItemIds[aKey]]-> |
|
657 UpdateFileStatusL( iDevId, ECmStored ); |
|
658 // Let's mark item to be deleted from the db |
|
659 iToBeDeleted.InsertInOrder( iItemIds[aKey] ); |
|
660 iFilesToBeShrinked->AppendL( |
|
661 iItems[iItemIds[aKey]]->Path() ); |
|
662 } |
|
663 else |
|
664 { |
|
665 iItems[iItemIds[aKey]]-> |
|
666 UpdateFileStatusL( iDevId, ECmStored ); |
|
667 } |
|
668 break; |
|
669 } |
|
670 case ECmKeepOnDevice: |
|
671 { |
|
672 LOG(_L("[STORE MNGR]\t Keep On Device")); |
|
673 if( 2 > countOfStatusVal ) |
|
674 { |
|
675 iItems[iItemIds[aKey]]-> |
|
676 UpdateFileStatusL( iDevId, ECmStored ); |
|
677 // Let's mark item to be deleted from the db |
|
678 iToBeDeleted.InsertInOrder( iItemIds[aKey] ); |
|
679 } |
|
680 else |
|
681 { |
|
682 // If no action needed just change status |
|
683 iItems[iItemIds[aKey]]-> |
|
684 UpdateFileStatusL( iDevId, ECmStored ); |
|
685 } |
|
686 break; |
|
687 } |
|
688 case ECmStored: |
|
689 { |
|
690 LOG(_L("[STORE MNGR]\t already stored")); |
|
691 break; |
|
692 } |
|
693 default: |
|
694 { |
|
695 LOG(_L("[STORE MNGR]\t Wrong status!!!")); |
|
696 TRACE(Print( _L("[STORE MNGR] Status = %d"), (TInt)status )); |
|
697 User::Invariant(); |
|
698 break; |
|
699 } |
|
700 } |
|
701 UpdateStoreTransferStatus( ECmStored, |
|
702 iItems[iItemIds[aKey]]->DbId(), |
|
703 iDevId ); |
|
704 } |
|
705 } |
|
706 |
|
707 // --------------------------------------------------------------------------- |
|
708 // CCmSmTransferEngine::UpdateStoreTransferStatus |
|
709 // --------------------------------------------------------------------------- |
|
710 // |
|
711 void CCmSmTransferEngine::UpdateStoreTransferStatus( TUint aStatus, |
|
712 TInt64 aFid, TInt64 aMsId ) |
|
713 { |
|
714 LOG(_L("[STORE MNGR]\t CCmSmTransferEngine::UpdateStoreTransferStatus")); |
|
715 |
|
716 iDBManager->UpdateStoreTransferStatus( aStatus, aFid, aMsId ); |
|
717 } |
|
718 |
|
719 // --------------------------------------------------------------------------- |
|
720 // CCmSmTransferEngine::GetArrayIndex |
|
721 // --------------------------------------------------------------------------- |
|
722 // |
|
723 TInt CCmSmTransferEngine::GetArrayIndex( TInt aKey ) |
|
724 { |
|
725 LOG(_L("[STORE MNGR]\t CCmSmTransferEngine::GetArrayIndex")); |
|
726 |
|
727 TInt index( 0 ); |
|
728 for( TInt i = 0; i < iItemIds.Count(); i++ ) |
|
729 { |
|
730 if( iItems[iItemIds[i]]->DbId() == aKey ) |
|
731 { |
|
732 index = i; |
|
733 // End loop |
|
734 i = iItemIds.Count(); |
|
735 } |
|
736 } |
|
737 return index; |
|
738 } |
|
739 |
|
740 // --------------------------------------------------------------------------- |
|
741 // CCmSmTransferEngine::IsDuplicateL |
|
742 // --------------------------------------------------------------------------- |
|
743 // |
|
744 TBool CCmSmTransferEngine::IsDuplicateL( const TInt aIndex ) |
|
745 { |
|
746 LOG(_L("[STORE MNGR]\t CCmSmTransferEngine::IsDuplicateL")); |
|
747 |
|
748 return iDbWrapper->ExistsL( *iItems[iItemIds[aIndex]], iDevId ); |
|
749 } |
|
750 |
|
751 // End of file |
|
752 |
|
753 |
|