1 /* |
|
2 * Copyright (c) 2006-2007 Nokia Corporation and/or its subsidiary(-ies). |
|
3 * All rights reserved. |
|
4 * This component and the accompanying materials are made available |
|
5 * under the terms of "Eclipse Public License v1.0" |
|
6 * which accompanies this distribution, and is available |
|
7 * at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
8 * |
|
9 * Initial Contributors: |
|
10 * Nokia Corporation - initial contribution. |
|
11 * |
|
12 * Contributors: |
|
13 * |
|
14 * Description: Processor |
|
15 * |
|
16 */ |
|
17 |
|
18 |
|
19 #include <e32base.h> |
|
20 |
|
21 #include <mdeconstants.h> |
|
22 #include <centralrepository.h> |
|
23 |
|
24 #include <mpxcollectionutility.h> |
|
25 #include <mpxmessagegeneraldefs.h> |
|
26 #include <mpxcollectionmessage.h> |
|
27 #include <coreapplicationuisdomainpskeys.h> |
|
28 |
|
29 #include "thumbagprocessor.h" |
|
30 #include "thumbnaillog.h" |
|
31 #include "thumbnailmanagerconstants.h" |
|
32 #include "thumbnailmanagerprivatecrkeys.h" |
|
33 #include "OstTraceDefinitions.h" |
|
34 #ifdef OST_TRACE_COMPILER_IN_USE |
|
35 #include "thumbagprocessorTraces.h" |
|
36 #endif |
|
37 |
|
38 // --------------------------------------------------------------------------- |
|
39 // CThumbAGProcessor::NewL() |
|
40 // --------------------------------------------------------------------------- |
|
41 // |
|
42 CThumbAGProcessor* CThumbAGProcessor::NewL() |
|
43 { |
|
44 TN_DEBUG1( "CThumbAGProcessor::NewL() - begin" ); |
|
45 OstTrace0( TRACE_NORMAL, CTHUMBAGPROCESSOR_NEWL, "CThumbAGProcessor::NewL - begin" ); |
|
46 |
|
47 CThumbAGProcessor* self = new( ELeave )CThumbAGProcessor(); |
|
48 CleanupStack::PushL( self ); |
|
49 self->ConstructL(); |
|
50 CleanupStack::Pop( self ); |
|
51 return self; |
|
52 } |
|
53 |
|
54 // --------------------------------------------------------------------------- |
|
55 // CThumbAGProcessor::CThumbAGProcessor() |
|
56 // --------------------------------------------------------------------------- |
|
57 // |
|
58 CThumbAGProcessor::CThumbAGProcessor(): CActive( CActive::EPriorityStandard ), iMMCHarvestingItemsLeftTemp(0), |
|
59 iPHHarvestingItemsLeftTemp(0) |
|
60 { |
|
61 TN_DEBUG1( "CThumbAGProcessor::CThumbAGProcessor() - begin" ); |
|
62 OstTrace0( TRACE_NORMAL, CTHUMBAGPROCESSOR_CTHUMBAGPROCESSOR, "CThumbAGProcessor::CThumbAGProcessor- begin" ); |
|
63 |
|
64 CActiveScheduler::Add( this ); |
|
65 } |
|
66 |
|
67 // --------------------------------------------------------------------------- |
|
68 // CThumbAGProcessor::ConstructL() |
|
69 // --------------------------------------------------------------------------- |
|
70 // |
|
71 void CThumbAGProcessor::ConstructL() |
|
72 { |
|
73 TN_DEBUG1( "CThumbAGProcessor::ConstructL() - begin" ); |
|
74 OstTrace0( TRACE_NORMAL, CTHUMBAGPROCESSOR_CONSTRUCTL, "CThumbAGProcessor::ConstructL - begin" ); |
|
75 |
|
76 iShutdown = EFalse; |
|
77 |
|
78 iTMSession = CThumbnailManager::NewL( *this ); |
|
79 iTMSession->SetRequestObserver(*this); |
|
80 |
|
81 iQueryAllItems = NULL; |
|
82 iQueryPlaceholders = NULL; |
|
83 iQuery = NULL; |
|
84 iQueryActive = EFalse; |
|
85 iModify = EFalse; |
|
86 iProcessingCount = 0; |
|
87 |
|
88 iActiveCount = 0; |
|
89 |
|
90 // set auto create values from cenrep |
|
91 CheckAutoCreateValuesL(); |
|
92 |
|
93 iPeriodicTimer = CPeriodic::NewL(CActive::EPriorityStandard); |
|
94 |
|
95 iMountTimer = CPeriodic::NewL(CActive::EPriorityUserInput); |
|
96 |
|
97 SetForceRun( EFalse ); |
|
98 |
|
99 iFormatObserver = CTMFormatObserver::NewL( *this ); |
|
100 |
|
101 iFormatting = EFalse; |
|
102 iSessionDied = EFalse; |
|
103 |
|
104 iCollectionUtility = NULL; |
|
105 |
|
106 iActivityManager = CTMActivityManager::NewL( this, KBackgroundGenerationIdle); |
|
107 |
|
108 UpdatePSValues(ETrue, ETrue); |
|
109 |
|
110 RProperty::Define(KTAGDPSNotification, KMPXHarvesting, RProperty::EInt); |
|
111 |
|
112 //start foreground generation observer |
|
113 iForegroundGenerationObserver = CTMRPropertyObserver::NewL( *this, KTAGDPSNotification, KForceBackgroundGeneration, ETrue ); |
|
114 |
|
115 TN_DEBUG1( "CThumbAGProcessor::ConstructL() - end" ); |
|
116 OstTrace0( TRACE_NORMAL, DUP1_CTHUMBAGPROCESSOR_CONSTRUCTL, "CThumbAGProcessor::ConstructL - end" ); |
|
117 } |
|
118 |
|
119 // --------------------------------------------------------------------------- |
|
120 // CThumbAGProcessor::~CThumbAGProcessor() |
|
121 // --------------------------------------------------------------------------- |
|
122 // |
|
123 CThumbAGProcessor::~CThumbAGProcessor() |
|
124 { |
|
125 TN_DEBUG1( "CThumbAGProcessor::~CThumbAGProcessor() - begin" ); |
|
126 OstTrace0( TRACE_NORMAL, DUP1_CTHUMBAGPROCESSOR_CTHUMBAGPROCESSOR, "CThumbAGProcessor::~CThumbAGProcessor - begin" ); |
|
127 |
|
128 Shutdown(); |
|
129 |
|
130 Cancel(); |
|
131 |
|
132 if (iTMSession) |
|
133 { |
|
134 iTMSession->RemoveRequestObserver(); |
|
135 delete iTMSession; |
|
136 iTMSession = NULL; |
|
137 } |
|
138 |
|
139 if(iMountTimer) |
|
140 { |
|
141 iMountTimer->Cancel(); |
|
142 delete iMountTimer; |
|
143 iMountTimer = NULL; |
|
144 } |
|
145 |
|
146 if(iPeriodicTimer) |
|
147 { |
|
148 iPeriodicTimer->Cancel(); |
|
149 delete iPeriodicTimer; |
|
150 iPeriodicTimer = NULL; |
|
151 } |
|
152 |
|
153 if(iActivityManager) |
|
154 { |
|
155 delete iActivityManager; |
|
156 iActivityManager = NULL; |
|
157 } |
|
158 |
|
159 if (iQuery) |
|
160 { |
|
161 iQuery->Cancel(); |
|
162 delete iQuery; |
|
163 iQuery = NULL; |
|
164 } |
|
165 |
|
166 if(iQueryPlaceholders) |
|
167 { |
|
168 iQueryPlaceholders->Cancel(); |
|
169 delete iQueryPlaceholders; |
|
170 iQueryPlaceholders = NULL; |
|
171 } |
|
172 |
|
173 if (iQueryAllItems) |
|
174 { |
|
175 iQueryAllItems->Cancel(); |
|
176 delete iQueryAllItems; |
|
177 iQueryAllItems = NULL; |
|
178 } |
|
179 |
|
180 if (!iInit) |
|
181 { |
|
182 #ifdef MDS_MODIFY_OBSERVER |
|
183 iHarvesterClient.RemoveHarvesterEventObserver(*this); |
|
184 iHarvesterClient.Close(); |
|
185 #endif |
|
186 } |
|
187 |
|
188 if(iForegroundGenerationObserver) |
|
189 { |
|
190 delete iForegroundGenerationObserver; |
|
191 iForegroundGenerationObserver = NULL; |
|
192 } |
|
193 |
|
194 if(iFormatObserver) |
|
195 { |
|
196 delete iFormatObserver; |
|
197 iFormatObserver = NULL; |
|
198 } |
|
199 |
|
200 if ( iCollectionUtility ) |
|
201 { |
|
202 iCollectionUtility->Close(); |
|
203 iCollectionUtility = NULL; |
|
204 } |
|
205 |
|
206 for(TInt i=0;i<iGenerationQueue.Count();i++) |
|
207 { |
|
208 delete iGenerationQueue[i].iUri; |
|
209 iGenerationQueue[i].iUri = NULL; |
|
210 } |
|
211 |
|
212 iGenerationQueue.Reset(); |
|
213 iGenerationQueue.Close(); |
|
214 |
|
215 iQueryQueue.Close(); |
|
216 |
|
217 TN_DEBUG1( "CThumbAGProcessor::~CThumbAGProcessor() - end" ); |
|
218 OstTrace0( TRACE_NORMAL, DUP2_CTHUMBAGPROCESSOR_CTHUMBAGPROCESSOR, "CThumbAGProcessor::~CThumbAGProcessor - end" ); |
|
219 } |
|
220 |
|
221 // --------------------------------------------------------------------------- |
|
222 // CThumbAGProcessor::Shutdown() |
|
223 // --------------------------------------------------------------------------- |
|
224 // |
|
225 void CThumbAGProcessor::Shutdown() |
|
226 { |
|
227 TN_DEBUG1( "CThumbAGProcessor::Shutdown()" ); |
|
228 OstTrace0( TRACE_NORMAL, CTHUMBAGPROCESSOR_SHUTDOWN, "CThumbAGProcessor::Shutdown" ); |
|
229 iShutdown = ETrue; |
|
230 UpdatePSValues(EFalse, EFalse); |
|
231 } |
|
232 |
|
233 // ----------------------------------------------------------------------------- |
|
234 // CThumbAGProcessor::HandleQueryNewResults() |
|
235 // ----------------------------------------------------------------------------- |
|
236 // |
|
237 void CThumbAGProcessor::HandleQueryNewResults( CMdEQuery& aQuery, |
|
238 const TInt aFirstNewItemIndex, |
|
239 const TInt aNewItemCount ) |
|
240 { |
|
241 // PH & AllItems query results are handled here |
|
242 |
|
243 if(iShutdown) |
|
244 { |
|
245 return; |
|
246 } |
|
247 |
|
248 if (aNewItemCount > 0) |
|
249 { |
|
250 if(&aQuery == iQueryPlaceholders) |
|
251 { |
|
252 TN_DEBUG2( "CThumbAGProcessor::HandleQueryNewResults - iQueryPlaceholders, %d new", aNewItemCount); |
|
253 OstTrace1( TRACE_NORMAL, CTHUMBAGPROCESSOR_HANDLEQUERYNEWRESULTS, "CThumbAGProcessor::HandleQueryNewResults - iQueryPlaceholders;aNewItemCount=%d", aNewItemCount ); |
|
254 |
|
255 for(TInt i = aFirstNewItemIndex; i < iQueryPlaceholders->Count(); i++) |
|
256 { |
|
257 const CMdEObject* object = &iQueryPlaceholders->Result(i); |
|
258 |
|
259 if(!object) |
|
260 { |
|
261 continue; |
|
262 } |
|
263 |
|
264 if(!object->Placeholder()) |
|
265 { |
|
266 TN_DEBUG2( "CThumbAGProcessor::HandleQueryNewResults %d not placeholder", object->Id()); |
|
267 OstTrace1( TRACE_NORMAL, DUP1_CTHUMBAGPROCESSOR_HANDLEQUERYNEWRESULTS, "CThumbAGProcessor::HandleQueryNewResults - not placeholder;object->Id()=%u", object->Id() ); |
|
268 continue; |
|
269 } |
|
270 |
|
271 // ignore if fails |
|
272 TThumbnailGenerationItem item; |
|
273 item.iItemId = object->Id(); |
|
274 item.iPlaceholder = ETrue; |
|
275 |
|
276 SetGenerationItemType( item, object->Def().Id()); |
|
277 |
|
278 AppendProcessingQueue( item ); |
|
279 } |
|
280 } |
|
281 else if(&aQuery == iQueryAllItems) |
|
282 { |
|
283 TN_DEBUG2( "CThumbAGProcessor::HandleQueryNewResults - QueryAllItems, %d new", aNewItemCount); |
|
284 OstTrace1( TRACE_NORMAL, DUP2_CTHUMBAGPROCESSOR_HANDLEQUERYNEWRESULTS, "CThumbAGProcessor::HandleQueryNewResults - QueryAllItems;aNewItemCount=%d", aNewItemCount ); |
|
285 |
|
286 for(TInt i = aFirstNewItemIndex; i < iQueryAllItems->Count(); i++) |
|
287 { |
|
288 const CMdEObject* object = &iQueryAllItems->Result(i); |
|
289 |
|
290 if(!object) |
|
291 { |
|
292 continue; |
|
293 } |
|
294 |
|
295 TThumbnailGenerationItem item; |
|
296 item.iItemId = object->Id(); |
|
297 |
|
298 SetGenerationItemType(item, object->Def().Id()); |
|
299 |
|
300 TInt itemIndex = iGenerationQueue.FindInOrder(item, Compare); |
|
301 |
|
302 item.iPlaceholder = object->Placeholder(); |
|
303 |
|
304 AppendProcessingQueue( item ); |
|
305 } |
|
306 } |
|
307 } |
|
308 else |
|
309 { |
|
310 TN_DEBUG1( "CThumbAGProcessor::HandleQueryNewResults - error, no new items"); |
|
311 OstTrace0( TRACE_NORMAL, DUP3_CTHUMBAGPROCESSOR_HANDLEQUERYNEWRESULTS, "CThumbAGProcessor::HandleQueryNewResults - error, no new items" ); |
|
312 } |
|
313 } |
|
314 |
|
315 // ----------------------------------------------------------------------------- |
|
316 // CThumbAGProcessor::HandleQueryCompleted() |
|
317 // ----------------------------------------------------------------------------- |
|
318 // |
|
319 void CThumbAGProcessor::HandleQueryCompleted( CMdEQuery& aQuery, const TInt aError ) |
|
320 { |
|
321 TN_DEBUG3( "CThumbAGProcessor::HandleQueryCompleted, aError == %d Count== %d", aError, aQuery.Count()); |
|
322 OstTraceExt2( TRACE_NORMAL, CTHUMBAGPROCESSOR_HANDLEQUERYCOMPLETED, "CThumbAGProcessor::HandleQueryCompleted;aError=%d;aQuery.Count()=%d", aError, aQuery.Count() ); |
|
323 |
|
324 if(iShutdown) |
|
325 { |
|
326 return; |
|
327 } |
|
328 |
|
329 if(&aQuery == iQueryPlaceholders) |
|
330 { |
|
331 TN_DEBUG1( "CThumbAGProcessor::HandleQueryCompleted - iQueryPlaceholders completed"); |
|
332 OstTrace0( TRACE_NORMAL, DUP1_CTHUMBAGPROCESSOR_HANDLEQUERYCOMPLETED, "CThumbAGProcessor::HandleQueryCompleted - iQueryPlaceholders completed" ); |
|
333 |
|
334 //free query |
|
335 delete iQueryPlaceholders; |
|
336 iQueryPlaceholders = NULL; |
|
337 |
|
338 if(iDoQueryAllItems) |
|
339 { |
|
340 iDoQueryAllItems = EFalse; |
|
341 TRAP_IGNORE(QueryAllItemsL()); |
|
342 } |
|
343 } |
|
344 else if(&aQuery == iQueryAllItems) |
|
345 { |
|
346 TN_DEBUG1( "CThumbAGProcessor::HandleQueryCompleted - QueryAllItems completed"); |
|
347 OstTrace0( TRACE_NORMAL, DUP2_CTHUMBAGPROCESSOR_HANDLEQUERYCOMPLETED, "CThumbAGProcessor::HandleQueryCompleted - QueryAllItems completed" ); |
|
348 |
|
349 #ifdef _DEBUG |
|
350 TN_DEBUG2( "CThumbAGProcessor::HandleQueryCompleted IN-COUNTERS---------- Amount: %d, Add",iQueryAllItems->Count()); |
|
351 OstTrace1( TRACE_NORMAL, DUP3_CTHUMBAGPROCESSOR_HANDLEQUERYCOMPLETED, "CThumbAGProcessor::HandleQueryCompleted IN-COUNTERS---------- Amount;iQueryAllItems->Count()=%d", iQueryAllItems->Count() ); |
|
352 #endif |
|
353 |
|
354 //free query |
|
355 delete iQueryAllItems; |
|
356 iQueryAllItems = NULL; |
|
357 } |
|
358 else if(&aQuery == iQuery ) |
|
359 { |
|
360 TN_DEBUG1( "CThumbAGProcessor::HandleQueryCompleted - Query completed"); |
|
361 OstTrace0( TRACE_NORMAL, DUP4_CTHUMBAGPROCESSOR_HANDLEQUERYCOMPLETED, "CThumbAGProcessor::HandleQueryCompleted - Query completed" ); |
|
362 |
|
363 if(iQueryActive) |
|
364 { |
|
365 iQueryReady = ETrue; |
|
366 iQueryActive = EFalse; |
|
367 } |
|
368 |
|
369 // if no errors in query |
|
370 if (aError == KErrNone && iQuery) |
|
371 { |
|
372 iProcessingCount = iQuery->Count(); |
|
373 |
|
374 if(iProcessingCount != iQueryQueue.Count() ) |
|
375 { |
|
376 TN_DEBUG1( "CThumbAGProcessor::HandleQueryCompleted() some result items missing"); |
|
377 OstTrace0( TRACE_NORMAL, DUP5_CTHUMBAGPROCESSOR_HANDLEQUERYCOMPLETED, "CThumbAGProcessor::HandleQueryCompleted - some result items missing" ); |
|
378 |
|
379 RArray<TItemId> queryQueueDelta; |
|
380 |
|
381 //search delta items which were queried, but not found |
|
382 for(TInt queryItem =0; queryItem < iQueryQueue.Count();queryItem++) |
|
383 { |
|
384 TBool found(EFalse); |
|
385 for(TInt queryResult = 0; queryResult < iQuery->Count(); queryResult++) |
|
386 { |
|
387 const CMdEObject* object = &iQuery->Result(queryResult); |
|
388 |
|
389 if( iQueryQueue[queryItem] == object->Id()) |
|
390 { |
|
391 found = ETrue; |
|
392 break; |
|
393 } |
|
394 } |
|
395 |
|
396 if(!found) |
|
397 { |
|
398 TN_DEBUG2( "CThumbAGProcessor::HandleQueryCompleted() %d missing from query results", iQueryQueue[queryItem] ); |
|
399 OstTrace1( TRACE_NORMAL, DUP6_CTHUMBAGPROCESSOR_HANDLEQUERYCOMPLETED, "CThumbAGProcessor::HandleQueryCompleted;iQueryQueue[queryItem]=%d", iQueryQueue[queryItem] ); |
|
400 |
|
401 // ignore if fails |
|
402 queryQueueDelta.InsertInOrder(iQueryQueue[queryItem], CompareId); |
|
403 } |
|
404 } |
|
405 |
|
406 TN_DEBUG2( "CThumbAGProcessor::HandleQueryCompleted() missing items found %d", queryQueueDelta.Count()); |
|
407 OstTrace1( TRACE_NORMAL, DUP7_CTHUMBAGPROCESSOR_HANDLEQUERYCOMPLETED, "CThumbAGProcessor::HandleQueryCompleted - missing items found;queryQueueDelta.Count()=%d", queryQueueDelta.Count() ); |
|
408 //cleanup from previous queue it item is not found from MDS |
|
409 while(queryQueueDelta.Count()) |
|
410 { |
|
411 TThumbnailGenerationItem item; |
|
412 item.iItemId = queryQueueDelta[0]; |
|
413 TInt itemIndex = iQueryQueue.FindInOrder(item.iItemId, CompareId); |
|
414 |
|
415 if(itemIndex >= 0) |
|
416 { |
|
417 TN_DEBUG2( "CThumbAGProcessor::HandleQueryCompleted() remove %d from iQueryQueue", queryQueueDelta[0]); |
|
418 OstTrace1( TRACE_NORMAL, DUP8_CTHUMBAGPROCESSOR_HANDLEQUERYCOMPLETED, "CThumbAGProcessor::HandleQueryCompleted - remove from iQueryQueue;queryQueueDelta[0]=%d", queryQueueDelta[0] ); |
|
419 iQueryQueue.Remove( itemIndex ); |
|
420 |
|
421 //remove from procesing queue |
|
422 itemIndex = iGenerationQueue.FindInOrder(item, Compare); |
|
423 |
|
424 if(itemIndex >= 0) |
|
425 { |
|
426 |
|
427 if( iUnknown ) |
|
428 { |
|
429 TN_DEBUG2( "CThumbAGProcessor::HandleQueryCompleted() mark %d as EGenerationItemTypeNotFound in iGenerationQueue", queryQueueDelta[0]); |
|
430 OstTrace1( TRACE_NORMAL, DUP9_CTHUMBAGPROCESSOR_HANDLEQUERYCOMPLETED, "CThumbAGProcessor::HandleQueryCompleted - mark as EGenerationItemTypeNotFound in iGenerationQueue;queryQueueDelta[0]=%d", queryQueueDelta[0] ); |
|
431 //mark to be removed, cleanup is done below |
|
432 iGenerationQueue[itemIndex].iItemType = EGenerationItemTypeNotFound; |
|
433 } |
|
434 else |
|
435 { |
|
436 TN_DEBUG2( "CThumbAGProcessor::HandleQueryCompleted() remove %d from iGenerationQueue", queryQueueDelta[0]); |
|
437 OstTrace1( TRACE_NORMAL, DUP10_CTHUMBAGPROCESSOR_HANDLEQUERYCOMPLETED, "CThumbAGProcessor::HandleQueryCompleted - remove from iGenerationQueue;queryQueueDelta[0]=%d", queryQueueDelta[0] ); |
|
438 iGenerationQueue.Remove( itemIndex ); |
|
439 } |
|
440 } |
|
441 } |
|
442 queryQueueDelta.Remove(0); |
|
443 } |
|
444 queryQueueDelta.Close(); |
|
445 } |
|
446 |
|
447 if(iUnknown) |
|
448 { |
|
449 for(TInt i = 0; i < iQuery->Count(); i++) |
|
450 { |
|
451 const CMdEObject* object = &iQuery->Result(i); |
|
452 |
|
453 if(!object) |
|
454 { |
|
455 continue; |
|
456 } |
|
457 |
|
458 TThumbnailGenerationItem tempItem; |
|
459 tempItem.iItemId = object->Id(); |
|
460 TInt itemIndex = iGenerationQueue.FindInOrder(tempItem, Compare); |
|
461 |
|
462 if(itemIndex >= 0) |
|
463 { |
|
464 TThumbnailGenerationItem& item = iGenerationQueue[itemIndex]; |
|
465 |
|
466 if(iGenerationQueue[itemIndex].iItemType == EGenerationItemTypeNotFound) |
|
467 { |
|
468 TN_DEBUG2( "CThumbAGProcessor::HandleQueryCompleted() remove EGenerationItemTypeNotFound %d item from iGenerationQueue", item.iItemId); |
|
469 OstTrace1( TRACE_NORMAL, DUP11_CTHUMBAGPROCESSOR_HANDLEQUERYCOMPLETED, "CThumbAGProcessor::HandleQueryCompleted - remove EGenerationItemTypeNotFound item from iGenerationQueue;item.iItemId=%u", item.iItemId ); |
|
470 iGenerationQueue.Remove(itemIndex); |
|
471 continue; |
|
472 } |
|
473 |
|
474 SetGenerationItemType(item, object->Def().Id()); |
|
475 |
|
476 if(item.iItemType == EGenerationItemTypeUnknown ) |
|
477 { |
|
478 TN_DEBUG2( "CThumbAGProcessor::HandleQueryCompleted() remove unknown item %d", item.iItemId); |
|
479 OstTrace1( TRACE_NORMAL, DUP12_CTHUMBAGPROCESSOR_HANDLEQUERYCOMPLETED, "CThumbAGProcessor::HandleQueryCompleted - remove unknown item;item.iItemId=%u", item.iItemId ); |
|
480 iGenerationQueue.Remove(itemIndex); |
|
481 continue; |
|
482 } |
|
483 |
|
484 item.iPlaceholder = object->Placeholder(); |
|
485 |
|
486 } |
|
487 } |
|
488 |
|
489 iQueryQueue.Reset(); |
|
490 iProcessingCount = 0; |
|
491 iUnknown = EFalse; |
|
492 } |
|
493 |
|
494 // no results, reset query |
|
495 if( !iProcessingCount ) |
|
496 { |
|
497 delete iQuery; |
|
498 iQuery = NULL; |
|
499 iModify = EFalse; |
|
500 } |
|
501 } |
|
502 else |
|
503 { |
|
504 //Delete and cancel query, do not return items back to original queue |
|
505 DeleteAndCancelQuery( EFalse ); |
|
506 TN_DEBUG1( "CThumbAGProcessor::HandleQueryCompleted() Query FAILED!"); |
|
507 OstTrace0( TRACE_NORMAL, DUP13_CTHUMBAGPROCESSOR_HANDLEQUERYCOMPLETED, "CThumbAGProcessor::HandleQueryCompleted - Query FAILED!" ); |
|
508 } |
|
509 } |
|
510 else |
|
511 { |
|
512 TN_DEBUG1( "CThumbAGProcessor::HandleQueryCompleted() - NO QUERY ACTIVE"); |
|
513 OstTrace0( TRACE_NORMAL, DUP14_CTHUMBAGPROCESSOR_HANDLEQUERYCOMPLETED, "CThumbAGProcessor::HandleQueryCompleted - NO QUERY ACTIVE" ); |
|
514 __ASSERT_DEBUG((EFalse), User::Panic(_L("CThumbAGProcessor::HandleQueryCompleted()"), -1)); |
|
515 } |
|
516 |
|
517 ActivateAO(); |
|
518 } |
|
519 |
|
520 // ----------------------------------------------------------------------------- |
|
521 // CThumbAGProcessor::ThumbnailPreviewReady() |
|
522 // ----------------------------------------------------------------------------- |
|
523 // |
|
524 void CThumbAGProcessor::ThumbnailPreviewReady( MThumbnailData& /*aThumbnail*/, |
|
525 TThumbnailRequestId /*aId*/) |
|
526 { |
|
527 TN_DEBUG1( "CThumbAGProcessor::ThumbnailPreviewReady()"); |
|
528 OstTrace0( TRACE_NORMAL, CTHUMBAGPROCESSOR_THUMBNAILPREVIEWREADY, "CThumbAGProcessor::ThumbnailPreviewReady" ); |
|
529 // No implementation required |
|
530 } |
|
531 |
|
532 // ----------------------------------------------------------------------------- |
|
533 // CThumbAGProcessor::ThumbnailReady()d |
|
534 // ----------------------------------------------------------------------------- |
|
535 // |
|
536 void CThumbAGProcessor::ThumbnailReady( TInt aError, MThumbnailData& /*aThumbnail*/, |
|
537 TThumbnailRequestId /*aId*/ ) |
|
538 { |
|
539 TN_DEBUG2( "CThumbAGProcessor::ThumbnailReady() aError == %d", aError ); |
|
540 OstTrace1( TRACE_NORMAL, CTHUMBAGPROCESSOR_THUMBNAILREADY, "CThumbAGProcessor::ThumbnailReady;aError=%d", aError ); |
|
541 |
|
542 iActiveCount--; |
|
543 |
|
544 // TNM server died, delete session |
|
545 if( aError == KErrServerTerminated ) |
|
546 { |
|
547 TN_DEBUG1( "CThumbAGProcessor::ThumbnailReady() - **** THUMBNAIL SERVER DIED ****" ); |
|
548 OstTrace0( TRACE_NORMAL, DUP1_CTHUMBAGPROCESSOR_THUMBNAILREADY, "CThumbAGProcessor::ThumbnailReady - **** THUMBNAIL SERVER DIED ****" ); |
|
549 |
|
550 iSessionDied = ETrue; |
|
551 |
|
552 if( !iPeriodicTimer->IsActive()) |
|
553 { |
|
554 StartTimeout(); |
|
555 } |
|
556 |
|
557 //reset PS idle so that RunL() can startup reopen TNM session and proceed |
|
558 TInt ret = RProperty::Set(KServerIdle, KIdle, ETrue); |
|
559 TN_DEBUG2( "CThumbAGProcessor::ThumbnailReady() set Idle ret = %d", ret ); |
|
560 OstTrace1( TRACE_NORMAL, DUP2_CTHUMBAGPROCESSOR_THUMBNAILREADY, "CThumbAGProcessor::ThumbnailReady - set Idle ret;ret=%d", ret ); |
|
561 return; |
|
562 } |
|
563 |
|
564 ActivateAO(); |
|
565 |
|
566 TN_DEBUG1( "CThumbAGProcessor::ThumbnailReady() - end" ); |
|
567 OstTrace0( TRACE_NORMAL, DUP3_CTHUMBAGPROCESSOR_THUMBNAILREADY, "CThumbAGProcessor::ThumbnailReady - end" ); |
|
568 } |
|
569 |
|
570 // ----------------------------------------------------------------------------- |
|
571 // CThumbAGProcessor::ThumbnailRequestReady() |
|
572 // ----------------------------------------------------------------------------- |
|
573 // |
|
574 void CThumbAGProcessor::ThumbnailRequestReady( TInt /*aError*/, TThumbnailRequestType aRequestType, |
|
575 TThumbnailRequestId /*aId*/ ) |
|
576 { |
|
577 if (aRequestType == ERequestDeleteThumbnails) |
|
578 { |
|
579 TN_DEBUG1( "CThumbAGProcessor::ThumbnailRequestReady() - delete" ); |
|
580 OstTrace0( TRACE_NORMAL, CTHUMBAGPROCESSOR_THUMBNAILREQUESTREADY, "CThumbAGProcessor::ThumbnailRequestReady - delete" ); |
|
581 |
|
582 iActiveCount--; |
|
583 |
|
584 ActivateAO(); |
|
585 } |
|
586 } |
|
587 |
|
588 // --------------------------------------------------------------------------- |
|
589 // CThumbAGProcessor::SetMdESession() |
|
590 // --------------------------------------------------------------------------- |
|
591 // |
|
592 void CThumbAGProcessor::SetMdESessionL( CMdESession* aMdESession ) |
|
593 { |
|
594 TN_DEBUG1( "CThumbAGProcessor::SetMdESession() - begin" ); |
|
595 OstTrace0( TRACE_NORMAL, CTHUMBAGPROCESSOR_SETMDESESSIONL, "CThumbAGProcessor::SetMdESessionL - begin" ); |
|
596 |
|
597 iMdESession = aMdESession; |
|
598 |
|
599 __ASSERT_DEBUG((iMdESession), User::Panic(_L("CThumbAGProcessor::SetMdESession() !iMdESession "), KErrBadHandle)); |
|
600 |
|
601 TRAPD( err, iDefNamespace = &iMdESession->GetDefaultNamespaceDefL() ); |
|
602 if (err != KErrNone) |
|
603 { |
|
604 TN_DEBUG2( "CThumbAGProcessor::SetMdESession() GetDefaultNamespaceDefL() err = %d", err ); |
|
605 OstTrace1( TRACE_NORMAL, DUP1_CTHUMBAGPROCESSOR_SETMDESESSIONL, "CThumbAGProcessor::SetMdESessionL;err=%d", err ); |
|
606 __ASSERT_DEBUG((iDefNamespace), User::Panic(_L("CThumbAGProcessor::SetMdESession() !iDefNamespace "), KErrBadHandle)); |
|
607 } |
|
608 else |
|
609 { |
|
610 iImageObjectDef = &iDefNamespace->GetObjectDefL( MdeConstants::Image::KImageObject ); |
|
611 __ASSERT_DEBUG((iImageObjectDef), User::Panic(_L("CThumbAGProcessor::SetMdESession() !iDefNamespace "), KErrBadHandle)); |
|
612 iVideoObjectDef = &iDefNamespace->GetObjectDefL( MdeConstants::Video::KVideoObject ); |
|
613 __ASSERT_DEBUG((iVideoObjectDef), User::Panic(_L("CThumbAGProcessor::SetMdESession() !iVideoObjectDef "), KErrBadHandle)); |
|
614 iAudioObjectDef = &iDefNamespace->GetObjectDefL( MdeConstants::Audio::KAudioObject ); |
|
615 __ASSERT_DEBUG((iAudioObjectDef), User::Panic(_L("CThumbAGProcessor::SetMdESession() !iAudioObjectDef "), KErrBadHandle)); |
|
616 |
|
617 //do async init |
|
618 iInit = ETrue; |
|
619 |
|
620 ActivateAO(); |
|
621 } |
|
622 } |
|
623 |
|
624 // --------------------------------------------------------------------------- |
|
625 // CThumbAGProcessor::AddToQueue() |
|
626 // --------------------------------------------------------------------------- |
|
627 // |
|
628 void CThumbAGProcessor::AddToQueueL( TObserverNotificationType aType, |
|
629 TThumbnailGenerationItemType aItemType, |
|
630 const RArray<TItemId>& aIDArray, |
|
631 const RPointerArray<HBufC>& aObjectUriArray, |
|
632 TBool /*aPresent*/ ) |
|
633 { |
|
634 TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - begin" ); |
|
635 OstTrace0( TRACE_NORMAL, CTHUMBAGPROCESSOR_ADDTOQUEUEL, "CThumbAGProcessor::AddToQueueL - begin" ); |
|
636 |
|
637 // update queues |
|
638 if (aType == ENotifyAdd) |
|
639 { |
|
640 TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - ENotifyAdd" ); |
|
641 |
|
642 for (int i=0; i<aIDArray.Count(); i++) |
|
643 { |
|
644 TThumbnailGenerationItem item; |
|
645 item.iItemId = aIDArray[i]; |
|
646 item.iItemType = aItemType; |
|
647 |
|
648 SetGenerationItemAction(item, aItemType); |
|
649 |
|
650 if(iPHHarvesting) |
|
651 { |
|
652 item.iPlaceholder = ETrue; |
|
653 } |
|
654 |
|
655 AppendProcessingQueue( item ); |
|
656 } |
|
657 } |
|
658 else if (aType == ENotifyModify) |
|
659 { |
|
660 TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - ENotifyModify" ); |
|
661 OstTrace0( TRACE_NORMAL, DUP1_CTHUMBAGPROCESSOR_ADDTOQUEUEL, "CThumbAGProcessor::AddToQueueL - ENotifyModify" ); |
|
662 |
|
663 if(iPHHarvesting) |
|
664 { |
|
665 TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - PH harvesting active, treat like add" ); |
|
666 OstTrace0( TRACE_NORMAL, DUP2_CTHUMBAGPROCESSOR_ADDTOQUEUEL, "CThumbAGProcessor::AddToQueueL - PH harvesting active, treat like add" ); |
|
667 for (int i=0; i<aIDArray.Count(); i++) |
|
668 { |
|
669 TThumbnailGenerationItem item; |
|
670 item.iItemId = aIDArray[i]; |
|
671 item.iItemType = aItemType; |
|
672 |
|
673 TInt itemIndex = iGenerationQueue.FindInOrder(item, Compare); |
|
674 |
|
675 if (itemIndex >= 0) |
|
676 { |
|
677 TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - set as non-placeholder"); |
|
678 OstTrace0( TRACE_NORMAL, DUP3_CTHUMBAGPROCESSOR_ADDTOQUEUEL, "CThumbAGProcessor::AddToQueueL - set as non-placeholder" ); |
|
679 iGenerationQueue[itemIndex].iPlaceholder = EFalse; |
|
680 } |
|
681 else |
|
682 { |
|
683 TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - append"); |
|
684 OstTrace0( TRACE_NORMAL, DUP4_CTHUMBAGPROCESSOR_ADDTOQUEUEL, "CThumbAGProcessor::AddToQueueL - append" ); |
|
685 item.iPlaceholder = EFalse; |
|
686 SetGenerationItemAction( item, aItemType ); |
|
687 AppendProcessingQueue( item ); |
|
688 } |
|
689 } |
|
690 } |
|
691 else |
|
692 { |
|
693 TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - PH harvesting finished, check is real modify!" ); |
|
694 OstTrace0( TRACE_NORMAL, DUP5_CTHUMBAGPROCESSOR_ADDTOQUEUEL, "CThumbAGProcessor::AddToQueueL - PH harvesting finished, check is real modify!" ); |
|
695 |
|
696 TInt itemIndex(KErrNotFound); |
|
697 |
|
698 for (int i=0; i<aIDArray.Count(); i++) |
|
699 { |
|
700 TThumbnailGenerationItem item; |
|
701 item.iItemId = aIDArray[i]; |
|
702 item.iItemType = aItemType; |
|
703 |
|
704 itemIndex = iGenerationQueue.FindInOrder(item, Compare); |
|
705 |
|
706 if (itemIndex >= 0) |
|
707 { |
|
708 if( iGenerationQueue[itemIndex].iPlaceholder ) |
|
709 { |
|
710 TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - placeholder modify"); |
|
711 OstTrace0( TRACE_NORMAL, DUP6_CTHUMBAGPROCESSOR_ADDTOQUEUEL, "CThumbAGProcessor::AddToQueueL - placeholder modify" ); |
|
712 iGenerationQueue[itemIndex].iPlaceholder = EFalse; |
|
713 } |
|
714 else |
|
715 { |
|
716 TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - real modify"); |
|
717 OstTrace0( TRACE_NORMAL, DUP7_CTHUMBAGPROCESSOR_ADDTOQUEUEL, "CThumbAGProcessor::AddToQueueL - real modify" ); |
|
718 iGenerationQueue[itemIndex].iItemAction = EGenerationItemActionModify; |
|
719 SetForceRun( ETrue ); |
|
720 } |
|
721 } |
|
722 else |
|
723 { |
|
724 TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - append"); |
|
725 OstTrace0( TRACE_NORMAL, DUP8_CTHUMBAGPROCESSOR_ADDTOQUEUEL, "CThumbAGProcessor::AddToQueueL - append" ); |
|
726 SetGenerationItemAction( item, aItemType); |
|
727 item.iPlaceholder = EFalse; |
|
728 AppendProcessingQueue( item ); |
|
729 } |
|
730 } |
|
731 } |
|
732 } |
|
733 else if (aType == ENotifyRemove && aItemType == EGenerationItemTypeAny) |
|
734 { |
|
735 TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - ENotifyRemove, remove IDs from all queues"); |
|
736 OstTrace0( TRACE_NORMAL, DUP9_CTHUMBAGPROCESSOR_ADDTOQUEUEL, "CThumbAGProcessor::AddToQueueL - ENotifyRemove, remove IDs from all queues" ); |
|
737 |
|
738 for (int i=0; i<aIDArray.Count(); i++) |
|
739 { |
|
740 TThumbnailGenerationItem item; |
|
741 item.iItemId = aIDArray[i]; |
|
742 item.iItemType = aItemType; |
|
743 |
|
744 TInt itemIndex = iGenerationQueue.FindInOrder(item, Compare); |
|
745 |
|
746 if(itemIndex >= 0) |
|
747 { |
|
748 iGenerationQueue[itemIndex].iItemAction = EGenerationItemActionDelete; |
|
749 delete iGenerationQueue[itemIndex].iUri; |
|
750 iGenerationQueue[itemIndex].iUri = NULL; |
|
751 |
|
752 if( aObjectUriArray[i]) |
|
753 { |
|
754 iGenerationQueue[itemIndex].iUri = aObjectUriArray[i]->AllocL(); |
|
755 } |
|
756 else |
|
757 { |
|
758 //invalid URI remove from processing queue |
|
759 iGenerationQueue.Remove(itemIndex); |
|
760 } |
|
761 } |
|
762 else |
|
763 { |
|
764 TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - append"); |
|
765 OstTrace0( TRACE_NORMAL, DUP10_CTHUMBAGPROCESSOR_ADDTOQUEUEL, "CThumbAGProcessor::AddToQueueL - append" ); |
|
766 item.iItemAction = EGenerationItemActionDelete; |
|
767 delete item.iUri; |
|
768 item.iUri = NULL; |
|
769 |
|
770 if( aObjectUriArray[i]) |
|
771 { |
|
772 item.iUri = aObjectUriArray[i]->AllocL(); |
|
773 CleanupStack::PushL( item.iUri ); |
|
774 User::LeaveIfError( iGenerationQueue.InsertInOrder(item, Compare) ); |
|
775 CleanupStack::Pop(); |
|
776 } |
|
777 |
|
778 //owned by item |
|
779 item.iUri = NULL; |
|
780 } |
|
781 |
|
782 TN_DEBUG2( "CThumbAGProcessor::AddToQueueL() - %S", aObjectUriArray[i]); |
|
783 OstTraceExt1( TRACE_NORMAL, DUP11_CTHUMBAGPROCESSOR_ADDTOQUEUEL, "CThumbAGProcessor::AddToQueueL;aObjectUriArray[i]=%S", *aObjectUriArray[i] ); |
|
784 } |
|
785 } |
|
786 #ifdef _DEBUG |
|
787 else |
|
788 { |
|
789 TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - should not come here" ); |
|
790 OstTrace0( TRACE_NORMAL, DUP12_CTHUMBAGPROCESSOR_ADDTOQUEUEL, "CThumbAGProcessor::AddToQueueL - should not come here" ); |
|
791 __ASSERT_DEBUG((EFalse), User::Panic(_L("CThumbAGProcessor::AddToQueueL()"), KErrArgument)); |
|
792 User::Leave( KErrArgument ); |
|
793 } |
|
794 #endif |
|
795 |
|
796 ActivateAO(); |
|
797 |
|
798 TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - end" ); |
|
799 OstTrace0( TRACE_NORMAL, DUP13_CTHUMBAGPROCESSOR_ADDTOQUEUEL, "CThumbAGProcessor::AddToQueueL - end" ); |
|
800 } |
|
801 |
|
802 // --------------------------------------------------------------------------- |
|
803 // CThumbAGProcessor::CreateThumbnailsL() |
|
804 // --------------------------------------------------------------------------- |
|
805 // |
|
806 void CThumbAGProcessor::CreateThumbnailsL( const CMdEObject* aObject ) |
|
807 { |
|
808 TN_DEBUG1( "CThumbAGProcessor::CreateThumbnailsL() - begin" ); |
|
809 OstTrace0( TRACE_NORMAL, CTHUMBAGPROCESSOR_CREATETHUMBNAILSL, "CThumbAGProcessor::CreateThumbnailsL - begin" ); |
|
810 |
|
811 __ASSERT_DEBUG((iTMSession), User::Panic(_L("CThumbAGProcessor::CreateThumbnailsL() !iTMSession "), KErrBadHandle)); |
|
812 __ASSERT_DEBUG((iDefNamespace), User::Panic(_L("CThumbAGProcessor::CreateThumbnailsL() !iDefNamespace "), KErrBadHandle)); |
|
813 |
|
814 if(!iTMSession || !iDefNamespace) |
|
815 { |
|
816 return; |
|
817 } |
|
818 |
|
819 TInt orientationVal = 0; |
|
820 TInt64 modifiedVal = 0; |
|
821 |
|
822 CMdEProperty* orientation = NULL; |
|
823 |
|
824 TInt orientErr = aObject->Property( iImageObjectDef->GetPropertyDefL( MdeConstants::Image::KOrientationProperty ), orientation, 0 ); |
|
825 |
|
826 if (orientErr == KErrNone) |
|
827 { |
|
828 orientationVal = orientation->Uint16ValueL(); |
|
829 } |
|
830 |
|
831 CMdEProperty* modified = NULL; |
|
832 CMdEObjectDef& baseObjDef = iDefNamespace->GetObjectDefL( MdeConstants::Object::KBaseObject ); |
|
833 TInt modifyErr = aObject->Property( baseObjDef.GetPropertyDefL( MdeConstants::Object::KLastModifiedDateProperty ), modified, 0 ); |
|
834 |
|
835 if (modifyErr >= 0) |
|
836 { |
|
837 modifiedVal = modified->TimeValueL().Int64(); |
|
838 } |
|
839 |
|
840 // update thumbs |
|
841 if (iTMSession) |
|
842 { |
|
843 // 2nd round and modify updates both sizes if needed |
|
844 if( i2ndRound ) |
|
845 { |
|
846 //generate both if needed |
|
847 TN_DEBUG1( "CThumbAGProcessor::CreateThumbnailsL() EOptimizeForQuality "); |
|
848 OstTrace0( TRACE_NORMAL, DUP1_CTHUMBAGPROCESSOR_CREATETHUMBNAILSL, "CThumbAGProcessor::CreateThumbnailsL - EOptimizeForQuality" ); |
|
849 iTMSession->SetQualityPreferenceL( CThumbnailManager::EOptimizeForQuality ); |
|
850 |
|
851 TN_DEBUG2( "CThumbAGProcessor::CreateThumbnailsL() - 2nd round add remove from queue", aObject->Id() ); |
|
852 OstTrace1( TRACE_NORMAL, DUP2_CTHUMBAGPROCESSOR_CREATETHUMBNAILSL, "CThumbAGProcessor::CreateThumbnailsL - 2nd round add remove from queue;aObject->Id()=%u", aObject->Id() ); |
|
853 |
|
854 TThumbnailGenerationItem item; |
|
855 item.iItemId = aObject->Id(); |
|
856 TInt itemIndex = iGenerationQueue.FindInOrder(item, Compare); |
|
857 |
|
858 if(itemIndex >=0 ) |
|
859 { |
|
860 if(iGenerationQueue[itemIndex].iItemAction == EGenerationItemAction2ndAdd) |
|
861 { |
|
862 iGenerationQueue.Remove(itemIndex); |
|
863 } |
|
864 } |
|
865 } |
|
866 // 1st roung generation |
|
867 else |
|
868 { |
|
869 //1st round |
|
870 TN_DEBUG1( "CThumbAGProcessor::CreateThumbnailsL() EOptimizeForQualityWithPreview"); |
|
871 OstTrace0( TRACE_NORMAL, DUP3_CTHUMBAGPROCESSOR_CREATETHUMBNAILSL, "CThumbAGProcessor::CreateThumbnailsL - EOptimizeForQualityWithPreview" ); |
|
872 iTMSession->SetQualityPreferenceL( CThumbnailManager::EOptimizeForQualityWithPreview ); |
|
873 |
|
874 // add item to 2nd round queue |
|
875 TN_DEBUG2( "CThumbAGProcessor::CreateThumbnailsL() - 1st round add/modify, append to 2nd round queue", aObject->Id() ); |
|
876 OstTrace1( TRACE_NORMAL, DUP4_CTHUMBAGPROCESSOR_CREATETHUMBNAILSL, "CThumbAGProcessor::CreateThumbnailsL - 1st round add/modify, append to 2nd round queue;aObject->Id()=%u", aObject->Id() ); |
|
877 |
|
878 TThumbnailGenerationItem item; |
|
879 item.iItemId = aObject->Id(); |
|
880 TInt itemIndex = iGenerationQueue.FindInOrder(item, Compare); |
|
881 |
|
882 if(itemIndex >=0 ) |
|
883 { |
|
884 if(iGenerationQueue[itemIndex].iItemAction == EGenerationItemActionModify) |
|
885 { |
|
886 iGenerationQueue.Remove(itemIndex); |
|
887 } |
|
888 //change 1st round item for 2nd round processing |
|
889 //2nd round item can be deleted |
|
890 else if(iGenerationQueue[itemIndex].iItemAction == EGenerationItemActionAdd) |
|
891 { |
|
892 iGenerationQueue[itemIndex].iItemAction = EGenerationItemAction2ndAdd; |
|
893 } |
|
894 else |
|
895 { |
|
896 iGenerationQueue.Remove(itemIndex); |
|
897 } |
|
898 } |
|
899 } |
|
900 |
|
901 // run as lower priority than getting but higher that creating thumbnails |
|
902 TRAPD(err, iTMSession->UpdateThumbnailsL(KNoId, aObject->Uri(), orientationVal, modifiedVal, CActive::EPriorityIdle )); |
|
903 |
|
904 if ( err != KErrNone ) |
|
905 { |
|
906 TN_DEBUG2( "CThumbAGProcessor::CreateThumbnailsL, iTMSession error == %d", err ); |
|
907 OstTrace0( TRACE_NORMAL, DUP5_CTHUMBAGPROCESSOR_CREATETHUMBNAILSL, "CThumbAGProcessor::CreateThumbnailsL" ); |
|
908 |
|
909 iSessionDied = ETrue; |
|
910 ActivateAO(); |
|
911 } |
|
912 else |
|
913 { |
|
914 iActiveCount++; |
|
915 } |
|
916 } |
|
917 else |
|
918 { |
|
919 ActivateAO(); |
|
920 } |
|
921 |
|
922 TN_DEBUG1( "CThumbAGProcessor::CreateThumbnailsL() - end" ); |
|
923 OstTrace0( TRACE_NORMAL, DUP6_CTHUMBAGPROCESSOR_CREATETHUMBNAILSL, "CThumbAGProcessor::CreateThumbnailsL - end" ); |
|
924 } |
|
925 |
|
926 // --------------------------------------------------------------------------- |
|
927 // CThumbAGProcessor::QueryL() |
|
928 // --------------------------------------------------------------------------- |
|
929 // |
|
930 void CThumbAGProcessor::QueryL(/*RArray<TItemId>& aIDArray*/TThumbnailGenerationItemAction aAction ) |
|
931 { |
|
932 TN_DEBUG1( "CThumbAGProcessor::QueryL() - begin" ); |
|
933 OstTrace0( TRACE_NORMAL, CTHUMBAGPROCESSOR_QUERYL, "CThumbAGProcessor::QueryL - begin" ); |
|
934 |
|
935 __ASSERT_DEBUG((iMdESession), User::Panic(_L("CThumbAGProcessor::QueryL() !iMdeSession "), KErrBadHandle)); |
|
936 __ASSERT_DEBUG((iDefNamespace), User::Panic(_L("CThumbAGProcessor::QueryL() !iDefNamespace "), KErrBadHandle)); |
|
937 |
|
938 if(!iMdESession || !iDefNamespace || iShutdown) |
|
939 { |
|
940 return; |
|
941 } |
|
942 |
|
943 //reset query queue |
|
944 iQueryQueue.Reset(); |
|
945 //set reference to current pprocessing queue |
|
946 |
|
947 iQueryReady = EFalse; |
|
948 |
|
949 // delete old query |
|
950 if (iQuery) |
|
951 { |
|
952 delete iQuery; |
|
953 iQuery = NULL; |
|
954 } |
|
955 |
|
956 //move ID from source queue to Query queue |
|
957 TInt maxCount = iGenerationQueue.Count(); |
|
958 |
|
959 TN_DEBUG3( "CThumbAGProcessor::QueryL() - fill begin iGenerationQueue == %d, iQueryQueue == %d", iGenerationQueue.Count(), iQueryQueue.Count() ); |
|
960 OstTraceExt2( TRACE_NORMAL, DUP1_CTHUMBAGPROCESSOR_QUERYL, "CThumbAGProcessor::QueryL - - fill begin iGenerationQueue, iQueryQueue;iGenerationQueue.Count()=%d;iQueryQueue.Count()=%d", iGenerationQueue.Count(), iQueryQueue.Count() ); |
|
961 |
|
962 TInt itemCount(0); |
|
963 for(TInt i=0; itemCount < KMaxQueryItems && i < maxCount; i++) |
|
964 { |
|
965 TInt itemIndex(KErrNotFound); |
|
966 switch(aAction) |
|
967 { |
|
968 //1st round items |
|
969 case EGenerationItemActionAdd: |
|
970 if(iGenerationQueue[i].iItemAction == aAction ) |
|
971 { |
|
972 itemIndex = i; |
|
973 } |
|
974 break; |
|
975 case EGenerationItemActionModify: |
|
976 if( iGenerationQueue[i].iItemAction == aAction ) |
|
977 { |
|
978 itemIndex = i; |
|
979 } |
|
980 break; |
|
981 case EGenerationItemAction2ndAdd: |
|
982 if( iGenerationQueue[i].iItemAction == aAction ) |
|
983 { |
|
984 itemIndex = i; |
|
985 } |
|
986 break; |
|
987 //unknown stuff |
|
988 case EGenerationItemActionResolveType: |
|
989 if( iGenerationQueue[i].iItemType == EGenerationItemTypeUnknown ) |
|
990 { |
|
991 itemIndex = i; |
|
992 } |
|
993 break; |
|
994 default: |
|
995 break; |
|
996 }; |
|
997 |
|
998 if( itemIndex >= 0 ) |
|
999 { |
|
1000 TN_DEBUG2( "CThumbAGProcessor::QueryL() - fill %d", iGenerationQueue[itemIndex].iItemId ); |
|
1001 OstTrace1( TRACE_NORMAL, DUP2_CTHUMBAGPROCESSOR_QUERYL, "CThumbAGProcessor::QueryL - fill;iGenerationQueue[itemIndex].iItemId=%u", iGenerationQueue[itemIndex].iItemId ); |
|
1002 iQueryQueue.InsertInOrder(iGenerationQueue[itemIndex].iItemId, CompareId); |
|
1003 itemCount++; |
|
1004 } |
|
1005 } |
|
1006 |
|
1007 if(!itemCount) |
|
1008 { |
|
1009 TN_DEBUG1( "CThumbAGProcessor::QueryL() - empty query, cancel?!"); |
|
1010 OstTrace0( TRACE_NORMAL, DUP3_CTHUMBAGPROCESSOR_QUERYL, "CThumbAGProcessor::QueryL - empty query, cancel?!" ); |
|
1011 iQueryActive = EFalse; |
|
1012 __ASSERT_DEBUG((iMdESession), User::Panic(_L("CThumbAGProcessor::QueryL() empty! "), KErrNotFound)); |
|
1013 return; |
|
1014 } |
|
1015 |
|
1016 TN_DEBUG3( "CThumbAGProcessor::QueryL() - fill end iGenerationQueue == %d, iQueryQueue == %d", iGenerationQueue.Count(), iQueryQueue.Count() ); |
|
1017 OstTraceExt2( TRACE_NORMAL, DUP4_CTHUMBAGPROCESSOR_QUERYL, "CThumbAGProcessor::QueryL;iGenerationQueue.Count()=%d;iQueryQueue.Count()=%d", iGenerationQueue.Count(), iQueryQueue.Count() ); |
|
1018 |
|
1019 CMdEObjectDef& objDef = iDefNamespace->GetObjectDefL( MdeConstants::Object::KBaseObject ); |
|
1020 iQuery = iMdESession->NewObjectQueryL( *iDefNamespace, objDef, this ); |
|
1021 |
|
1022 if(iQuery) |
|
1023 { |
|
1024 iQuery->SetResultMode( EQueryResultModeItem ); |
|
1025 |
|
1026 CMdELogicCondition& rootCondition = iQuery->Conditions(); |
|
1027 rootCondition.SetOperator( ELogicConditionOperatorAnd ); |
|
1028 |
|
1029 // add IDs |
|
1030 CleanupClosePushL( iQueryQueue ); |
|
1031 rootCondition.AddObjectConditionL( iQueryQueue ); |
|
1032 CleanupStack::Pop( &iQueryQueue ); |
|
1033 |
|
1034 // add object type conditions |
|
1035 if (!(iModify || iUnknown)) |
|
1036 { |
|
1037 CMdELogicCondition& objDefCondition = rootCondition.AddLogicConditionL( ELogicConditionOperatorOr ); |
|
1038 |
|
1039 if (iAutoImage) |
|
1040 { |
|
1041 CMdEObjectDef& imageDef = iDefNamespace->GetObjectDefL( MdeConstants::Image::KImageObject ); |
|
1042 objDefCondition.AddObjectConditionL( imageDef ); |
|
1043 } |
|
1044 if (iAutoVideo) |
|
1045 { |
|
1046 CMdEObjectDef& videoDef = iDefNamespace->GetObjectDefL( MdeConstants::Video::KVideoObject ); |
|
1047 objDefCondition.AddObjectConditionL( videoDef ); |
|
1048 } |
|
1049 if (iAutoAudio) |
|
1050 { |
|
1051 CMdEObjectDef& audioDef = iDefNamespace->GetObjectDefL( MdeConstants::Audio::KAudioObject ); |
|
1052 objDefCondition.AddObjectConditionL( audioDef ); |
|
1053 } |
|
1054 } |
|
1055 |
|
1056 iQuery->FindL(); |
|
1057 } |
|
1058 else |
|
1059 { |
|
1060 iQueryActive = EFalse; |
|
1061 } |
|
1062 |
|
1063 TN_DEBUG1( "CThumbAGProcessor::QueryL() - end" ); |
|
1064 OstTrace0( TRACE_NORMAL, DUP5_CTHUMBAGPROCESSOR_QUERYL, "CThumbAGProcessor::QueryL - end" ); |
|
1065 } |
|
1066 |
|
1067 |
|
1068 // --------------------------------------------------------------------------- |
|
1069 // CThumbAGProcessor::QueryForPlaceholders() |
|
1070 // --------------------------------------------------------------------------- |
|
1071 // |
|
1072 |
|
1073 void CThumbAGProcessor::QueryPlaceholdersL(TBool aPresent) |
|
1074 { |
|
1075 TN_DEBUG1( "CThumbAGProcessor::QueryPlaceholdersL" ); |
|
1076 OstTrace0( TRACE_NORMAL, CTHUMBAGPROCESSOR_QUERYPLACEHOLDERSL, "CThumbAGProcessor::QueryPlaceholdersL" ); |
|
1077 |
|
1078 __ASSERT_DEBUG((iMdESession), User::Panic(_L("CThumbAGProcessor::QueryPlaceholdersL() !iMdeSession "), KErrBadHandle)); |
|
1079 __ASSERT_DEBUG((iDefNamespace), User::Panic(_L("CThumbAGProcessor::QueryPlaceholdersL() !iDefNamespace "), KErrBadHandle)); |
|
1080 |
|
1081 if(!iMdESession || !iDefNamespace || iShutdown) |
|
1082 { |
|
1083 return; |
|
1084 } |
|
1085 |
|
1086 if( iQueryPlaceholders ) |
|
1087 { |
|
1088 if( !iQueryPlaceholders->IsComplete() ) |
|
1089 { |
|
1090 TN_DEBUG1( "CThumbAGProcessor::QueryPlaceholdersL active- skip" ); |
|
1091 OstTrace0( TRACE_NORMAL, DUP1_CTHUMBAGPROCESSOR_QUERYPLACEHOLDERSL, "CThumbAGProcessor::QueryPlaceholdersL - skip" ); |
|
1092 return; |
|
1093 } |
|
1094 |
|
1095 // delete old query |
|
1096 iQueryPlaceholders->Cancel(); |
|
1097 delete iQueryPlaceholders; |
|
1098 iQueryPlaceholders = NULL; |
|
1099 } |
|
1100 |
|
1101 TN_DEBUG1( "CThumbAGProcessor::QueryPlaceholdersL - start" ); |
|
1102 OstTrace0( TRACE_NORMAL, DUP2_CTHUMBAGPROCESSOR_QUERYPLACEHOLDERSL, "CThumbAGProcessor::QueryPlaceholdersL - start" ); |
|
1103 |
|
1104 CMdEObjectDef& imageObjDef = iDefNamespace->GetObjectDefL( MdeConstants::Image::KImageObject ); |
|
1105 CMdEObjectDef& videoObjDef = iDefNamespace->GetObjectDefL( MdeConstants::Video::KVideoObject ); |
|
1106 CMdEObjectDef& audioObjDef = iDefNamespace->GetObjectDefL( MdeConstants::Audio::KAudioObject ); |
|
1107 |
|
1108 CMdEObjectDef& objDef = iDefNamespace->GetObjectDefL( MdeConstants::Object::KBaseObject); |
|
1109 iQueryPlaceholders = iMdESession->NewObjectQueryL( *iDefNamespace, objDef, this ); |
|
1110 |
|
1111 if(iQueryPlaceholders) |
|
1112 { |
|
1113 iQueryPlaceholders->SetResultMode( EQueryResultModeItem ); |
|
1114 |
|
1115 CMdELogicCondition& rootCondition = iQueryPlaceholders->Conditions(); |
|
1116 rootCondition.SetOperator( ELogicConditionOperatorOr ); |
|
1117 |
|
1118 CMdEObjectCondition& imagePHObjectCondition = rootCondition.AddObjectConditionL(imageObjDef); |
|
1119 CleanupStack::PushL( &imagePHObjectCondition ); |
|
1120 imagePHObjectCondition.SetPlaceholderOnly( ETrue ); |
|
1121 imagePHObjectCondition.SetNotPresent( aPresent ); |
|
1122 |
|
1123 CMdEObjectCondition& videoPHObjectCondition = rootCondition.AddObjectConditionL(videoObjDef); |
|
1124 CleanupStack::PushL( &videoPHObjectCondition ); |
|
1125 videoPHObjectCondition.SetPlaceholderOnly( ETrue ); |
|
1126 videoPHObjectCondition.SetNotPresent( aPresent ); |
|
1127 |
|
1128 CMdEObjectCondition& audioPHObjectCondition = rootCondition.AddObjectConditionL(audioObjDef); |
|
1129 CleanupStack::PushL( &audioPHObjectCondition ); |
|
1130 audioPHObjectCondition.SetPlaceholderOnly( ETrue ); |
|
1131 audioPHObjectCondition.SetNotPresent( aPresent ); |
|
1132 |
|
1133 iQueryPlaceholders->FindL(KMdEQueryDefaultMaxCount, KMaxQueryBatchSize); |
|
1134 |
|
1135 CleanupStack::Pop(3, &imagePHObjectCondition ); |
|
1136 } |
|
1137 |
|
1138 TN_DEBUG1( "CThumbAGProcessor::QueryPlaceholdersL - end" ); |
|
1139 OstTrace0( TRACE_NORMAL, DUP3_CTHUMBAGPROCESSOR_QUERYPLACEHOLDERSL, "CThumbAGProcessor::QueryPlaceholdersL - end" ); |
|
1140 } |
|
1141 |
|
1142 |
|
1143 // --------------------------------------------------------------------------- |
|
1144 // CThumbAGProcessor::RunL() |
|
1145 // --------------------------------------------------------------------------- |
|
1146 // |
|
1147 void CThumbAGProcessor::RunL() |
|
1148 { |
|
1149 TN_DEBUG1( "CThumbAGProcessor::RunL() - begin" ); |
|
1150 OstTrace0( TRACE_NORMAL, CTHUMBAGPROCESSOR_RUNL, "CThumbAGProcessor::RunL - begin" ); |
|
1151 |
|
1152 if(iShutdown) |
|
1153 { |
|
1154 TN_DEBUG1( "CThumbAGProcessor::RunL() - shutdown" ); |
|
1155 OstTrace0( TRACE_NORMAL, DUP1_CTHUMBAGPROCESSOR_RUNL, "CThumbAGProcessor::RunL - shutdown" ); |
|
1156 return; |
|
1157 } |
|
1158 |
|
1159 if (iSessionDied) |
|
1160 { |
|
1161 TN_DEBUG1( "CThumbAGProcessor::RunL() - iSessionDied" ); |
|
1162 OstTrace0( TRACE_NORMAL, DUP2_CTHUMBAGPROCESSOR_RUNL, "CThumbAGProcessor::RunL - iSessionDied" ); |
|
1163 delete iTMSession; |
|
1164 iTMSession = NULL; |
|
1165 } |
|
1166 |
|
1167 if (iInit) |
|
1168 { |
|
1169 TN_DEBUG1( "CThumbAGProcessor::RunL() - Do Initialisation 1" ); |
|
1170 OstTrace0( TRACE_NORMAL, DUP3_CTHUMBAGPROCESSOR_RUNL, "CThumbAGProcessor::RunL - Do Initialisation 1" ); |
|
1171 |
|
1172 iInit = EFalse; |
|
1173 iInit2 = ETrue; |
|
1174 |
|
1175 iGenerationQueue.Reset(); |
|
1176 iQueryQueue.Reset(); |
|
1177 |
|
1178 //query all not present placeholders |
|
1179 TRAP_IGNORE(QueryPlaceholdersL( ETrue )); |
|
1180 //query all items after PH query |
|
1181 iDoQueryAllItems = ETrue; |
|
1182 TN_DEBUG1( "CThumbAGProcessor::RunL() - Initialisation 1 done" ); |
|
1183 OstTrace0( TRACE_NORMAL, DUP4_CTHUMBAGPROCESSOR_RUNL, "CThumbAGProcessor::RunL - Initialisation 1 done" ); |
|
1184 ActivateAO(); |
|
1185 return; |
|
1186 } |
|
1187 |
|
1188 if(iInit2) |
|
1189 { |
|
1190 TN_DEBUG1( "CThumbAGProcessor::RunL() - Do Initialisation 2" ); |
|
1191 OstTrace0( TRACE_NORMAL, DUP5_CTHUMBAGPROCESSOR_RUNL, "CThumbAGProcessor::RunL - Do Initialisation 2" ); |
|
1192 |
|
1193 iInit2 = EFalse; |
|
1194 TInt err(KErrNone); |
|
1195 |
|
1196 #ifdef MDS_MODIFY_OBSERVER |
|
1197 TN_DEBUG1( "CThumbAGProcessor::RunL() do iHarvesterClient connect"); |
|
1198 OstTrace0( TRACE_NORMAL, DUP6_CTHUMBAGPROCESSOR_RUNL, "CThumbAGProcessor::RunL - do iHarvesterClient connect" ); |
|
1199 err = iHarvesterClient.Connect(); |
|
1200 TN_DEBUG2( "CThumbAGProcessor::RunL() iHarvesterClient connect err = %d", err); |
|
1201 OstTrace1( TRACE_NORMAL, DUP7_CTHUMBAGPROCESSOR_RUNL, "CThumbAGProcessor::RunL - iHarvesterClient connect;err=%d", err ); |
|
1202 |
|
1203 __ASSERT_DEBUG((err == KErrNone), User::Panic(_L("CThumbAGProcessor::RunL(), !iHarvesterClient "), err)); |
|
1204 |
|
1205 if( err == KErrNone ) |
|
1206 { |
|
1207 TN_DEBUG1( "CThumbAGProcessor::RunL() add iHarvesterClient observer"); |
|
1208 OstTrace0( TRACE_NORMAL, DUP8_CTHUMBAGPROCESSOR_RUNL, "CThumbAGProcessor::RunL - add iHarvesterClient observer" ); |
|
1209 err = iHarvesterClient.AddHarvesterEventObserver( *this, EHEObserverTypeOverall | EHEObserverTypeMMC | EHEObserverTypePlaceholder, 20 ); |
|
1210 TN_DEBUG2( "CThumbAGProcessor::RunL() iHarvesterClient observer err = %d", err); |
|
1211 OstTrace1( TRACE_NORMAL, DUP9_CTHUMBAGPROCESSOR_RUNL, "CThumbAGProcessor::RunL - iHarvesterClient observer;err=%d", err ); |
|
1212 |
|
1213 if( err != KErrNone ) |
|
1214 { |
|
1215 TN_DEBUG1( "CThumbAGProcessor::RunL() add iHarvesterClient observer failed"); |
|
1216 OstTrace0( TRACE_NORMAL, DUP10_CTHUMBAGPROCESSOR_RUNL, "CThumbAGProcessor::RunL - add iHarvesterClient observer failed" ); |
|
1217 // if we fail observer harvester, fake it |
|
1218 iHarvesterActivated = ETrue; |
|
1219 } |
|
1220 __ASSERT_DEBUG((err==KErrNone), User::Panic(_L("CThumbAGProcessor::RunL(), !iHarvesterClient "), err)); |
|
1221 } |
|
1222 #endif |
|
1223 |
|
1224 TN_DEBUG1( "CThumbAGProcessor::RunL() MMPXCollectionUtility"); |
|
1225 OstTrace0( TRACE_NORMAL, DUP11_CTHUMBAGPROCESSOR_RUNL, "CThumbAGProcessor::RunL - MMPXCollectionUtility"); |
|
1226 TRAP( err, iCollectionUtility = MMPXCollectionUtility::NewL( this, KMcModeIsolated )); |
|
1227 TN_DEBUG2( "CThumbAGProcessor::RunL() create MMPXCollectionUtility err = %d", err); |
|
1228 OstTrace1( TRACE_NORMAL, DUP12_CTHUMBAGPROCESSOR_RUNL, "CThumbAGProcessor::RunL - create MMPXCollectionUtility err;err=%d", err ); |
|
1229 __ASSERT_DEBUG((iCollectionUtility), User::Panic(_L("CThumbAGProcessor::RunL(), !iCollectionUtility "), err)); |
|
1230 |
|
1231 __ASSERT_DEBUG((iActivityManager), User::Panic(_L("CThumbAGProcessor::RunL(), !iActivityManager "), KErrBadHandle)); |
|
1232 if(iActivityManager) |
|
1233 { |
|
1234 iActivityManager->Start(); |
|
1235 } |
|
1236 |
|
1237 TN_DEBUG1( "CThumbAGProcessor::RunL() - Initialisation 2 done" ); |
|
1238 OstTrace0( TRACE_NORMAL, DUP13_CTHUMBAGPROCESSOR_RUNL, "CThumbAGProcessor::RunL - Initialisation 2 done" ); |
|
1239 return; |
|
1240 } |
|
1241 |
|
1242 // restart session if died |
|
1243 if (!iTMSession) |
|
1244 { |
|
1245 TN_DEBUG1( "CThumbAGProcessor::RunL() - open TNM session"); |
|
1246 OstTrace0( TRACE_NORMAL, DUP14_CTHUMBAGPROCESSOR_RUNL, "CThumbAGProcessor::RunL" ); |
|
1247 TRAPD( err, iTMSession = CThumbnailManager::NewL( *this ) ); |
|
1248 |
|
1249 if (err != KErrNone) |
|
1250 { |
|
1251 iTMSession = NULL; |
|
1252 ActivateAO(); |
|
1253 TN_DEBUG2( "CThumbAGProcessor::RunL() - Session restart failed, error == %d", err ); |
|
1254 OstTrace1( TRACE_NORMAL, DUP15_CTHUMBAGPROCESSOR_RUNL, "CThumbAGProcessor::RunL - Session restart failed, error;err=%d", err ); |
|
1255 } |
|
1256 else |
|
1257 { |
|
1258 iTMSession->SetRequestObserver(*this); |
|
1259 iSessionDied = EFalse; |
|
1260 } |
|
1261 } |
|
1262 |
|
1263 // do not run if request is already issued to TNM server even if forced |
|
1264 if(iActiveCount >= KMaxDaemonRequests) |
|
1265 { |
|
1266 TN_DEBUG1( "CThumbAGProcessor::RunL() - waiting for previous to complete, abort..." ); |
|
1267 OstTrace0( TRACE_NORMAL, DUP16_CTHUMBAGPROCESSOR_RUNL, "CThumbAGProcessor::RunL - waiting for previous to complete, abort..." ); |
|
1268 return; |
|
1269 } |
|
1270 |
|
1271 //force run can proceed from this point |
|
1272 #ifdef _DEBUG |
|
1273 if( iForegroundRun ) |
|
1274 { |
|
1275 TN_DEBUG1( "void CThumbAGProcessor::RunL() KForceBackgroundGeneration enabled"); |
|
1276 OstTrace0( TRACE_NORMAL, DUP17_CTHUMBAGPROCESSOR_RUNL, "CThumbAGProcessor::RunL - KForceBackgroundGeneration enabled" ); |
|
1277 } |
|
1278 |
|
1279 if( iForceRun ) |
|
1280 { |
|
1281 TN_DEBUG1( "CThumbAGProcessor::RunL() - *** FORCED RUN ***"); |
|
1282 OstTrace0( TRACE_NORMAL, DUP18_CTHUMBAGPROCESSOR_RUNL, "CThumbAGProcessor::RunL - *** FORCED RUN ***" ); |
|
1283 } |
|
1284 #endif |
|
1285 |
|
1286 if( (iForceRun || iForegroundRun ) && !iMountTimer->IsActive() ) |
|
1287 { |
|
1288 TN_DEBUG1( "void CThumbAGProcessor::RunL() skip idle detection!"); |
|
1289 OstTrace0( TRACE_NORMAL, DUP19_CTHUMBAGPROCESSOR_RUNL, "CThumbAGProcessor::RunL - skip idle detection!" ); |
|
1290 CancelTimeout(); |
|
1291 } |
|
1292 else |
|
1293 { |
|
1294 if( !iIdle || iHarvesting || iMPXHarvesting || iPeriodicTimer->IsActive() ) |
|
1295 { |
|
1296 TN_DEBUG1( "void CThumbAGProcessor::RunL() device not idle"); |
|
1297 OstTrace0( TRACE_NORMAL, DUP20_CTHUMBAGPROCESSOR_RUNL, "CThumbAGProcessor::RunL - device not idle" ); |
|
1298 return; |
|
1299 } |
|
1300 else |
|
1301 { |
|
1302 //check is server idle |
|
1303 TInt serveIdle(KErrNotFound); |
|
1304 TInt ret = RProperty::Get(KServerIdle, KIdle, serveIdle); |
|
1305 |
|
1306 if(ret != KErrNone || !serveIdle ) |
|
1307 { |
|
1308 //start inactivity timer and retry on after callback |
|
1309 TN_DEBUG1( "void CThumbAGProcessor::RunL() server not idle"); |
|
1310 OstTrace0( TRACE_NORMAL, DUP21_CTHUMBAGPROCESSOR_RUNL, "CThumbAGProcessor::RunL - server not idle" ); |
|
1311 StartTimeout(); |
|
1312 return; |
|
1313 } |
|
1314 TN_DEBUG1( "void CThumbAGProcessor::RunL() device and server idle, process"); |
|
1315 OstTrace0( TRACE_NORMAL, DUP22_CTHUMBAGPROCESSOR_RUNL, "CThumbAGProcessor::RunL - device and server idle, process" ); |
|
1316 } |
|
1317 } |
|
1318 |
|
1319 //Handle completed MDS Query |
|
1320 if( iQueryReady && iProcessingCount) |
|
1321 { |
|
1322 TInt err(KErrNone); |
|
1323 //if force or non forced |
|
1324 //if unknown items or mount timer is active, abort processing |
|
1325 |
|
1326 if(((iForceRun && iModify ) || (!iForceRun && !iModify )) && !iUnknownItemCount && !iMountTimer->IsActive()) |
|
1327 { |
|
1328 TN_DEBUG1( "CThumbAGProcessor::RunL() - iQueryReady START" ); |
|
1329 OstTrace0( TRACE_NORMAL, DUP23_CTHUMBAGPROCESSOR_RUNL, "CThumbAGProcessor::RunL - iQueryReady START" ); |
|
1330 |
|
1331 const CMdEObject* object = &iQuery->Result( iProcessingCount-1 ); |
|
1332 iProcessingCount--; |
|
1333 |
|
1334 if ( object ) |
|
1335 { |
|
1336 //process one item at once |
|
1337 //remove item from queryQueue when request is issued |
|
1338 |
|
1339 TInt itemIndex = iQueryQueue.FindInOrder(object->Id(), CompareId); |
|
1340 if(itemIndex >= 0) |
|
1341 { |
|
1342 iQueryQueue.Remove(itemIndex); |
|
1343 } |
|
1344 |
|
1345 TRAP( err, CreateThumbnailsL( object ) ); |
|
1346 TN_DEBUG2( "CThumbAGProcessor::RunL(), CreateThumbnailsL error == %d", err ); |
|
1347 OstTrace1( TRACE_NORMAL, DUP24_CTHUMBAGPROCESSOR_RUNL, "CThumbAGProcessor::RunL - CreateThumbnailsL error;err=%d", err ); |
|
1348 __ASSERT_DEBUG((err==KErrNone), User::Panic(_L("CThumbAGProcessor::RunL(), CreateThumbnailsL() "), err)); |
|
1349 } |
|
1350 } |
|
1351 //force is coming, but executing non-forced query complete-> cancel old |
|
1352 else |
|
1353 { |
|
1354 //cancel query |
|
1355 TN_DEBUG1( "CThumbAGProcessor::RunL() - cancel processing query" ); |
|
1356 OstTrace0( TRACE_NORMAL, DUP25_CTHUMBAGPROCESSOR_RUNL, "CThumbAGProcessor::RunL - cancel processing query" ); |
|
1357 DeleteAndCancelQuery( ETrue ); |
|
1358 ActivateAO(); |
|
1359 return; |
|
1360 } |
|
1361 |
|
1362 //is last query item |
|
1363 if( iProcessingCount <= 0 ) |
|
1364 { |
|
1365 TN_DEBUG1( "CThumbAGProcessor::RunL() - iQueryReady FINISH" ); |
|
1366 OstTrace0( TRACE_NORMAL, DUP26_CTHUMBAGPROCESSOR_RUNL, "CThumbAGProcessor::RunL - iQueryReady FINISH" ); |
|
1367 iQueryReady = EFalse; |
|
1368 iQueryActive = EFalse; |
|
1369 } |
|
1370 |
|
1371 ActivateAO(); |
|
1372 } |
|
1373 //waiting for MDS query to complete |
|
1374 else if( iQueryActive ) |
|
1375 { |
|
1376 //state mismatch |
|
1377 if(iForceRun && !(iModify || iUnknown)) |
|
1378 { |
|
1379 //cancel query and move items back to original processing queue |
|
1380 DeleteAndCancelQuery(ETrue); |
|
1381 ActivateAO(); |
|
1382 } |
|
1383 else |
|
1384 { |
|
1385 TN_DEBUG1( "CThumbAGProcessor::RunL() - waiting for query to complete, abort..." ); |
|
1386 OstTrace0( TRACE_NORMAL, DUP27_CTHUMBAGPROCESSOR_RUNL, "CThumbAGProcessor::RunL - waiting for query to complete, abort..." ); |
|
1387 } |
|
1388 } |
|
1389 else if ( iUnknownItemCount > 0 ) |
|
1390 { |
|
1391 TN_DEBUG1( "void CThumbAGProcessor::RunL() unknown items in queue"); |
|
1392 OstTrace0( TRACE_NORMAL, DUP28_CTHUMBAGPROCESSOR_RUNL, "CThumbAGProcessor::RunL - unknown items in queue" ); |
|
1393 |
|
1394 i2ndRound = EFalse; |
|
1395 iModify = EFalse; |
|
1396 iUnknown = ETrue; |
|
1397 iQueryActive = ETrue; |
|
1398 |
|
1399 QueryL( EGenerationItemActionResolveType ); |
|
1400 } |
|
1401 else if ( iDeleteItemCount > 0 ) |
|
1402 { |
|
1403 TN_DEBUG1( "void CThumbAGProcessor::RunL() delete thumbnails"); |
|
1404 OstTrace0( TRACE_NORMAL, DUP29_CTHUMBAGPROCESSOR_RUNL, "CThumbAGProcessor::RunL - delete thumbnails" ); |
|
1405 // delete thumbs by URI |
|
1406 __ASSERT_DEBUG((iTMSession), User::Panic(_L("CThumbAGProcessor::RunL() !iTMSession "), KErrBadHandle)); |
|
1407 if(iTMSession) |
|
1408 { |
|
1409 TInt itemIndex(KErrNotFound); |
|
1410 |
|
1411 for(TInt i=0;i<iGenerationQueue.Count() || itemIndex == KErrNotFound;i++) |
|
1412 { |
|
1413 if(iGenerationQueue[i].iItemAction == EGenerationItemActionDelete) |
|
1414 { |
|
1415 itemIndex = i; |
|
1416 } |
|
1417 } |
|
1418 |
|
1419 if(itemIndex >= 0) |
|
1420 { |
|
1421 if(!iGenerationQueue[itemIndex].iUri) |
|
1422 { |
|
1423 //URI is invalid |
|
1424 TN_DEBUG1( "void CThumbAGProcessor::RunL() unable to delete URI inbalid"); |
|
1425 OstTrace0( TRACE_NORMAL, DUP30_CTHUMBAGPROCESSOR_RUNL, "CThumbAGProcessor::RunL - unable to delete URI inbalid" ); |
|
1426 iGenerationQueue.Remove( itemIndex ); |
|
1427 ActivateAO(); |
|
1428 return; |
|
1429 } |
|
1430 |
|
1431 TN_DEBUG2( "void CThumbAGProcessor::RunL() delete %S", iGenerationQueue[itemIndex].iUri); |
|
1432 OstTraceExt1( TRACE_NORMAL, DUP31_CTHUMBAGPROCESSOR_RUNL, "CThumbAGProcessor::RunL;iGenerationQueue[itemIndex].iUri=%S", *iGenerationQueue[itemIndex].iUri ); |
|
1433 CThumbnailObjectSource* source = NULL; |
|
1434 TRAPD(err, source = CThumbnailObjectSource::NewL( *iGenerationQueue[itemIndex].iUri, KNullDesC)); |
|
1435 |
|
1436 if(err == KErrNone) |
|
1437 { |
|
1438 iTMSession->DeleteThumbnails( *source ); |
|
1439 } |
|
1440 delete source; |
|
1441 |
|
1442 delete iGenerationQueue[itemIndex].iUri; |
|
1443 iGenerationQueue[itemIndex].iUri = NULL; |
|
1444 iGenerationQueue.Remove( itemIndex ); |
|
1445 |
|
1446 iActiveCount++; |
|
1447 } |
|
1448 } |
|
1449 } |
|
1450 // no items in query queue, start new |
|
1451 // select queue to process, priority by type |
|
1452 else if ( iModifyItemCount > 0 ) |
|
1453 { |
|
1454 TN_DEBUG1( "void CThumbAGProcessor::RunL() update thumbnails"); |
|
1455 OstTrace0( TRACE_NORMAL, DUP32_CTHUMBAGPROCESSOR_RUNL, "CThumbAGProcessor::RunL - update thumbnails" ); |
|
1456 |
|
1457 i2ndRound = EFalse; |
|
1458 |
|
1459 // query for object info |
|
1460 iQueryActive = ETrue; |
|
1461 iModify = ETrue; |
|
1462 iUnknown = EFalse; |
|
1463 QueryL( EGenerationItemActionModify ); |
|
1464 } |
|
1465 else if ( iAddItemCount > 0 ) |
|
1466 { |
|
1467 TN_DEBUG1( "void CThumbAGProcessor::RunL() update 1st round thumbnails"); |
|
1468 OstTrace0( TRACE_NORMAL, DUP33_CTHUMBAGPROCESSOR_RUNL, "CThumbAGProcessor::RunL - update 1st round thumbnails" ); |
|
1469 |
|
1470 i2ndRound = EFalse; |
|
1471 iUnknown = EFalse; |
|
1472 // query for object info |
|
1473 iQueryActive = ETrue; |
|
1474 |
|
1475 QueryL( EGenerationItemActionAdd ); |
|
1476 } |
|
1477 else if( i2ndAddItemCount > 0) |
|
1478 { |
|
1479 TN_DEBUG1( "void CThumbAGProcessor::RunL() update 2nd round thumbnails"); |
|
1480 OstTrace0( TRACE_NORMAL, DUP34_CTHUMBAGPROCESSOR_RUNL, "CThumbAGProcessor::RunL - update 2nd round thumbnails" ); |
|
1481 |
|
1482 // query for object info |
|
1483 iQueryActive = ETrue; |
|
1484 i2ndRound = ETrue; |
|
1485 iUnknown = EFalse; |
|
1486 QueryL( EGenerationItemAction2ndAdd ); |
|
1487 } |
|
1488 |
|
1489 TN_DEBUG1( "CThumbAGProcessor::RunL() - end" ); |
|
1490 OstTrace0( TRACE_NORMAL, DUP35_CTHUMBAGPROCESSOR_RUNL, "CThumbAGProcessor::RunL - end" ); |
|
1491 } |
|
1492 |
|
1493 // --------------------------------------------------------------------------- |
|
1494 // CThumbAGProcessor::DeleteAndCancelQuery() |
|
1495 // --------------------------------------------------------------------------- |
|
1496 // |
|
1497 void CThumbAGProcessor::DeleteAndCancelQuery(TBool aRestoreItems) |
|
1498 { |
|
1499 TN_DEBUG2( "CThumbAGProcessor::DeleteAndCancelQuery(aRestoreItems = %d) in", aRestoreItems ); |
|
1500 OstTrace1( TRACE_NORMAL, CTHUMBAGPROCESSOR_DELETEANDCANCELQUERY, "CThumbAGProcessor::DeleteAndCancelQuery;aRestoreItems=%d", aRestoreItems ); |
|
1501 |
|
1502 if(iQuery) |
|
1503 { |
|
1504 TN_DEBUG1( "CThumbAGProcessor::DeleteAndCancelQuery() - deleting query" ); |
|
1505 OstTrace0( TRACE_NORMAL, DUP1_CTHUMBAGPROCESSOR_DELETEANDCANCELQUERY, "CThumbAGProcessor::DeleteAndCancelQuery - deleting query" ); |
|
1506 iQuery->Cancel(); |
|
1507 delete iQuery; |
|
1508 iQuery = NULL; |
|
1509 } |
|
1510 |
|
1511 iQueryReady = EFalse; |
|
1512 iQueryActive = EFalse; |
|
1513 iProcessingCount = 0; |
|
1514 |
|
1515 //move remainig IDs in query queue back to original queue |
|
1516 while(iQueryQueue.Count()) |
|
1517 { |
|
1518 if(!aRestoreItems ) |
|
1519 { |
|
1520 TThumbnailGenerationItem item; |
|
1521 item.iItemId = iQueryQueue[0]; |
|
1522 TInt itemIndex = iGenerationQueue.FindInOrder(item, Compare); |
|
1523 |
|
1524 if(itemIndex >= 0) |
|
1525 { |
|
1526 delete iGenerationQueue[itemIndex].iUri; |
|
1527 iGenerationQueue[itemIndex].iUri = NULL; |
|
1528 iGenerationQueue.Remove(itemIndex); |
|
1529 } |
|
1530 } |
|
1531 iQueryQueue.Remove(0); |
|
1532 } |
|
1533 |
|
1534 TN_DEBUG1( "CThumbAGProcessor::DeleteAndCancelQuery() out" ); |
|
1535 OstTrace0( TRACE_NORMAL, DUP2_CTHUMBAGPROCESSOR_DELETEANDCANCELQUERY, "CThumbAGProcessor::DeleteAndCancelQuery - out" ); |
|
1536 } |
|
1537 |
|
1538 // --------------------------------------------------------------------------- |
|
1539 // CThumbAGProcessor::DoCancel() |
|
1540 // --------------------------------------------------------------------------- |
|
1541 // |
|
1542 void CThumbAGProcessor::DoCancel() |
|
1543 { |
|
1544 // No implementation required |
|
1545 } |
|
1546 |
|
1547 void CThumbAGProcessor::HarvestingUpdated( |
|
1548 HarvesterEventObserverType aHEObserverType, |
|
1549 HarvesterEventState aHarvesterEventState, |
|
1550 TInt aItemsLeft ) |
|
1551 { |
|
1552 TN_DEBUG4( "CThumbAGProcessor::HarvestingUpdated -- start() aHEObserverType = %d, aHarvesterEventState = %d, aItemsLeft = %d", aHEObserverType, aHarvesterEventState, aItemsLeft ); |
|
1553 OstTraceExt3( TRACE_NORMAL, CTHUMBAGPROCESSOR_HARVESTINGUPDATED, "CThumbAGProcessor::HarvestingUpdated;aHEObserverType=%u;aHarvesterEventState=%u;aItemsLeft=%d", aHEObserverType, aHarvesterEventState, aItemsLeft ); |
|
1554 |
|
1555 if(iShutdown) |
|
1556 { |
|
1557 return; |
|
1558 } |
|
1559 |
|
1560 if(!iHarvesterActivated) |
|
1561 { |
|
1562 iHarvesterActivated = ETrue; |
|
1563 } |
|
1564 |
|
1565 #ifdef _DEBUG |
|
1566 if( aHEObserverType == EHEObserverTypePlaceholder) |
|
1567 { |
|
1568 TN_DEBUG1( "CThumbAGProcessor::HarvestingUpdated -- type EHEObserverTypePlaceholder"); |
|
1569 OstTrace0( TRACE_NORMAL, DUP1_CTHUMBAGPROCESSOR_HARVESTINGUPDATED, "CThumbAGProcessor::HarvestingUpdated -- type EHEObserverTypePlaceholder" ); |
|
1570 } |
|
1571 else if( aHEObserverType == EHEObserverTypeOverall) |
|
1572 { |
|
1573 TN_DEBUG1( "CThumbAGProcessor::HarvestingUpdated -- type EHEObserverTypeOverall"); |
|
1574 OstTrace0( TRACE_NORMAL, DUP2_CTHUMBAGPROCESSOR_HARVESTINGUPDATED, "CThumbAGProcessor::HarvestingUpdated -- type EHEObserverTypeOverall" ); |
|
1575 } |
|
1576 else if( aHEObserverType == EHEObserverTypeMMC) |
|
1577 { |
|
1578 TN_DEBUG1( "CThumbAGProcessor::HarvestingUpdated -- type EHEObserverTypeMMC"); |
|
1579 OstTrace0( TRACE_NORMAL, DUP3_CTHUMBAGPROCESSOR_HARVESTINGUPDATED, "CThumbAGProcessor::HarvestingUpdated -- type EHEObserverTypeMMC" ); |
|
1580 } |
|
1581 #endif |
|
1582 |
|
1583 //placeholder harvesting |
|
1584 if( aHEObserverType == EHEObserverTypePlaceholder) |
|
1585 { |
|
1586 switch(aHarvesterEventState) |
|
1587 { |
|
1588 case EHEStateStarted: |
|
1589 case EHEStateHarvesting: |
|
1590 case EHEStateResumed: |
|
1591 { |
|
1592 iPHHarvestingTemp = ETrue; |
|
1593 break; |
|
1594 } |
|
1595 case EHEStatePaused: |
|
1596 case EHEStateFinished: |
|
1597 case EHEStateUninitialized: |
|
1598 { |
|
1599 iPHHarvestingTemp = EFalse; |
|
1600 break; |
|
1601 } |
|
1602 }; |
|
1603 |
|
1604 if(iPHHarvestingTemp != iPHHarvesting) |
|
1605 { |
|
1606 iPHHarvesting = iPHHarvestingTemp; |
|
1607 |
|
1608 if( iPHHarvesting ) |
|
1609 { |
|
1610 TN_DEBUG1( "CThumbAGProcessor::HarvestingUpdated -- MDS placeholder harvesterin started"); |
|
1611 OstTrace0( TRACE_NORMAL, DUP4_CTHUMBAGPROCESSOR_HARVESTINGUPDATED, "CThumbAGProcessor::HarvestingUpdated -- MDS placeholder harvesterin starteds" ); |
|
1612 } |
|
1613 else |
|
1614 { |
|
1615 TN_DEBUG1( "CThumbAGProcessor::HarvestingUpdated -- MDS placeholder harvesting finished"); |
|
1616 OstTrace0( TRACE_NORMAL, DUP5_CTHUMBAGPROCESSOR_HARVESTINGUPDATED, "CThumbAGProcessor::HarvestingUpdated -- MDS placeholder harvesting finished" ); |
|
1617 //query present placeholders |
|
1618 TRAP_IGNORE(QueryPlaceholdersL( EFalse )); |
|
1619 iDoQueryAllItems = EFalse; |
|
1620 iPHHarvestingItemsLeftTemp = 0; |
|
1621 } |
|
1622 } |
|
1623 |
|
1624 //restart mount timout if PH item count is increasing durin MMC harvesting |
|
1625 if(iMMCHarvesting && iPHHarvesting && aItemsLeft > iPHHarvestingItemsLeftTemp) |
|
1626 { |
|
1627 //if items count increasing, restart mount timeout |
|
1628 TN_DEBUG1( "CThumbAGProcessor::HarvestingUpdated -- PH count increasing, restart mount timeout"); |
|
1629 OstTrace0( TRACE_NORMAL, DUP6_CTHUMBAGPROCESSOR_HARVESTINGUPDATED, "CThumbAGProcessor::HarvestingUpdated -- PH count increasing, restart mount timeout" ); |
|
1630 |
|
1631 if(iMountTimer->IsActive()) |
|
1632 { |
|
1633 iMountTimer->Cancel(); |
|
1634 } |
|
1635 |
|
1636 iMountTimer->Start( KMountTimeout, KMountTimeout, TCallBack(MountTimerCallBack, this)); |
|
1637 } |
|
1638 |
|
1639 //we are interestead of only PHs during MMC harvesting |
|
1640 if( iMMCHarvesting ) |
|
1641 { |
|
1642 iPHHarvestingItemsLeftTemp = aItemsLeft; |
|
1643 } |
|
1644 } |
|
1645 //overall harvesting |
|
1646 else if ( aHEObserverType == EHEObserverTypeOverall) |
|
1647 { |
|
1648 switch(aHarvesterEventState) |
|
1649 { |
|
1650 case EHEStateStarted: |
|
1651 case EHEStateHarvesting: |
|
1652 case EHEStatePaused: |
|
1653 case EHEStateResumed: |
|
1654 { |
|
1655 iHarvestingTemp = ETrue; |
|
1656 break; |
|
1657 } |
|
1658 case EHEStateFinished: |
|
1659 case EHEStateUninitialized: |
|
1660 { |
|
1661 iHarvestingTemp = EFalse; |
|
1662 break; |
|
1663 } |
|
1664 }; |
|
1665 |
|
1666 if(iHarvestingTemp != iHarvesting) |
|
1667 { |
|
1668 iHarvesting = iHarvestingTemp; |
|
1669 |
|
1670 if( iHarvesting ) |
|
1671 { |
|
1672 TN_DEBUG1( "CThumbAGProcessor::HarvestingUpdated -- MDS harvesting started"); |
|
1673 OstTrace0( TRACE_NORMAL, DUP7_CTHUMBAGPROCESSOR_HARVESTINGUPDATED, "CThumbAGProcessor::HarvestingUpdated -- MDS harvesting started" ); |
|
1674 CancelTimeout(); |
|
1675 } |
|
1676 else |
|
1677 { |
|
1678 TN_DEBUG1( "CThumbAGProcessor::HarvestingUpdated -- MDS harvesting finished "); |
|
1679 OstTrace0( TRACE_NORMAL, DUP8_CTHUMBAGPROCESSOR_HARVESTINGUPDATED, "CThumbAGProcessor::HarvestingUpdated -- MDS harvesting finished" ); |
|
1680 // continue processing if needed |
|
1681 StartTimeout(); |
|
1682 |
|
1683 if(iMountTimer->IsActive()) |
|
1684 { |
|
1685 iMountTimer->Cancel(); |
|
1686 } |
|
1687 } |
|
1688 } |
|
1689 } |
|
1690 //MMC harvesting |
|
1691 else if( aHEObserverType == EHEObserverTypeMMC) |
|
1692 { |
|
1693 switch(aHarvesterEventState) |
|
1694 { |
|
1695 case EHEStateStarted: |
|
1696 case EHEStateHarvesting: |
|
1697 case EHEStatePaused: |
|
1698 case EHEStateResumed: |
|
1699 { |
|
1700 iMMCHarvestingTemp = ETrue; |
|
1701 break; |
|
1702 } |
|
1703 case EHEStateFinished: |
|
1704 case EHEStateUninitialized: |
|
1705 { |
|
1706 iMMCHarvestingTemp = EFalse; |
|
1707 break; |
|
1708 } |
|
1709 }; |
|
1710 |
|
1711 if(iMMCHarvestingTemp != iMMCHarvesting) |
|
1712 { |
|
1713 iMMCHarvesting = iMMCHarvestingTemp; |
|
1714 |
|
1715 if( iMMCHarvesting ) |
|
1716 { |
|
1717 TN_DEBUG1( "CThumbAGProcessor::HarvestingUpdated -- MDS MMC harvesterin started"); |
|
1718 OstTrace0( TRACE_NORMAL, DUP9_CTHUMBAGPROCESSOR_HARVESTINGUPDATED, "CThumbAGProcessor::HarvestingUpdated -- MDS MMC harvesterin started" ); |
|
1719 UpdatePSValues(EFalse, ETrue); |
|
1720 iMMCHarvestingItemsLeftTemp = 0; |
|
1721 } |
|
1722 else |
|
1723 { |
|
1724 //activate timeout if overall harvesting is not active |
|
1725 if(!iHarvesting) |
|
1726 { |
|
1727 StartTimeout(); |
|
1728 } |
|
1729 TN_DEBUG1( "CThumbAGProcessor::HarvestingUpdated -- MDS MMC harvesting finished "); |
|
1730 OstTrace0( TRACE_NORMAL, DUP10_CTHUMBAGPROCESSOR_HARVESTINGUPDATED, "CThumbAGProcessor::HarvestingUpdated -- MDS MMC harvesting finished" ); |
|
1731 } |
|
1732 } |
|
1733 |
|
1734 //restart mount timout if MMC item count is still increasing |
|
1735 if(iMMCHarvesting && aItemsLeft > iMMCHarvestingItemsLeftTemp) |
|
1736 { |
|
1737 TN_DEBUG1( "CThumbAGProcessor::HarvestingUpdated -- MMC count increasing, restart mount timeout"); |
|
1738 OstTrace0( TRACE_NORMAL, DUP11_CTHUMBAGPROCESSOR_HARVESTINGUPDATED, "CThumbAGProcessor::HarvestingUpdated -- MMC count increasing, restart mount timeout" ); |
|
1739 |
|
1740 if(iMountTimer->IsActive()) |
|
1741 { |
|
1742 iMountTimer->Cancel(); |
|
1743 } |
|
1744 |
|
1745 iMountTimer->Start( KMountTimeout, KMountTimeout, TCallBack(MountTimerCallBack, this)); |
|
1746 } |
|
1747 |
|
1748 iMMCHarvestingItemsLeftTemp = aItemsLeft; |
|
1749 } |
|
1750 |
|
1751 TN_DEBUG4( "CThumbAGProcessor::HarvestingUpdated -- end() iHarvesting == %d, iPHHarvesting == %d iMMCHarvesting == %d ", iHarvesting, iPHHarvesting, iMMCHarvesting); |
|
1752 OstTraceExt3( TRACE_NORMAL, DUP12_CTHUMBAGPROCESSOR_HARVESTINGUPDATED, "CThumbAGProcessor::HarvestingUpdated;iHarvesting=%u;iPHHarvesting=%u;iMMCHarvesting=%u", iHarvesting, iPHHarvesting, iMMCHarvesting ); |
|
1753 } |
|
1754 |
|
1755 // --------------------------------------------------------------------------- |
|
1756 // CThumbAGProcessor::StartTimeout() |
|
1757 // --------------------------------------------------------------------------- |
|
1758 // |
|
1759 void CThumbAGProcessor::StartTimeout() |
|
1760 { |
|
1761 TN_DEBUG1( "CThumbAGProcessor::StartTimeout()"); |
|
1762 OstTrace0( TRACE_NORMAL, CTHUMBAGPROCESSOR_STARTTIMEOUT, "CThumbAGProcessor::StartTimeout" ); |
|
1763 CancelTimeout(); |
|
1764 |
|
1765 if(!iHarvesting && !iMPXHarvesting && !iPeriodicTimer->IsActive() && !iShutdown) |
|
1766 { |
|
1767 iPeriodicTimer->Start( KHarvestingCompleteTimeout, KHarvestingCompleteTimeout, |
|
1768 TCallBack(PeriodicTimerCallBack, this)); |
|
1769 } |
|
1770 } |
|
1771 |
|
1772 // --------------------------------------------------------------------------- |
|
1773 // CThumbAGProcessor::StopTimeout() |
|
1774 // --------------------------------------------------------------------------- |
|
1775 // |
|
1776 void CThumbAGProcessor::CancelTimeout() |
|
1777 { |
|
1778 TN_DEBUG1( "CThumbAGProcessor::CancelTimeout()"); |
|
1779 OstTrace0( TRACE_NORMAL, CTHUMBAGPROCESSOR_CANCELTIMEOUT, "CThumbAGProcessor::CancelTimeout" ); |
|
1780 if(iPeriodicTimer->IsActive()) |
|
1781 { |
|
1782 iPeriodicTimer->Cancel(); |
|
1783 } |
|
1784 } |
|
1785 |
|
1786 // --------------------------------------------------------------------------- |
|
1787 // CThumbAGProcessor::RunError() |
|
1788 // --------------------------------------------------------------------------- |
|
1789 // |
|
1790 #ifdef _DEBUG |
|
1791 TInt CThumbAGProcessor::RunError(TInt aError) |
|
1792 #else |
|
1793 TInt CThumbAGProcessor::RunError(TInt /*aError*/) |
|
1794 #endif |
|
1795 { |
|
1796 TN_DEBUG2( "CThumbAGrocessor::RunError() %d", aError); |
|
1797 #ifdef _DEBUG |
|
1798 OstTrace1( TRACE_NORMAL, CTHUMBAGPROCESSOR_RUNERROR, "CThumbAGProcessor::RunError;aError=%d", aError ); |
|
1799 #else |
|
1800 OstTrace0( TRACE_NORMAL, DUP1_CTHUMBAGPROCESSOR_RUNERROR, "CThumbAGProcessor::RunError"); |
|
1801 #endif |
|
1802 UpdatePSValues(EFalse, EFalse); |
|
1803 |
|
1804 iActiveCount--; |
|
1805 |
|
1806 ActivateAO(); |
|
1807 |
|
1808 // nothing to do |
|
1809 return KErrNone; |
|
1810 } |
|
1811 |
|
1812 // --------------------------------------------------------------------------- |
|
1813 // CThumbAGProcessor::ActivateAO() |
|
1814 // --------------------------------------------------------------------------- |
|
1815 // |
|
1816 void CThumbAGProcessor::ActivateAO() |
|
1817 { |
|
1818 UpdateItemCounts(); |
|
1819 |
|
1820 if(iFormatting) |
|
1821 { |
|
1822 TN_DEBUG1( "CThumbAGProcessor::ActivateAO() - FORMATTING - DAEMON ON PAUSE"); |
|
1823 OstTrace0( TRACE_NORMAL, CTHUMBAGPROCESSOR_ACTIVATEAO, "CThumbAGProcessor::ActivateAO - FORMATTING - DAEMON ON PAUSE" ); |
|
1824 return; |
|
1825 } |
|
1826 |
|
1827 //check if forced run needs to continue |
|
1828 if ( (iModifyItemCount > 0 || iDeleteItemCount > 0 || iUnknownItemCount > 0) && !iMountTimer->IsActive()) |
|
1829 { |
|
1830 TN_DEBUG1( "CThumbAGProcessor::ActivateAO() - forced run"); |
|
1831 OstTrace0( TRACE_NORMAL, DUP1_CTHUMBAGPROCESSOR_ACTIVATEAO, "CThumbAGProcessor::ActivateAO - iModifyItemCount > 0 || iUnknownItemCount > 0 || iDeleteItemCount > 0" ); |
|
1832 SetForceRun( ETrue ); |
|
1833 } |
|
1834 else |
|
1835 { |
|
1836 iModify = EFalse; |
|
1837 SetForceRun( EFalse ); |
|
1838 } |
|
1839 |
|
1840 if( !IsActive() && !iShutdown && ((iActiveCount < KMaxDaemonRequests && !iQueryActive) || iForceRun )) |
|
1841 { |
|
1842 TN_DEBUG1( "CThumbAGProcessor::ActivateAO() - Activated"); |
|
1843 OstTrace0( TRACE_NORMAL, DUP2_CTHUMBAGPROCESSOR_ACTIVATEAO, "CThumbAGProcessor::ActivateAO - Activated" ); |
|
1844 SetActive(); |
|
1845 TRequestStatus* statusPtr = &iStatus; |
|
1846 User::RequestComplete( statusPtr, KErrNone ); |
|
1847 } |
|
1848 |
|
1849 UpdatePSValues(EFalse, EFalse); |
|
1850 } |
|
1851 |
|
1852 // --------------------------------------------------------------------------- |
|
1853 // CThumbAGProcessor::PeriodicTimerCallBack() |
|
1854 // --------------------------------------------------------------------------- |
|
1855 // |
|
1856 TInt CThumbAGProcessor::PeriodicTimerCallBack(TAny* aAny) |
|
1857 { |
|
1858 TN_DEBUG1( "CThumbAGProcessor::PeriodicTimerCallBack()"); |
|
1859 OstTrace0( TRACE_NORMAL, CTHUMBAGPROCESSOR_PERIODICTIMERCALLBACK, "CThumbAGProcessor::PeriodicTimerCallBack" ); |
|
1860 CThumbAGProcessor* self = static_cast<CThumbAGProcessor*>( aAny ); |
|
1861 |
|
1862 self->CancelTimeout(); |
|
1863 self->ActivateAO(); |
|
1864 |
|
1865 return KErrNone; // Return value ignored by CPeriodic |
|
1866 } |
|
1867 |
|
1868 // --------------------------------------------------------------------------- |
|
1869 // CThumbAGProcessor::CheckAutoCreateValuesL() |
|
1870 // --------------------------------------------------------------------------- |
|
1871 // |
|
1872 void CThumbAGProcessor::CheckAutoCreateValuesL() |
|
1873 { |
|
1874 CRepository* rep = CRepository::NewL( TUid::Uid( THUMBNAIL_CENREP_UID )); |
|
1875 |
|
1876 TBool imageGrid( EFalse ); |
|
1877 TBool imageList( EFalse ); |
|
1878 TBool imageFull( EFalse ); |
|
1879 TBool videoGrid( EFalse ); |
|
1880 TBool videoList( EFalse ); |
|
1881 TBool videoFull( EFalse ); |
|
1882 TBool audioGrid( EFalse ); |
|
1883 TBool audioList( EFalse ); |
|
1884 TBool audioFull( EFalse ); |
|
1885 |
|
1886 // get cenrep values |
|
1887 TInt ret = rep->Get( KAutoCreateImageGrid, imageGrid ); |
|
1888 TN_DEBUG2( "CThumbAGProcessor::CheckAutoCreateValuesL() KAutoCreateImageGrid %d", ret); |
|
1889 OstTrace1( TRACE_NORMAL, CTHUMBAGPROCESSOR_CHECKAUTOCREATEVALUESL, "CThumbAGProcessor::CheckAutoCreateValuesL - KAutoCreateImageGrid;ret=%d", ret ); |
|
1890 ret = rep->Get( KAutoCreateImageList, imageList ); |
|
1891 TN_DEBUG2( "CThumbAGProcessor::CheckAutoCreateValuesL() KAutoCreateImageList %d", ret); |
|
1892 OstTrace1( TRACE_NORMAL, DUP1_CTHUMBAGPROCESSOR_CHECKAUTOCREATEVALUESL, "CThumbAGProcessor::CheckAutoCreateValuesL - KAutoCreateImageList;ret=%d", ret ); |
|
1893 ret = rep->Get( KAutoCreateImageFullscreen, imageFull ); |
|
1894 TN_DEBUG2( "CThumbAGProcessor::CheckAutoCreateValuesL() KAutoCreateImageFullscreen %d", ret); |
|
1895 OstTrace1( TRACE_NORMAL, DUP2_CTHUMBAGPROCESSOR_CHECKAUTOCREATEVALUESL, "CThumbAGProcessor::CheckAutoCreateValuesL;ret=%d", ret ); |
|
1896 ret = rep->Get( KAutoCreateVideoGrid, videoGrid ); |
|
1897 TN_DEBUG2( "CThumbAGProcessor::CheckAutoCreateValuesL() KAutoCreateVideoGrid %d", ret); |
|
1898 OstTrace1( TRACE_NORMAL, DUP3_CTHUMBAGPROCESSOR_CHECKAUTOCREATEVALUESL, "CThumbAGProcessor::CheckAutoCreateValuesL - KAutoCreateVideoGrid;ret=%d", ret ); |
|
1899 ret = rep->Get( KAutoCreateVideoList, videoList ); |
|
1900 TN_DEBUG2( "CThumbAGProcessor::CheckAutoCreateValuesL() KAutoCreateVideoList %d", ret); |
|
1901 OstTrace1( TRACE_NORMAL, DUP4_CTHUMBAGPROCESSOR_CHECKAUTOCREATEVALUESL, "CThumbAGProcessor::CheckAutoCreateValuesL - KAutoCreateVideoList;ret=%d", ret ); |
|
1902 ret = rep->Get( KAutoCreateVideoFullscreen, videoFull ); |
|
1903 TN_DEBUG2( "CThumbAGProcessor::CheckAutoCreateValuesL() KAutoCreateVideoFullscreen %d", ret); |
|
1904 OstTrace1( TRACE_NORMAL, DUP5_CTHUMBAGPROCESSOR_CHECKAUTOCREATEVALUESL, "CThumbAGProcessor::CheckAutoCreateValuesL - KAutoCreateVideoFullscreen;ret=%d", ret ); |
|
1905 ret = rep->Get( KAutoCreateAudioGrid, audioGrid ); |
|
1906 TN_DEBUG2( "CThumbAGProcessor::CheckAutoCreateValuesL() KAutoCreateAudioGrid %d", ret); |
|
1907 OstTrace1( TRACE_NORMAL, DUP6_CTHUMBAGPROCESSOR_CHECKAUTOCREATEVALUESL, "CThumbAGProcessor::CheckAutoCreateValuesL - KAutoCreateAudioGrid;ret=%d", ret ); |
|
1908 ret = rep->Get( KAutoCreateAudioList, audioList ); |
|
1909 TN_DEBUG2( "CThumbAGProcessor::CheckAutoCreateValuesL() KAutoCreateAudioList %d", ret); |
|
1910 OstTrace1( TRACE_NORMAL, DUP7_CTHUMBAGPROCESSOR_CHECKAUTOCREATEVALUESL, "CThumbAGProcessor::CheckAutoCreateValuesL - KAutoCreateAudioList;ret=%d", ret ); |
|
1911 ret = rep->Get( KAutoCreateAudioFullscreen, audioFull ); |
|
1912 TN_DEBUG2( "CThumbAGProcessor::CheckAutoCreateValuesL() KAutoCreateAudioFullscreen %d", ret); |
|
1913 OstTrace1( TRACE_NORMAL, DUP8_CTHUMBAGPROCESSOR_CHECKAUTOCREATEVALUESL, "CThumbAGProcessor::CheckAutoCreateValuesL - KAutoCreateAudioFullscreen;ret=%d", ret ); |
|
1914 |
|
1915 iAutoImage = EFalse; |
|
1916 iAutoVideo = EFalse; |
|
1917 iAutoAudio = EFalse; |
|
1918 |
|
1919 // set processing values |
|
1920 if (imageGrid || imageList || imageFull) |
|
1921 { |
|
1922 iAutoImage = ETrue; |
|
1923 } |
|
1924 if (videoGrid || videoList || videoFull) |
|
1925 { |
|
1926 iAutoVideo = ETrue; |
|
1927 } |
|
1928 if (audioGrid || audioList || audioFull) |
|
1929 { |
|
1930 iAutoAudio = ETrue; |
|
1931 } |
|
1932 |
|
1933 delete rep; |
|
1934 } |
|
1935 |
|
1936 // --------------------------------------------------------------------------- |
|
1937 // CThumbAGProcessor::RemoveFromQueues() |
|
1938 // --------------------------------------------------------------------------- |
|
1939 // |
|
1940 #ifdef _DEBUG |
|
1941 void CThumbAGProcessor::RemoveFromQueues( const RArray<TItemId>& aIDArray, const TBool aRemoveFromDelete ) |
|
1942 #else |
|
1943 void CThumbAGProcessor::RemoveFromQueues( const RArray<TItemId>& aIDArray, const TBool /*aRemoveFromDelete*/ ) |
|
1944 #endif |
|
1945 { |
|
1946 TN_DEBUG2( "CThumbAGProcessor::RemoveFromQueues() aRemoveFromDelete == %d - begin", aRemoveFromDelete ); |
|
1947 #ifdef _DEBUG |
|
1948 OstTrace1( TRACE_NORMAL, CTHUMBAGPROCESSOR_REMOVEFROMQUEUES, "CThumbAGProcessor::RemoveFromQueues - aRemoveFromDelete;aRemoveFromDelete=%d", aRemoveFromDelete ); |
|
1949 #else |
|
1950 OstTrace0( TRACE_NORMAL, DUP1_CTHUMBAGPROCESSOR_REMOVEFROMQUEUES, "CThumbAGProcessor::RemoveFromQueues - aRemoveFromDelete" ); |
|
1951 #endif |
|
1952 |
|
1953 TInt itemIndex(KErrNotFound); |
|
1954 |
|
1955 for (int i=0; i< aIDArray.Count(); i++) |
|
1956 { |
|
1957 TThumbnailGenerationItem item; |
|
1958 item.iItemId = aIDArray[i]; |
|
1959 TN_DEBUG2( "CThumbAGProcessor::RemoveFromQueues() - %d", aIDArray[i]); |
|
1960 OstTrace1( TRACE_NORMAL, DUP2_CTHUMBAGPROCESSOR_REMOVEFROMQUEUES, "CThumbAGProcessor::RemoveFromQueues;aIDArray[i]=%u", aIDArray[i] ); |
|
1961 |
|
1962 itemIndex = iGenerationQueue.FindInOrder(item, Compare); |
|
1963 if(itemIndex >= 0) |
|
1964 { |
|
1965 delete iGenerationQueue[itemIndex].iUri; |
|
1966 iGenerationQueue[itemIndex].iUri = NULL; |
|
1967 iGenerationQueue.Remove(itemIndex); |
|
1968 TN_DEBUG1( "CThumbAGProcessor::RemoveFromQueues() - iGenerationQueue" ); |
|
1969 OstTrace0( TRACE_NORMAL, DUP3_CTHUMBAGPROCESSOR_REMOVEFROMQUEUES, "CThumbAGProcessor::RemoveFromQueues - iGenerationQueue" ); |
|
1970 } |
|
1971 |
|
1972 itemIndex = iQueryQueue.FindInOrder(aIDArray[i], CompareId); |
|
1973 if(itemIndex >= 0) |
|
1974 { |
|
1975 iQueryQueue.Remove(itemIndex); |
|
1976 TN_DEBUG1( "CThumbAGProcessor::RemoveFromQueues() - iQueryQueue" ); |
|
1977 OstTrace0( TRACE_NORMAL, DUP4_CTHUMBAGPROCESSOR_REMOVEFROMQUEUES, "CThumbAGProcessor::RemoveFromQueues - iQueryQueue" ); |
|
1978 } |
|
1979 } |
|
1980 |
|
1981 ActivateAO(); |
|
1982 |
|
1983 TN_DEBUG1( "CThumbAGProcessor::RemoveFromQueues() - end" ); |
|
1984 OstTrace0( TRACE_NORMAL, DUP5_CTHUMBAGPROCESSOR_REMOVEFROMQUEUES, "CThumbAGProcessor::RemoveFromQueues - end" ); |
|
1985 } |
|
1986 |
|
1987 // --------------------------------------------------------------------------- |
|
1988 // CThumbAGProcessor::SetForceRun() |
|
1989 // --------------------------------------------------------------------------- |
|
1990 // |
|
1991 void CThumbAGProcessor::SetForceRun( const TBool aForceRun) |
|
1992 { |
|
1993 TN_DEBUG2( "CThumbAGProcessor::SetForceRun(%d) - end", aForceRun ); |
|
1994 OstTrace1( TRACE_NORMAL, CTHUMBAGPROCESSOR_SETFORCERUN, "CThumbAGProcessor::SetForceRun - end;aForceRun=%u", aForceRun ); |
|
1995 |
|
1996 // enable forced run |
|
1997 iForceRun = aForceRun; |
|
1998 } |
|
1999 |
|
2000 // --------------------------------------------------------------------------- |
|
2001 // CThumbAGProcessor::QueryForPlaceholders() |
|
2002 // --------------------------------------------------------------------------- |
|
2003 // |
|
2004 void CThumbAGProcessor::QueryAllItemsL() |
|
2005 { |
|
2006 TN_DEBUG1( "CThumbAGProcessor::QueryAllItemsL" ); |
|
2007 OstTrace0( TRACE_NORMAL, CTHUMBAGPROCESSOR_QUERYALLITEMSL, "CThumbAGProcessor::QueryAllItemsL" ); |
|
2008 |
|
2009 __ASSERT_DEBUG((iMdESession), User::Panic(_L("CThumbAGProcessor::QueryAllItemsL() !iMdeSession "), KErrBadHandle)); |
|
2010 |
|
2011 if(!iMdESession) |
|
2012 { |
|
2013 return; |
|
2014 } |
|
2015 |
|
2016 if( iQueryAllItems ) |
|
2017 { |
|
2018 if( !iQueryAllItems->IsComplete() ) |
|
2019 { |
|
2020 TN_DEBUG1( "CThumbAGProcessor::QueryAllItemsL active- skip" ); |
|
2021 OstTrace0( TRACE_NORMAL, DUP1_CTHUMBAGPROCESSOR_QUERYALLITEMSL, "CThumbAGProcessor::QueryAllItemsL - active- skip" ); |
|
2022 return; |
|
2023 } |
|
2024 |
|
2025 // delete old query |
|
2026 iQueryAllItems->Cancel(); |
|
2027 delete iQueryAllItems; |
|
2028 iQueryAllItems = NULL; |
|
2029 } |
|
2030 |
|
2031 TN_DEBUG1( "CThumbAGProcessor::QueryAllItemsL - start" ); |
|
2032 OstTrace0( TRACE_NORMAL, DUP2_CTHUMBAGPROCESSOR_QUERYALLITEMSL, "CThumbAGProcessor::QueryAllItemsL -start" ); |
|
2033 |
|
2034 CMdEObjectDef& imageObjDef = iDefNamespace->GetObjectDefL( MdeConstants::Image::KImageObject ); |
|
2035 CMdEObjectDef& videoObjDef = iDefNamespace->GetObjectDefL( MdeConstants::Video::KVideoObject ); |
|
2036 CMdEObjectDef& audioObjDef = iDefNamespace->GetObjectDefL( MdeConstants::Audio::KAudioObject ); |
|
2037 |
|
2038 CMdEObjectDef& objDef = iDefNamespace->GetObjectDefL( MdeConstants::Object::KBaseObject); |
|
2039 iQueryAllItems = iMdESession->NewObjectQueryL( *iDefNamespace, objDef, this ); |
|
2040 |
|
2041 iQueryAllItems->SetResultMode( EQueryResultModeItem ); |
|
2042 |
|
2043 CMdELogicCondition& rootCondition = iQueryAllItems->Conditions(); |
|
2044 rootCondition.SetOperator( ELogicConditionOperatorOr ); |
|
2045 |
|
2046 rootCondition.AddObjectConditionL(imageObjDef); |
|
2047 rootCondition.AddObjectConditionL(videoObjDef); |
|
2048 rootCondition.AddObjectConditionL(audioObjDef); |
|
2049 |
|
2050 iQueryAllItems->FindL(KMdEQueryDefaultMaxCount, KMaxQueryBatchSize); |
|
2051 |
|
2052 TN_DEBUG1( "CThumbAGProcessor::QueryAllItemsL - end" ); |
|
2053 OstTrace0( TRACE_NORMAL, DUP3_CTHUMBAGPROCESSOR_QUERYALLITEMSL, "CThumbAGProcessor::QueryAllItemsL" ); |
|
2054 } |
|
2055 |
|
2056 // ----------------------------------------------------------------------------- |
|
2057 // CThumbAGProcessor::HandleCollectionMessage |
|
2058 // From MMPXCollectionObserver |
|
2059 // Handle collection message. |
|
2060 // ----------------------------------------------------------------------------- |
|
2061 // |
|
2062 void CThumbAGProcessor::HandleCollectionMessage( CMPXMessage* aMessage, TInt aError ) |
|
2063 { |
|
2064 if ( aError != KErrNone || !aMessage || iShutdown ) |
|
2065 { |
|
2066 return; |
|
2067 } |
|
2068 |
|
2069 TMPXMessageId generalId( *aMessage->Value<TMPXMessageId>( KMPXMessageGeneralId ) ); |
|
2070 |
|
2071 TN_DEBUG2( "CThumbAGProcessor::HandleCollectionMessage KMPXMessageGeneralId=%d", generalId); |
|
2072 OstTrace1( TRACE_NORMAL, CTHUMBAGPROCESSOR_HANDLECOLLECTIONMESSAGE, "CThumbAGProcessor::HandleCollectionMessage - KMPXMessageGeneralId;generalId=%u", generalId ); |
|
2073 |
|
2074 //we are interestead of only general system events |
|
2075 if ( generalId == KMPXMessageGeneral ) |
|
2076 { |
|
2077 TInt event( *aMessage->Value<TInt>( KMPXMessageGeneralEvent ) ); |
|
2078 TInt op( *aMessage->Value<TInt>( KMPXMessageGeneralType ) ); |
|
2079 TN_DEBUG3( "CThumbAGProcessor::HandleCollectionMessage KMPXMessageGeneralEvent=%d", event, op); |
|
2080 OstTraceExt2( TRACE_NORMAL, DUP1_CTHUMBAGPROCESSOR_HANDLECOLLECTIONMESSAGE, "CThumbAGProcessor::HandleCollectionMessage - KMPXMessageGeneralEvent;event=%d;op=%d", event, op ); |
|
2081 if ( event == TMPXCollectionMessage::EBroadcastEvent ) |
|
2082 { |
|
2083 switch( op ) |
|
2084 { |
|
2085 //when MTP sync or music collection is started then pause processing |
|
2086 case EMcMsgRefreshStart: |
|
2087 case EMcMsgUSBMTPStart: |
|
2088 TN_DEBUG1("CThumbAGProcessor::HandleCollectionMessage MPX refresh started" ); |
|
2089 OstTrace0( TRACE_NORMAL, DUP2_CTHUMBAGPROCESSOR_HANDLECOLLECTIONMESSAGE, "CThumbAGProcessor::HandleCollectionMessage - MPX refresh started" ); |
|
2090 iMPXHarvesting = ETrue; |
|
2091 CancelTimeout(); |
|
2092 break; |
|
2093 //when MTP sync or music collection refresh is complete then resume processing |
|
2094 case EMcMsgRefreshEnd: |
|
2095 case EMcMsgUSBMTPEnd: |
|
2096 case EMcMsgUSBMTPNotActive: |
|
2097 TN_DEBUG1("CThumbAGProcessor::HandleCollectionMessage MPX refresh finished/not active" ); |
|
2098 OstTrace0( TRACE_NORMAL, DUP3_CTHUMBAGPROCESSOR_HANDLECOLLECTIONMESSAGE, "CThumbAGProcessor::HandleCollectionMessage - MPX refresh finished/not active" ); |
|
2099 iMPXHarvesting = EFalse; |
|
2100 StartTimeout(); |
|
2101 break; |
|
2102 default: |
|
2103 break; |
|
2104 } |
|
2105 |
|
2106 //signal Server's stores about MPX harvesting state |
|
2107 if( iMPXHarvesting ) |
|
2108 { |
|
2109 RProperty::Set(KTAGDPSNotification, KMPXHarvesting, ETrue); |
|
2110 } |
|
2111 else |
|
2112 { |
|
2113 RProperty::Set(KTAGDPSNotification, KMPXHarvesting, EFalse); |
|
2114 } |
|
2115 |
|
2116 TN_DEBUG3( "CThumbAGProcessor::HandleCollectionMessage -- end() iHarvesting == %d, iMPXHarvesting == %d", iHarvesting, iMPXHarvesting); |
|
2117 OstTraceExt2( TRACE_NORMAL, DUP4_CTHUMBAGPROCESSOR_HANDLECOLLECTIONMESSAGE, "CThumbAGProcessor::HandleCollectionMessage - end;iHarvesting=%u;iMPXHarvesting=%u", iHarvesting, iMPXHarvesting ); |
|
2118 } |
|
2119 } |
|
2120 } |
|
2121 |
|
2122 // ----------------------------------------------------------------------------- |
|
2123 // CThumbAGProcessor::HandleOpenL |
|
2124 // From MMPXCollectionObserver |
|
2125 // Handles the collection entries being opened. |
|
2126 // ----------------------------------------------------------------------------- |
|
2127 // |
|
2128 void CThumbAGProcessor::HandleOpenL( const CMPXMedia& /*aEntries*/, TInt /*aIndex*/, |
|
2129 TBool /*aComplete*/, TInt /*aError*/ ) |
|
2130 { |
|
2131 // not needed here |
|
2132 } |
|
2133 |
|
2134 // ----------------------------------------------------------------------------- |
|
2135 // CThumbAGProcessor::HandleOpenL |
|
2136 // From MMPXCollectionObserver |
|
2137 // Handles an item being opened. |
|
2138 // ----------------------------------------------------------------------------- |
|
2139 void CThumbAGProcessor::HandleOpenL( const CMPXCollectionPlaylist& /*aPlaylist*/, TInt /*aError*/ ) |
|
2140 { |
|
2141 // not needed here |
|
2142 } |
|
2143 |
|
2144 // ----------------------------------------------------------------------------- |
|
2145 // CThumbAGProcessor::HandleCollectionMediaL |
|
2146 // From MMPXCollectionObserver |
|
2147 // Handle media properties. |
|
2148 // ----------------------------------------------------------------------------- |
|
2149 // |
|
2150 void CThumbAGProcessor::HandleCollectionMediaL( const CMPXMedia& /*aMedia*/, |
|
2151 TInt /*aError*/ ) |
|
2152 { |
|
2153 // not needed here |
|
2154 } |
|
2155 |
|
2156 // ----------------------------------------------------------------------------- |
|
2157 // ActivityChanged() |
|
2158 // ----------------------------------------------------------------------------- |
|
2159 // |
|
2160 void CThumbAGProcessor::ActivityChanged(const TBool aActive) |
|
2161 { |
|
2162 TN_DEBUG2( "void CThumbAGProcessor::ActivityChanged() aActive == %d", aActive); |
|
2163 OstTrace0( TRACE_NORMAL, CTHUMBAGPROCESSOR_ACTIVITYCHANGED, "CThumbAGProcessor::ActivityChanged" ); |
|
2164 if(aActive) |
|
2165 { |
|
2166 iIdle = EFalse; |
|
2167 } |
|
2168 else |
|
2169 { |
|
2170 iIdle = ETrue; |
|
2171 |
|
2172 if(iGenerationQueue.Count() > 0 ) |
|
2173 { |
|
2174 ActivateAO(); |
|
2175 } |
|
2176 } |
|
2177 } |
|
2178 |
|
2179 |
|
2180 // --------------------------------------------------------------------------- |
|
2181 // CThumbAGProcessor::FormatNotification |
|
2182 // Handles a format operation |
|
2183 // --------------------------------------------------------------------------- |
|
2184 // |
|
2185 void CThumbAGProcessor::FormatNotification( TBool aFormat ) |
|
2186 { |
|
2187 TN_DEBUG2( "CThumbAGProcessor::FormatNotification(%d)", aFormat ); |
|
2188 OstTrace1( TRACE_NORMAL, CTHUMBAGPROCESSOR_FORMATNOTIFICATION, "CThumbAGProcessor::FormatNotification;aFormat=%u", aFormat ); |
|
2189 |
|
2190 iFormatting = aFormat; |
|
2191 |
|
2192 if(!aFormat) |
|
2193 { |
|
2194 //force update |
|
2195 UpdatePSValues(EFalse, ETrue); |
|
2196 ActivateAO(); |
|
2197 } |
|
2198 } |
|
2199 |
|
2200 // --------------------------------------------------------------------------- |
|
2201 // CThumbAGProcessor::RPropertyNotification |
|
2202 // Handles a RProperty changed operation |
|
2203 // --------------------------------------------------------------------------- |
|
2204 // |
|
2205 void CThumbAGProcessor::RPropertyNotification(const TInt aError, const TUid aKeyCategory, const TUint aPropertyKey, const TInt aValue) |
|
2206 { |
|
2207 TN_DEBUG5( "CThumbAGProcessor::RPropertyNotification() aError = %d, aPropertyKey = %d, aKeyCategory = %d, aValue = %d", aError, aPropertyKey, aKeyCategory, aValue ); |
|
2208 OstTraceExt2( TRACE_NORMAL, CTHUMBAGPROCESSOR_RPROPERTYNOTIFICATION, "CThumbAGProcessor::RPropertyNotification;aPropertyKey=%u;aValue=%d", aPropertyKey, aValue ); |
|
2209 |
|
2210 if(aPropertyKey == KForceBackgroundGeneration && aKeyCategory == KTAGDPSNotification ) |
|
2211 { |
|
2212 if( aValue == 1 && aError == KErrNone ) |
|
2213 { |
|
2214 iForegroundRun = ETrue; |
|
2215 ActivateAO(); |
|
2216 } |
|
2217 else |
|
2218 { |
|
2219 iForegroundRun = EFalse; |
|
2220 } |
|
2221 } |
|
2222 } |
|
2223 |
|
2224 // --------------------------------------------------------------------------- |
|
2225 // CThumbAGProcessor::UpdateItemsLeft |
|
2226 // Update KItemsleft PS value if changed |
|
2227 // --------------------------------------------------------------------------- |
|
2228 // |
|
2229 void CThumbAGProcessor::UpdatePSValues(const TBool aDefine, const TBool aForce) |
|
2230 { |
|
2231 TInt itemsLeft(KErrNotReady); |
|
2232 TBool daemonProcessing = ETrue; |
|
2233 |
|
2234 if(iShutdown) |
|
2235 { |
|
2236 RProperty::Set(KTAGDPSNotification, KDaemonProcessing, EFalse); |
|
2237 RProperty::Set(KTAGDPSNotification, KItemsleft, 0 ); |
|
2238 return; |
|
2239 } |
|
2240 |
|
2241 if(aDefine) |
|
2242 { |
|
2243 TInt ret = RProperty::Define(KTAGDPSNotification, KDaemonProcessing, RProperty::EInt); |
|
2244 |
|
2245 if( ret != KErrNone ) |
|
2246 { |
|
2247 TN_DEBUG2( "CThumbAGProcessor::UpdatePSValues() define KDaemonProcessing ret = %d", ret); |
|
2248 OstTrace1( TRACE_NORMAL, CTHUMBAGPROCESSOR_UPDATEPSVALUES, "CThumbAGProcessor::UpdatePSValues - define KDaemonProcessing;ret=%d", ret ); |
|
2249 } |
|
2250 |
|
2251 ret = RProperty::Define(KTAGDPSNotification, KItemsleft, RProperty::EInt); |
|
2252 |
|
2253 if( ret != KErrNone ) |
|
2254 { |
|
2255 TN_DEBUG2( "CThumbAGProcessor::UpdatePSValues() define KItemsleft ret = %d", ret); |
|
2256 OstTrace1( TRACE_NORMAL, DUP1_CTHUMBAGPROCESSOR_UPDATEPSVALUES, "CThumbAGProcessor::UpdatePSValues - define KItemsleft;ret=%d", ret ); |
|
2257 } |
|
2258 } |
|
2259 |
|
2260 // set itemsleft = KErrNotReady (-18) and daemonProcessing = ETrue if |
|
2261 // - key is initalized |
|
2262 // - mount timer is pending |
|
2263 // - harvester observer is not yet activated |
|
2264 // - single unknown item exists in processing queue |
|
2265 // - forced |
|
2266 if( iMountTimer->IsActive() || aForce || aDefine || iUnknownItemCount |
|
2267 || !iHarvesterActivated ) |
|
2268 { |
|
2269 daemonProcessing = ETrue; |
|
2270 itemsLeft = KErrNotReady; |
|
2271 } |
|
2272 else |
|
2273 { |
|
2274 itemsLeft = iAddItemCount + iModifyItemCount; |
|
2275 } |
|
2276 |
|
2277 TN_DEBUG2( "CThumbAGProcessor::UpdatePSValues() KItemsleft == %d", itemsLeft); |
|
2278 OstTrace1( TRACE_NORMAL, DUP2_CTHUMBAGPROCESSOR_UPDATEPSVALUES, "CThumbAGProcessor::UpdatePSValues;itemsLeft=%d", itemsLeft ); |
|
2279 |
|
2280 //cancel 2nd round generarion when there is items in 1st round queues |
|
2281 if(iAddItemCount && i2ndRound) |
|
2282 { |
|
2283 DeleteAndCancelQuery(ETrue); |
|
2284 i2ndRound = EFalse; |
|
2285 } |
|
2286 |
|
2287 if( iGenerationQueue.Count() ) |
|
2288 { |
|
2289 daemonProcessing = ETrue; |
|
2290 } |
|
2291 else |
|
2292 { |
|
2293 daemonProcessing = EFalse; |
|
2294 } |
|
2295 |
|
2296 if( daemonProcessing != iPreviousDaemonProcessing) |
|
2297 { |
|
2298 TN_DEBUG2( "CThumbAGProcessor::UpdatePSValues() update KDaemonProcessing == %d", daemonProcessing); |
|
2299 OstTrace1( TRACE_NORMAL, DUP3_CTHUMBAGPROCESSOR_UPDATEPSVALUES, "CThumbAGProcessor::UpdatePSValues - update KDaemonProcessing;daemonProcessing=%u", daemonProcessing ); |
|
2300 iPreviousDaemonProcessing = daemonProcessing; |
|
2301 TInt ret = RProperty::Set(KTAGDPSNotification, KDaemonProcessing, daemonProcessing); |
|
2302 |
|
2303 if(ret != KErrNone ) |
|
2304 { |
|
2305 TN_DEBUG3( "CThumbAGProcessor::UpdatePSValues() set KDaemonProcessing %d failed %d", daemonProcessing, ret); |
|
2306 OstTraceExt2( TRACE_NORMAL, DUP4_CTHUMBAGPROCESSOR_UPDATEPSVALUES, "CThumbAGProcessor::UpdatePSValues - set KDaemonProcessing;daemonProcessing=%u;ret=%d", daemonProcessing, ret ); |
|
2307 } |
|
2308 } |
|
2309 |
|
2310 TInt ret = RProperty::Get(KTAGDPSNotification, KItemsleft, iPreviousItemsLeft ); |
|
2311 TN_DEBUG2( "CThumbAGProcessor::UpdatePSValues() iPreviousItemsLeft == %d", iPreviousItemsLeft); |
|
2312 OstTrace1( TRACE_NORMAL, DUP5_CTHUMBAGPROCESSOR_UPDATEPSVALUES, "CThumbAGProcessor::UpdatePSValues;iPreviousItemsLeft=%d", iPreviousItemsLeft ); |
|
2313 |
|
2314 if( itemsLeft != iPreviousItemsLeft) |
|
2315 { |
|
2316 TN_DEBUG2( "CThumbAGProcessor::UpdatePSValues() Set KItemsleft == %d", itemsLeft); |
|
2317 OstTrace1( TRACE_NORMAL, DUP6_CTHUMBAGPROCESSOR_UPDATEPSVALUES, "CThumbAGProcessor::UpdatePSValues - Set KItemsleft;itemsLeft=%d", itemsLeft ); |
|
2318 iPreviousItemsLeft = itemsLeft; |
|
2319 TInt ret = RProperty::Set(KTAGDPSNotification, KItemsleft, itemsLeft ); |
|
2320 |
|
2321 if(ret != KErrNone ) |
|
2322 { |
|
2323 TN_DEBUG3( "CThumbAGProcessor::UpdatePSValues() set KItemsleft %d failed %d", itemsLeft, ret); |
|
2324 OstTraceExt2( TRACE_NORMAL, DUP7_CTHUMBAGPROCESSOR_UPDATEPSVALUES, "CThumbAGProcessor::UpdatePSValues - set KItemsleft failed;itemsLeft=%d;ret=%d", itemsLeft, ret ); |
|
2325 } |
|
2326 } |
|
2327 |
|
2328 } |
|
2329 |
|
2330 // --------------------------------------------------------------------------- |
|
2331 // CThumbAGProcessor::Compare |
|
2332 // Comparison function for logaritmic use of queue arrays |
|
2333 // --------------------------------------------------------------------------- |
|
2334 // |
|
2335 |
|
2336 TInt CThumbAGProcessor::Compare(const TThumbnailGenerationItem& aLeft, const TThumbnailGenerationItem& aRight) |
|
2337 { |
|
2338 return (aLeft.iItemId - aRight.iItemId); |
|
2339 } |
|
2340 |
|
2341 TInt CThumbAGProcessor::CompareId(const TItemId& aLeft, const TItemId& aRight) |
|
2342 { |
|
2343 return (aLeft - aRight); |
|
2344 } |
|
2345 |
|
2346 void CThumbAGProcessor::UpdateItemCounts() |
|
2347 { |
|
2348 TN_DEBUG1( "CThumbAGProcessor::UpdateItemCounts()"); |
|
2349 OstTrace0( TRACE_NORMAL, CTHUMBAGPROCESSOR_UPDATEITEMCOUNTS, "CThumbAGProcessor::UpdateItemCounts" ); |
|
2350 iModifyItemCount = 0; |
|
2351 iDeleteItemCount = 0; |
|
2352 iAddItemCount = 0; |
|
2353 iUnknownItemCount = 0; |
|
2354 i2ndAddItemCount = 0; |
|
2355 iPlaceholderItemCount=0; |
|
2356 iCameraItemCount =0; |
|
2357 iImageItemCount=0; |
|
2358 iVideoItemCount=0; |
|
2359 iAudioItemCount=0; |
|
2360 |
|
2361 for(TInt i=0; i < iGenerationQueue.Count(); i++) |
|
2362 { |
|
2363 TThumbnailGenerationItem& item = iGenerationQueue[i]; |
|
2364 |
|
2365 if(item.iItemAction == EGenerationItemActionModify) |
|
2366 { |
|
2367 iModifyItemCount++; |
|
2368 } |
|
2369 |
|
2370 if(item.iItemAction == EGenerationItemActionDelete) |
|
2371 { |
|
2372 iDeleteItemCount++; |
|
2373 } |
|
2374 |
|
2375 if(item.iItemType == EGenerationItemTypeUnknown) |
|
2376 { |
|
2377 iUnknownItemCount++; |
|
2378 } |
|
2379 if(item.iItemAction == EGenerationItemAction2ndAdd) |
|
2380 { |
|
2381 i2ndAddItemCount++; |
|
2382 } |
|
2383 if(item.iPlaceholder) |
|
2384 { |
|
2385 iPlaceholderItemCount++; |
|
2386 } |
|
2387 if(item.iItemType == EGenerationItemTypeCamera) |
|
2388 { |
|
2389 iCameraItemCount++; |
|
2390 } |
|
2391 if(item.iItemAction == EGenerationItemActionAdd ) |
|
2392 { |
|
2393 iAddItemCount++; |
|
2394 } |
|
2395 if(item.iItemType == EGenerationItemTypeAudio) |
|
2396 { |
|
2397 iAudioItemCount++; |
|
2398 } |
|
2399 if(item.iItemType == EGenerationItemTypeVideo) |
|
2400 { |
|
2401 iVideoItemCount++; |
|
2402 } |
|
2403 if(item.iItemType == EGenerationItemTypeImage) |
|
2404 { |
|
2405 iImageItemCount++; |
|
2406 } |
|
2407 } |
|
2408 |
|
2409 TN_DEBUG2( "CThumbAGProcessor::UpdateItemCounts() iActiveCount = %d", |
|
2410 iActiveCount); |
|
2411 OstTrace1( TRACE_NORMAL, DUP1_CTHUMBAGPROCESSOR_UPDATEITEMCOUNTS, "CThumbAGProcessor::UpdateItemCounts - iActiveCount;iActiveCount=%u", iActiveCount ); |
|
2412 TN_DEBUG2( "CThumbAGProcessor::UpdateItemCounts() iPreviousItemsLeft = %d", |
|
2413 iPreviousItemsLeft); |
|
2414 OstTrace1( TRACE_NORMAL, DUP2_CTHUMBAGPROCESSOR_UPDATEITEMCOUNTS, "CThumbAGProcessor::UpdateItemCounts;iPreviousItemsLeft=%d", iPreviousItemsLeft ); |
|
2415 TN_DEBUG5( "CThumbAGProcessor::UpdateItemCounts() iHarvesting == %d, iMMCHarvesting == %d, iPHHarvesting == %d, iMPXHarvesting == %d", |
|
2416 iHarvesting, iMMCHarvesting, iPHHarvesting, iMPXHarvesting); |
|
2417 OstTraceExt4( TRACE_NORMAL, DUP3_CTHUMBAGPROCESSOR_UPDATEITEMCOUNTS, "CThumbAGProcessor::UpdateItemCounts;iHarvesting=%d;iMMCHarvesting=%d;iPHHarvesting=%d;iMPXHarvesting=%d", |
|
2418 iHarvesting, iMMCHarvesting, iPHHarvesting, iMPXHarvesting ); |
|
2419 |
|
2420 TN_DEBUG5( "CThumbAGProcessor::UpdateItemCounts() iIdle = %d, iForegroundRun = %d, timer = %d, iForceRun = %d", |
|
2421 iIdle, iForegroundRun, iPeriodicTimer->IsActive(), iForceRun); |
|
2422 OstTraceExt4( TRACE_NORMAL, DUP4_CTHUMBAGPROCESSOR_UPDATEITEMCOUNTS, "CThumbAGProcessor::UpdateItemCounts;iIdle=%d;iForegroundRun=%d;iPeriodicTimer->IsActive()=%d;iForceRun=%d", |
|
2423 iIdle, iForegroundRun, iPeriodicTimer->IsActive(), iForceRun ); |
|
2424 |
|
2425 TN_DEBUG4( "CThumbAGProcessor::UpdateItemCounts() iModify = %d, iQueryReady = %d, iProcessingCount = %d", |
|
2426 iModify, iQueryReady, iProcessingCount); |
|
2427 OstTraceExt2( TRACE_NORMAL, DUP5_CTHUMBAGPROCESSOR_UPDATEITEMCOUNTS, "CThumbAGProcessor::UpdateItemCounts;iModify=%u;iQueryReady=%u", |
|
2428 iModify, iQueryReady ); |
|
2429 OstTrace1( TRACE_NORMAL, DUP12_CTHUMBAGPROCESSOR_UPDATEITEMCOUNTS, "CThumbAGProcessor::UpdateItemCounts;iProcessingCount=%u", iProcessingCount ); |
|
2430 TN_DEBUG2( "CThumbAGProcessor::UpdateItemCounts() iMountTimer = %d", iMountTimer->IsActive()); |
|
2431 OstTrace1( TRACE_NORMAL, DUP6_CTHUMBAGPROCESSOR_UPDATEITEMCOUNTS, "CThumbAGProcessor::UpdateItemCounts;iMountTimer->IsActive()=%u", iMountTimer->IsActive() ); |
|
2432 TN_DEBUG3( "CThumbAGProcessor::UpdateItemCounts() iGenerationQueue = %d, iQueryQueue = %d", |
|
2433 iGenerationQueue.Count(), iQueryQueue.Count()); |
|
2434 OstTraceExt2( TRACE_NORMAL, DUP7_CTHUMBAGPROCESSOR_UPDATEITEMCOUNTS, "CThumbAGProcessor::UpdateItemCounts;iGenerationQueue.Count()=%d;iQueryQueue.Count()=%d", iGenerationQueue.Count(), iQueryQueue.Count() ); |
|
2435 TN_DEBUG5( "CThumbAGProcessor::UpdateItemCounts() iAddItemCount=%d, i2ndAddItemCount=%d, iModifyItemCount=%d, iDeleteItemCount=%d", |
|
2436 iAddItemCount, i2ndAddItemCount, iModifyItemCount, iDeleteItemCount ); |
|
2437 OstTrace0( TRACE_NORMAL, DUP8_CTHUMBAGPROCESSOR_UPDATEITEMCOUNTS, "CThumbAGProcessor::UpdateItemCounts" ); |
|
2438 TN_DEBUG3( "CThumbAGProcessor::UpdateItemCounts() iUnknownItemCount=%d, iPlaceholderItemCount=%d", |
|
2439 iUnknownItemCount, iPlaceholderItemCount); |
|
2440 OstTraceExt2( TRACE_NORMAL, DUP9_CTHUMBAGPROCESSOR_UPDATEITEMCOUNTS, "CThumbAGProcessor::UpdateItemCounts;iUnknownItemCount=%d;iPlaceholderItemCount=%d", iUnknownItemCount, iPlaceholderItemCount ); |
|
2441 TN_DEBUG4( "CThumbAGProcessor::UpdateItemCounts() iAudioItemCount=%d, iVideoItemCount=%d, iImageItemCount=%d", |
|
2442 iAudioItemCount, iVideoItemCount, iImageItemCount); |
|
2443 OstTraceExt3( TRACE_NORMAL, DUP10_CTHUMBAGPROCESSOR_UPDATEITEMCOUNTS, "CThumbAGProcessor::UpdateItemCounts;iAudioItemCount=%u;iVideoItemCount=%d;iImageItemCount=%d", |
|
2444 iAudioItemCount, iVideoItemCount, iImageItemCount ); |
|
2445 |
|
2446 TN_DEBUG2( "CThumbAGProcessor::UpdateItemCounts() iCameraItemCount=%d", iCameraItemCount); |
|
2447 OstTrace1( TRACE_NORMAL, DUP11_CTHUMBAGPROCESSOR_UPDATEITEMCOUNTS, "CThumbAGProcessor::UpdateItemCounts;iCameraItemCount=%d", iCameraItemCount ); |
|
2448 |
|
2449 //compress queues when empty |
|
2450 if(!iGenerationQueue.Count()) |
|
2451 { |
|
2452 iGenerationQueue.Compress(); |
|
2453 } |
|
2454 |
|
2455 if(!iQueryQueue.Count()) |
|
2456 { |
|
2457 iQueryQueue.Compress(); |
|
2458 } |
|
2459 } |
|
2460 |
|
2461 |
|
2462 // --------------------------------------------------------------------------- |
|
2463 // CThumbAGProcessor::MountTimerCallBack() |
|
2464 // --------------------------------------------------------------------------- |
|
2465 // |
|
2466 TInt CThumbAGProcessor::MountTimerCallBack(TAny* aAny) |
|
2467 { |
|
2468 TN_DEBUG1( "CThumbAGProcessor::MountTimerCallBack()"); |
|
2469 OstTrace0( TRACE_NORMAL, CTHUMBAGPROCESSOR_MOUNTTIMERCALLBACK, "CThumbAGProcessor::MountTimerCallBack" ); |
|
2470 CThumbAGProcessor* self = static_cast<CThumbAGProcessor*>( aAny ); |
|
2471 |
|
2472 self->iMountTimer->Cancel(); |
|
2473 |
|
2474 //activate timeout if overall or mmc harvestig is not active |
|
2475 if(!self->iHarvesting && !self->iMMCHarvesting ) |
|
2476 { |
|
2477 self->ActivateAO(); |
|
2478 } |
|
2479 |
|
2480 return KErrNone; // Return value ignored by CPeriodic |
|
2481 } |
|
2482 |
|
2483 // --------------------------------------------------------------------------- |
|
2484 // CThumbAGProcessor::SetGenerationItemAction() |
|
2485 // --------------------------------------------------------------------------- |
|
2486 // |
|
2487 void CThumbAGProcessor::SetGenerationItemAction( TThumbnailGenerationItem& aGenerationItem, TThumbnailGenerationItemType aItemType ) |
|
2488 { |
|
2489 switch( aItemType ) |
|
2490 { |
|
2491 case EGenerationItemTypeAudio: |
|
2492 aGenerationItem.iItemAction = EGenerationItemAction2ndAdd; |
|
2493 break; |
|
2494 case EGenerationItemTypeCamera: |
|
2495 aGenerationItem.iItemAction = EGenerationItemAction2ndAdd; |
|
2496 aGenerationItem.iPlaceholder = ETrue; |
|
2497 break; |
|
2498 case EGenerationItemTypeImage: |
|
2499 aGenerationItem.iItemAction = EGenerationItemActionAdd; |
|
2500 break; |
|
2501 case EGenerationItemTypeVideo: |
|
2502 //S^3 EGenerationItemActionAdd |
|
2503 //S^4 EGenerationItemAction2ndAdd |
|
2504 aGenerationItem.iItemAction = EGenerationItemAction2ndAdd; |
|
2505 break; |
|
2506 default: |
|
2507 aGenerationItem.iItemAction = EGenerationItemActionResolveType; |
|
2508 } |
|
2509 } |
|
2510 |
|
2511 // --------------------------------------------------------------------------- |
|
2512 // CThumbAGProcessor::SetGenerationItemType() |
|
2513 // --------------------------------------------------------------------------- |
|
2514 // |
|
2515 void CThumbAGProcessor::SetGenerationItemType( TThumbnailGenerationItem& aGenerationItem, const TDefId aDefId ) |
|
2516 { |
|
2517 if(aDefId == iImageObjectDef->Id()) |
|
2518 { |
|
2519 aGenerationItem.iItemType = EGenerationItemTypeImage; |
|
2520 } |
|
2521 else if(aDefId == iAudioObjectDef->Id()) |
|
2522 { |
|
2523 aGenerationItem.iItemType = EGenerationItemTypeAudio; |
|
2524 } |
|
2525 else if(aDefId == iVideoObjectDef->Id()) |
|
2526 { |
|
2527 aGenerationItem.iItemType = EGenerationItemTypeVideo; |
|
2528 } |
|
2529 else |
|
2530 { |
|
2531 aGenerationItem.iItemType = EGenerationItemTypeUnknown; |
|
2532 } |
|
2533 |
|
2534 SetGenerationItemAction( aGenerationItem, aGenerationItem.iItemType ); |
|
2535 } |
|
2536 |
|
2537 |
|
2538 // ----------------------------------------------------------------------------- |
|
2539 // CThumbAGProcessor::AppendProcessingQueue() |
|
2540 // ----------------------------------------------------------------------------- |
|
2541 // |
|
2542 void CThumbAGProcessor::AppendProcessingQueue( TThumbnailGenerationItem& item ) |
|
2543 { |
|
2544 |
|
2545 TInt itemIndex = iGenerationQueue.FindInOrder( item, Compare ); |
|
2546 |
|
2547 if(itemIndex >= 0) |
|
2548 { |
|
2549 iGenerationQueue[itemIndex].iPlaceholder = item.iPlaceholder; |
|
2550 iGenerationQueue[itemIndex].iItemType = item.iItemType; |
|
2551 iGenerationQueue[itemIndex].iItemAction = item.iItemAction; |
|
2552 } |
|
2553 else |
|
2554 { |
|
2555 iGenerationQueue.InsertInOrder(item, Compare); |
|
2556 } |
|
2557 } |
|
2558 |
|
2559 |
|
2560 // End of file |
|