329 // if no errors in query |
349 // if no errors in query |
330 if (aError == KErrNone && iQuery) |
350 if (aError == KErrNone && iQuery) |
331 { |
351 { |
332 iProcessingCount = iQuery->Count(); |
352 iProcessingCount = iQuery->Count(); |
333 |
353 |
334 if(iProcessingCount != iQueryQueue.Count()) |
354 if(iProcessingCount != iQueryQueue.Count() ) |
335 { |
355 { |
336 TN_DEBUG1( "CThumbAGProcessor::HandleQueryCompleted() some result items missing"); |
356 TN_DEBUG1( "CThumbAGProcessor::HandleQueryCompleted() some result items missing"); |
337 |
357 |
338 RArray<TItemId> queryQueueDelta; |
358 RArray<TItemId> queryQueueDelta; |
339 |
359 |
340 TInt itemIndex(KErrNotFound); |
360 //search delta items which were queried, but not found |
341 |
361 for(TInt queryItem =0; queryItem < iQueryQueue.Count();queryItem++) |
342 //search delta items which were queried, but not found |
362 { |
343 for(TInt queryItem =0; queryItem < iQueryQueue.Count();queryItem++) |
363 TBool found(EFalse); |
344 { |
364 for(TInt queryResult = 0; queryResult < iQuery->Count(); queryResult++) |
345 TBool found(EFalse); |
365 { |
346 for(TInt queryResult = 0; queryResult < iQuery->Count(); queryResult++) |
366 const CMdEObject* object = &iQuery->Result(queryResult); |
347 { |
367 |
348 const CMdEObject* object = &iQuery->Result(queryResult); |
368 if( iQueryQueue[queryItem] == object->Id()) |
349 |
369 { |
350 if( iQueryQueue[queryItem] == object->Id()) |
370 found = ETrue; |
|
371 break; |
|
372 } |
|
373 } |
|
374 |
|
375 if(!found) |
|
376 { |
|
377 TN_DEBUG2( "CThumbAGProcessor::HandleQueryCompleted() %d missing from query results", iQueryQueue[queryItem] ); |
|
378 |
|
379 // ignore if fails |
|
380 queryQueueDelta.InsertInOrder(iQueryQueue[queryItem], CompareId); |
|
381 } |
|
382 } |
|
383 |
|
384 TN_DEBUG2( "CThumbAGProcessor::HandleQueryCompleted() missing items found %d", queryQueueDelta.Count()); |
|
385 //cleanup from previous queue it item is not found from MDS |
|
386 while(queryQueueDelta.Count()) |
|
387 { |
|
388 TThumbnailGenerationItem item; |
|
389 item.iItemId = queryQueueDelta[0]; |
|
390 TInt itemIndex = iQueryQueue.FindInOrder(item.iItemId, CompareId); |
|
391 |
|
392 if(itemIndex >= 0) |
|
393 { |
|
394 TN_DEBUG2( "CThumbAGProcessor::HandleQueryCompleted() remove %d from iQueryQueue", queryQueueDelta[0]); |
|
395 iQueryQueue.Remove( itemIndex ); |
|
396 |
|
397 //remove from procesing queue |
|
398 itemIndex = iGenerationQueue.FindInOrder(item, Compare); |
|
399 |
|
400 if(itemIndex >= 0) |
|
401 { |
|
402 |
|
403 if( iUnknown ) |
|
404 { |
|
405 TN_DEBUG2( "CThumbAGProcessor::HandleQueryCompleted() mark %d as EGenerationItemTypeNotFound in iGenerationQueue", queryQueueDelta[0]); |
|
406 //mark to be removed, cleanup is done below |
|
407 iGenerationQueue[itemIndex].iItemType = EGenerationItemTypeNotFound; |
|
408 } |
|
409 else |
|
410 { |
|
411 TN_DEBUG2( "CThumbAGProcessor::HandleQueryCompleted() remove %d from iGenerationQueue", queryQueueDelta[0]); |
|
412 iGenerationQueue.Remove( itemIndex ); |
|
413 } |
|
414 } |
|
415 } |
|
416 queryQueueDelta.Remove(0); |
|
417 } |
|
418 queryQueueDelta.Close(); |
|
419 } |
|
420 |
|
421 if(iUnknown) |
|
422 { |
|
423 for(TInt i = 0; i < iQuery->Count(); i++) |
|
424 { |
|
425 const CMdEObject* object = &iQuery->Result(i); |
|
426 |
|
427 if(!object) |
|
428 { |
|
429 continue; |
|
430 } |
|
431 |
|
432 TThumbnailGenerationItem tempItem; |
|
433 tempItem.iItemId = object->Id(); |
|
434 TInt itemIndex = iGenerationQueue.FindInOrder(tempItem, Compare); |
|
435 |
|
436 if(itemIndex >= 0) |
351 { |
437 { |
352 found = ETrue; |
438 TThumbnailGenerationItem& item = iGenerationQueue[itemIndex]; |
353 break; |
439 |
|
440 if(iGenerationQueue[itemIndex].iItemType == EGenerationItemTypeNotFound) |
|
441 { |
|
442 TN_DEBUG2( "CThumbAGProcessor::HandleQueryCompleted() remove EGenerationItemTypeNotFound %d item from iGenerationQueue", item.iItemId); |
|
443 iGenerationQueue.Remove(itemIndex); |
|
444 continue; |
|
445 } |
|
446 |
|
447 SetGenerationItemType(item, object->Def().Id()); |
|
448 |
|
449 if(item.iItemType == EGenerationItemTypeUnknown ) |
|
450 { |
|
451 TN_DEBUG2( "CThumbAGProcessor::HandleQueryCompleted() remove unknown item %d", item.iItemId); |
|
452 iGenerationQueue.Remove(itemIndex); |
|
453 continue; |
|
454 } |
|
455 |
|
456 item.iPlaceholder = object->Placeholder(); |
|
457 |
354 } |
458 } |
355 } |
459 } |
356 |
460 |
357 if(!found) |
461 iQueryQueue.Reset(); |
358 { |
462 iProcessingCount = 0; |
359 TN_DEBUG2( "CThumbAGProcessor::HandleQueryCompleted() missing from results item %d", iQueryQueue[queryItem] ); |
463 iUnknown = EFalse; |
360 |
464 } |
361 // ignore if fails |
|
362 queryQueueDelta.InsertInOrder(iQueryQueue[queryItem], Compare); |
|
363 } |
|
364 } |
|
365 |
|
366 TN_DEBUG2( "CThumbAGProcessor::HandleQueryCompleted() missing items total count %d", queryQueueDelta.Count()); |
|
367 //cleanup from previous queue it item is not found from MDS |
|
368 while(queryQueueDelta.Count()) |
|
369 { |
|
370 itemIndex = iLastQueue->FindInOrder(queryQueueDelta[0], Compare); |
|
371 |
|
372 if(itemIndex >= 0) |
|
373 { |
|
374 TN_DEBUG2( "CThumbAGProcessor::HandleQueryCompleted() remove items %d", iQueryQueue[0]); |
|
375 iLastQueue->Remove( itemIndex ); |
|
376 } |
|
377 queryQueueDelta.Remove(0); |
|
378 } |
|
379 queryQueueDelta.Close(); |
|
380 } |
|
381 |
465 |
382 // no results, reset query |
466 // no results, reset query |
383 if( !iProcessingCount) |
467 if( !iProcessingCount ) |
384 { |
468 { |
385 delete iQuery; |
469 delete iQuery; |
386 iQuery = NULL; |
470 iQuery = NULL; |
387 iProcessingCount = 0; |
|
388 iModify = EFalse; |
471 iModify = EFalse; |
389 } |
472 } |
390 } |
473 } |
391 else |
474 else |
392 { |
475 { |
493 |
564 |
494 TRAPD( err, iDefNamespace = &iMdESession->GetDefaultNamespaceDefL() ); |
565 TRAPD( err, iDefNamespace = &iMdESession->GetDefaultNamespaceDefL() ); |
495 if (err != KErrNone) |
566 if (err != KErrNone) |
496 { |
567 { |
497 TN_DEBUG2( "CThumbAGProcessor::SetMdESession() GetDefaultNamespaceDefL() err = %d", err ); |
568 TN_DEBUG2( "CThumbAGProcessor::SetMdESession() GetDefaultNamespaceDefL() err = %d", err ); |
498 } |
569 __ASSERT_DEBUG((iDefNamespace), User::Panic(_L("CThumbAGProcessor::SetMdESession() !iDefNamespace "), KErrBadHandle)); |
499 |
570 } |
500 __ASSERT_DEBUG((iDefNamespace), User::Panic(_L("CThumbAGProcessor::SetMdESession() !iDefNamespace "), KErrBadHandle)); |
571 else |
501 |
572 { |
502 //do async init |
573 iImageObjectDef = &iDefNamespace->GetObjectDefL( MdeConstants::Image::KImageObject ); |
503 iInit = ETrue; |
574 __ASSERT_DEBUG((iImageObjectDef), User::Panic(_L("CThumbAGProcessor::SetMdESession() !iDefNamespace "), KErrBadHandle)); |
504 |
575 iVideoObjectDef = &iDefNamespace->GetObjectDefL( MdeConstants::Video::KVideoObject ); |
505 ActivateAO(); |
576 __ASSERT_DEBUG((iVideoObjectDef), User::Panic(_L("CThumbAGProcessor::SetMdESession() !iVideoObjectDef "), KErrBadHandle)); |
|
577 iAudioObjectDef = &iDefNamespace->GetObjectDefL( MdeConstants::Audio::KAudioObject ); |
|
578 __ASSERT_DEBUG((iAudioObjectDef), User::Panic(_L("CThumbAGProcessor::SetMdESession() !iAudioObjectDef "), KErrBadHandle)); |
|
579 |
|
580 //do async init |
|
581 iInit = ETrue; |
|
582 |
|
583 ActivateAO(); |
|
584 } |
506 } |
585 } |
507 |
586 |
508 // --------------------------------------------------------------------------- |
587 // --------------------------------------------------------------------------- |
509 // CThumbAGProcessor::AddToQueue() |
588 // CThumbAGProcessor::AddToQueue() |
510 // --------------------------------------------------------------------------- |
589 // --------------------------------------------------------------------------- |
511 // |
590 // |
512 void CThumbAGProcessor::AddToQueueL( TObserverNotificationType aType, |
591 void CThumbAGProcessor::AddToQueueL( TObserverNotificationType aType, |
|
592 TThumbnailGenerationItemType aItemType, |
513 const RArray<TItemId>& aIDArray, |
593 const RArray<TItemId>& aIDArray, |
514 const RPointerArray<HBufC>& aObjectUriArray, |
594 const RPointerArray<HBufC>& aObjectUriArray, |
515 TBool /*aPresent*/ ) |
595 TBool /*aPresent*/ ) |
516 { |
596 { |
517 TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - begin" ); |
597 TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - begin" ); |
|
598 |
518 |
599 |
519 // update queues |
600 // update queues |
520 if (aType == ENotifyAdd) |
601 if (aType == ENotifyAdd) |
521 { |
602 { |
522 TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - ENotifyAdd" ); |
603 TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - ENotifyAdd" ); |
523 |
604 |
524 for (int i=0; i<aIDArray.Count(); i++) |
605 for (int i=0; i<aIDArray.Count(); i++) |
525 { |
606 { |
526 // do not to append to Add queue if exist already in Add or 2nd Add queue (just processed) |
607 TThumbnailGenerationItem item; |
527 if (iAddQueue.FindInOrder(aIDArray[i], Compare) == KErrNotFound && |
608 item.iItemId = aIDArray[i]; |
528 i2ndRoundGenerateQueue.FindInOrder(aIDArray[i], Compare) == KErrNotFound) |
609 item.iItemType = aItemType; |
529 { |
610 |
530 User::LeaveIfError(iAddQueue.InsertInOrder(aIDArray[i], Compare)); |
611 SetGenerationItemAction(item, aItemType); |
531 } |
612 |
|
613 if(iPHHarvesting) |
|
614 { |
|
615 item.iPlaceholder = ETrue; |
|
616 } |
|
617 |
|
618 AppendProcessingQueue( item ); |
532 } |
619 } |
533 } |
620 } |
534 else if (aType == ENotifyModify) |
621 else if (aType == ENotifyModify) |
535 { |
622 { |
536 TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - ENotifyModify" ); |
623 TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - ENotifyModify" ); |
538 if(iPHHarvesting) |
625 if(iPHHarvesting) |
539 { |
626 { |
540 TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - PH harvesting active, treat like add" ); |
627 TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - PH harvesting active, treat like add" ); |
541 for (int i=0; i<aIDArray.Count(); i++) |
628 for (int i=0; i<aIDArray.Count(); i++) |
542 { |
629 { |
543 TInt itemIndex = iPlaceholderQueue.FindInOrder(aIDArray[i], Compare); |
630 TThumbnailGenerationItem item; |
|
631 item.iItemId = aIDArray[i]; |
|
632 item.iItemType = aItemType; |
|
633 |
|
634 TInt itemIndex = iGenerationQueue.FindInOrder(item, Compare); |
544 |
635 |
545 if (itemIndex >= 0) |
636 if (itemIndex >= 0) |
546 { |
637 { |
547 TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - remove from placeholder queue"); |
638 TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - set as non-placeholder"); |
548 iPlaceholderQueue.Remove( itemIndex ); |
639 iGenerationQueue[itemIndex].iPlaceholder = EFalse; |
549 } |
640 } |
|
641 else |
|
642 { |
|
643 TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - append"); |
|
644 |
|
645 item.iPlaceholder = EFalse; |
|
646 SetGenerationItemAction( item, aItemType ); |
|
647 AppendProcessingQueue( item ); |
|
648 } |
|
649 } |
|
650 } |
|
651 else |
|
652 { |
|
653 TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - PH harvesting finished, check is real modify!" ); |
|
654 |
|
655 TInt itemIndex(KErrNotFound); |
|
656 |
|
657 for (int i=0; i<aIDArray.Count(); i++) |
|
658 { |
|
659 TThumbnailGenerationItem item; |
|
660 item.iItemId = aIDArray[i]; |
|
661 item.iItemType = aItemType; |
550 |
662 |
551 if(iAddQueue.FindInOrder(aIDArray[i], Compare) == KErrNotFound && |
663 itemIndex = iGenerationQueue.FindInOrder(item, Compare); |
552 i2ndRoundGenerateQueue.FindInOrder(aIDArray[i], Compare) == KErrNotFound) |
|
553 { |
|
554 TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - append to add queue"); |
|
555 User::LeaveIfError(iAddQueue.InsertInOrder(aIDArray[i], Compare)); |
|
556 } |
|
557 } |
|
558 } |
|
559 else |
|
560 { |
|
561 TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - PH harvesting finished, check is real modify!" ); |
|
562 |
|
563 TInt itemIndex(KErrNotFound); |
|
564 |
|
565 for (int i=0; i<aIDArray.Count(); i++) |
|
566 { |
|
567 itemIndex = iPlaceholderQueue.FindInOrder(aIDArray[i], Compare); |
|
568 |
664 |
569 if (itemIndex >= 0) |
665 if (itemIndex >= 0) |
570 { |
666 { |
571 TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - placeholder modify, remove from placeholder queue"); |
667 if( iGenerationQueue[itemIndex].iPlaceholder ) |
572 iPlaceholderQueue.Remove( itemIndex ); |
668 { |
|
669 TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - placeholder modify"); |
|
670 iGenerationQueue[itemIndex].iPlaceholder = EFalse; |
|
671 } |
|
672 else |
|
673 { |
|
674 TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - real modify"); |
|
675 iGenerationQueue[itemIndex].iItemAction = EGenerationItemActionModify; |
|
676 SetForceRun( ETrue ); |
|
677 } |
573 } |
678 } |
574 else |
679 else |
575 { |
680 { |
576 TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - real modify"); |
681 TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - append"); |
577 itemIndex = iAddQueue.FindInOrder(aIDArray[i], Compare); |
682 SetGenerationItemAction( item, aItemType); |
578 |
683 item.iPlaceholder = EFalse; |
579 if (itemIndex >= 0) |
684 AppendProcessingQueue( item ); |
580 { |
685 } |
581 TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - remove from add queue"); |
686 } |
582 iAddQueue.Remove( itemIndex ); |
687 } |
583 } |
688 } |
584 else |
689 else if (aType == ENotifyRemove && aItemType == EGenerationItemTypeAny) |
585 { |
|
586 itemIndex = i2ndRoundGenerateQueue.FindInOrder(aIDArray[i], Compare); |
|
587 |
|
588 if (itemIndex >= 0) |
|
589 { |
|
590 TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - remove from 2nd round add queue"); |
|
591 i2ndRoundGenerateQueue.Remove( itemIndex ); |
|
592 } |
|
593 } |
|
594 |
|
595 TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - append to modify queue"); |
|
596 User::LeaveIfError(iModifyQueue.InsertInOrder(aIDArray[i], Compare)); |
|
597 |
|
598 SetForceRun( ETrue ); |
|
599 } |
|
600 } |
|
601 } |
|
602 } |
|
603 else if (aType == ENotifyRemove) |
|
604 { |
690 { |
605 TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - ENotifyRemove, remove IDs from all queues"); |
691 TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - ENotifyRemove, remove IDs from all queues"); |
606 |
692 |
607 for (int i=0; i<aIDArray.Count(); i++) |
693 for (int i=0; i<aIDArray.Count(); i++) |
608 { |
694 { |
609 // can be removed from Add queue |
695 TThumbnailGenerationItem item; |
610 TInt itemIndex = iAddQueue.FindInOrder(aIDArray[i], Compare); |
696 item.iItemId = aIDArray[i]; |
|
697 item.iItemType = aItemType; |
|
698 |
|
699 TInt itemIndex = iGenerationQueue.FindInOrder(item, Compare); |
|
700 |
611 if(itemIndex >= 0) |
701 if(itemIndex >= 0) |
612 { |
702 { |
613 iAddQueue.Remove(itemIndex); |
703 iGenerationQueue[itemIndex].iItemAction = EGenerationItemActionDelete; |
614 } |
704 delete iGenerationQueue[itemIndex].iUri; |
615 |
705 iGenerationQueue[itemIndex].iUri = NULL; |
616 // ..and Modify Queue |
706 |
617 itemIndex = iModifyQueue.FindInOrder(aIDArray[i], Compare); |
707 if( aObjectUriArray[i]) |
618 if(itemIndex >= 0) |
708 { |
|
709 iGenerationQueue[itemIndex].iUri = aObjectUriArray[i]->AllocL(); |
|
710 } |
|
711 else |
|
712 { |
|
713 //invalid URI remove from processing queue |
|
714 iGenerationQueue.Remove(itemIndex); |
|
715 } |
|
716 } |
|
717 else |
619 { |
718 { |
620 iModifyQueue.Remove(itemIndex); |
719 TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - append"); |
621 } |
720 item.iItemAction = EGenerationItemActionDelete; |
622 } |
721 delete item.iUri; |
623 |
722 item.iUri = NULL; |
624 TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - ENotifyRemove append URIs to remove queue"); |
723 |
625 for (int i=0; i<aObjectUriArray.Count(); i++) |
724 if( aObjectUriArray[i]) |
626 { |
725 { |
627 HBufC* temp = aObjectUriArray[i]->AllocL(); |
726 item.iUri = aObjectUriArray[i]->AllocL(); |
628 iRemoveQueue.Append( temp ); |
727 CleanupStack::PushL( item.iUri ); |
629 TN_DEBUG2( "CThumbAGProcessor::AddToQueueL() - %S", temp); |
728 User::LeaveIfError( iGenerationQueue.InsertInOrder(item, Compare) ); |
|
729 CleanupStack::Pop(); |
|
730 } |
|
731 |
|
732 //owned by item |
|
733 item.iUri = NULL; |
|
734 } |
|
735 |
|
736 TN_DEBUG2( "CThumbAGProcessor::AddToQueueL() - %S", aObjectUriArray[i]); |
630 } |
737 } |
631 } |
738 } |
632 #ifdef _DEBUG |
739 #ifdef _DEBUG |
633 else |
740 else |
634 { |
741 { |
635 TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - should not come here" ); |
742 TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - should not come here" ); |
|
743 __ASSERT_DEBUG((EFalse), User::Panic(_L("CThumbAGProcessor::AddToQueueL()"), KErrArgument)); |
636 User::Leave( KErrArgument ); |
744 User::Leave( KErrArgument ); |
637 } |
745 } |
638 #endif |
746 #endif |
639 |
747 |
640 ActivateAO(); |
748 ActivateAO(); |
686 if( i2ndRound ) |
794 if( i2ndRound ) |
687 { |
795 { |
688 //generate both if needed |
796 //generate both if needed |
689 TN_DEBUG1( "CThumbAGProcessor::CreateThumbnailsL() EOptimizeForQuality "); |
797 TN_DEBUG1( "CThumbAGProcessor::CreateThumbnailsL() EOptimizeForQuality "); |
690 iTMSession->SetQualityPreferenceL( CThumbnailManager::EOptimizeForQuality ); |
798 iTMSession->SetQualityPreferenceL( CThumbnailManager::EOptimizeForQuality ); |
|
799 |
|
800 TN_DEBUG2( "CThumbAGProcessor::CreateThumbnailsL() - 2nd round add remove from queue", aObject->Id() ); |
|
801 |
|
802 TThumbnailGenerationItem item; |
|
803 item.iItemId = aObject->Id(); |
|
804 TInt itemIndex = iGenerationQueue.FindInOrder(item, Compare); |
|
805 |
|
806 if(itemIndex >=0 ) |
|
807 { |
|
808 if(iGenerationQueue[itemIndex].iItemAction == EGenerationItemAction2ndAdd) |
|
809 { |
|
810 iGenerationQueue.Remove(itemIndex); |
|
811 } |
|
812 } |
691 } |
813 } |
692 // 1st roung generation |
814 // 1st roung generation |
693 else |
815 else |
694 { |
816 { |
695 //1st round |
817 //1st round |
696 TN_DEBUG1( "CThumbAGProcessor::CreateThumbnailsL() EOptimizeForQualityWithPreview"); |
818 TN_DEBUG1( "CThumbAGProcessor::CreateThumbnailsL() EOptimizeForQualityWithPreview"); |
697 iTMSession->SetQualityPreferenceL( CThumbnailManager::EOptimizeForQualityWithPreview ); |
819 iTMSession->SetQualityPreferenceL( CThumbnailManager::EOptimizeForQualityWithPreview ); |
698 |
820 |
699 CMdEObjectDef& videoObjectDef = iDefNamespace->GetObjectDefL( MdeConstants::Video::KVideoObject ); |
|
700 |
|
701 // add item to 2nd round queue |
821 // add item to 2nd round queue |
702 if(iLastQueue == &iAddQueue || iLastQueue == &iModifyQueue) |
822 TN_DEBUG2( "CThumbAGProcessor::CreateThumbnailsL() - 1st round add/modify, append to 2nd round queue", aObject->Id() ); |
703 { |
823 |
704 TN_DEBUG2( "CThumbAGProcessor::CreateThumbnailsL() - 1st round add/modify, append to 2nd round queue", aObject->Id() ); |
824 TThumbnailGenerationItem item; |
705 if(i2ndRoundGenerateQueue.FindInOrder(aObject->Id(), Compare) == KErrNotFound) |
825 item.iItemId = aObject->Id(); |
|
826 TInt itemIndex = iGenerationQueue.FindInOrder(item, Compare); |
|
827 |
|
828 if(itemIndex >=0 ) |
|
829 { |
|
830 if(iGenerationQueue[itemIndex].iItemAction == EGenerationItemActionModify) |
706 { |
831 { |
707 // ignore if fails |
832 iGenerationQueue.Remove(itemIndex); |
708 i2ndRoundGenerateQueue.InsertInOrder(aObject->Id(), Compare); |
833 } |
709 } |
834 //change 1st round item for 2nd round processing |
710 } |
835 //2nd round item can be deleted |
711 |
836 else if(iGenerationQueue[itemIndex].iItemAction == EGenerationItemActionAdd) |
712 /*CMdEProperty* inDefaultFolder = NULL; |
837 { |
713 TBool inDefaultFolderVal(ETrue); |
838 iGenerationQueue[itemIndex].iItemAction = EGenerationItemAction2ndAdd; |
714 TInt inDefaultFolderErr = aObject->Property( baseObjDef.GetPropertyDefL( MdeConstants::Object::KInDefaultFolder ), inDefaultFolder, 0 ); |
839 } |
715 |
840 else |
716 if(inDefaultFolder && inDefaultFolderErr >= 0 ) |
841 { |
717 { |
842 iGenerationQueue.Remove(itemIndex); |
718 inDefaultFolderVal = inDefaultFolder->BoolValueL(); |
843 } |
719 }*/ |
|
720 |
|
721 // Symbian^3 specific |
|
722 if( !(( imageObjectDef.Id() == aObject->Def().Id() || videoObjectDef.Id() == aObject->Def().Id()) |
|
723 /*&& inDefaultFolderVal*/ ) ) |
|
724 { |
|
725 TN_DEBUG1( "CThumbAGProcessor::CreateThumbnailsL() 1st round; not image or video in default folder, skip"); |
|
726 ActivateAO(); |
|
727 return; |
|
728 } |
844 } |
729 } |
845 } |
730 |
846 |
731 // run as lower priority than getting but higher that creating thumbnails |
847 // run as lower priority than getting but higher that creating thumbnails |
732 TRAPD(err, iTMSession->UpdateThumbnailsL(KNoId, aObject->Uri(), orientationVal, modifiedVal, CActive::EPriorityIdle )); |
848 TRAPD(err, iTMSession->UpdateThumbnailsL(KNoId, aObject->Uri(), orientationVal, modifiedVal, CActive::EPriorityIdle )); |
1111 } |
1264 } |
1112 //waiting for MDS query to complete |
1265 //waiting for MDS query to complete |
1113 else if( iQueryActive ) |
1266 else if( iQueryActive ) |
1114 { |
1267 { |
1115 //state mismatch |
1268 //state mismatch |
1116 if(iForceRun && !iModify) |
1269 if(iForceRun && !(iModify || iUnknown)) |
1117 { |
1270 { |
1118 //cancel query and move items back to original processing queue |
1271 //cancel query and move items back to original processing queue |
1119 DeleteAndCancelQuery(ETrue); |
1272 DeleteAndCancelQuery(ETrue); |
1120 ActivateAO(); |
1273 ActivateAO(); |
1121 } |
1274 } |
1122 else |
1275 else |
1123 { |
1276 { |
1124 TN_DEBUG1( "CThumbAGProcessor::RunL() - waiting for query to complete, abort..." ); |
1277 TN_DEBUG1( "CThumbAGProcessor::RunL() - waiting for query to complete, abort..." ); |
1125 } |
1278 } |
1126 } |
1279 } |
1127 |
1280 else if ( iUnknownItemCount > 0 ) |
|
1281 { |
|
1282 TN_DEBUG1( "void CThumbAGProcessor::RunL() unknown items in queue"); |
|
1283 |
|
1284 i2ndRound = EFalse; |
|
1285 iModify = EFalse; |
|
1286 iUnknown = ETrue; |
|
1287 iQueryActive = ETrue; |
|
1288 |
|
1289 QueryL( EGenerationItemActionResolveType ); |
|
1290 } |
1128 // no items in query queue, start new |
1291 // no items in query queue, start new |
1129 // select queue to process, priority by type |
1292 // select queue to process, priority by type |
1130 else if ( iModifyQueue.Count() > 0 ) |
1293 else if ( iModifyItemCount > 0 ) |
1131 { |
1294 { |
1132 TN_DEBUG1( "void CThumbAGProcessor::RunL() update thumbnails"); |
1295 TN_DEBUG1( "void CThumbAGProcessor::RunL() update thumbnails"); |
1133 |
1296 |
1134 i2ndRound = EFalse; |
1297 i2ndRound = EFalse; |
1135 |
1298 |
1136 // query for object info |
1299 // query for object info |
1137 iQueryActive = ETrue; |
1300 iQueryActive = ETrue; |
1138 iModify = ETrue; |
1301 iModify = ETrue; |
1139 QueryL( iModifyQueue ); |
1302 iUnknown = EFalse; |
|
1303 QueryL( EGenerationItemActionModify ); |
1140 } |
1304 } |
1141 else if ( iAddQueue.Count() > 0 ) |
1305 else if ( iAddItemCount > 0 ) |
1142 { |
1306 { |
1143 TN_DEBUG1( "void CThumbAGProcessor::RunL() update 1st round thumbnails"); |
1307 TN_DEBUG1( "void CThumbAGProcessor::RunL() update 1st round thumbnails"); |
1144 |
1308 |
1145 i2ndRound = EFalse; |
1309 i2ndRound = EFalse; |
1146 |
1310 iUnknown = EFalse; |
1147 // query for object info |
1311 // query for object info |
1148 iQueryActive = ETrue; |
1312 iQueryActive = ETrue; |
1149 |
1313 |
1150 QueryL( iAddQueue ); |
1314 QueryL( EGenerationItemActionAdd ); |
1151 } |
1315 } |
1152 else if ( iRemoveQueue.Count() > 0 ) |
1316 else if ( iDeleteItemCount > 0 ) |
1153 { |
1317 { |
1154 TN_DEBUG1( "void CThumbAGProcessor::RunL() delete thumbnails"); |
1318 TN_DEBUG1( "void CThumbAGProcessor::RunL() delete thumbnails"); |
1155 |
|
1156 i2ndRound = EFalse; |
1319 i2ndRound = EFalse; |
1157 |
1320 iUnknown = EFalse; |
1158 // delete thumbs by URI |
1321 // delete thumbs by URI |
1159 __ASSERT_DEBUG((iTMSession), User::Panic(_L("CThumbAGProcessor::RunL() !iTMSession "), KErrBadHandle)); |
1322 __ASSERT_DEBUG((iTMSession), User::Panic(_L("CThumbAGProcessor::RunL() !iTMSession "), KErrBadHandle)); |
1160 if(iTMSession) |
1323 if(iTMSession) |
1161 { |
1324 { |
1162 HBufC* uri = iRemoveQueue[0]; |
1325 TInt itemIndex(KErrNotFound); |
1163 TN_DEBUG2( "void CThumbAGProcessor::RunL() delete %S", uri); |
1326 |
1164 CThumbnailObjectSource* source = NULL; |
1327 for(TInt i=0;i<iGenerationQueue.Count() || itemIndex == KErrNotFound;i++) |
1165 TRAPD(err, source = CThumbnailObjectSource::NewL( *uri, KNullDesC)); |
1328 { |
1166 |
1329 if(iGenerationQueue[i].iItemAction == EGenerationItemActionDelete) |
1167 if(err == KErrNone) |
1330 { |
1168 { |
1331 itemIndex = i; |
1169 iTMSession->DeleteThumbnails( *source ); |
1332 } |
1170 } |
1333 } |
1171 iRemoveQueue.Remove( 0 ); |
1334 |
1172 delete source; |
1335 if(itemIndex >= 0) |
1173 delete uri; |
1336 { |
1174 |
1337 if(!iGenerationQueue[itemIndex].iUri) |
1175 iActiveCount++; |
1338 { |
1176 iActive = ETrue; |
1339 //URI is invalid |
1177 } |
1340 TN_DEBUG1( "void CThumbAGProcessor::RunL() unable to delete URI inbalid"); |
1178 } |
1341 iGenerationQueue.Remove( itemIndex ); |
1179 else if( i2ndRoundGenerateQueue.Count() > 0) |
1342 ActivateAO(); |
|
1343 return; |
|
1344 } |
|
1345 |
|
1346 TN_DEBUG2( "void CThumbAGProcessor::RunL() delete %S", iGenerationQueue[itemIndex].iUri); |
|
1347 CThumbnailObjectSource* source = NULL; |
|
1348 TRAPD(err, source = CThumbnailObjectSource::NewL( *iGenerationQueue[itemIndex].iUri, KNullDesC)); |
|
1349 |
|
1350 if(err == KErrNone) |
|
1351 { |
|
1352 iTMSession->DeleteThumbnails( *source ); |
|
1353 } |
|
1354 delete source; |
|
1355 |
|
1356 delete iGenerationQueue[itemIndex].iUri; |
|
1357 iGenerationQueue[itemIndex].iUri = NULL; |
|
1358 iGenerationQueue.Remove( itemIndex ); |
|
1359 |
|
1360 iActiveCount++; |
|
1361 } |
|
1362 } |
|
1363 } |
|
1364 else if( i2ndAddItemCount > 0) |
1180 { |
1365 { |
1181 TN_DEBUG1( "void CThumbAGProcessor::RunL() update 2nd round thumbnails"); |
1366 TN_DEBUG1( "void CThumbAGProcessor::RunL() update 2nd round thumbnails"); |
1182 |
1367 |
1183 // query for object info |
1368 // query for object info |
1184 iQueryActive = ETrue; |
1369 iQueryActive = ETrue; |
1185 i2ndRound = ETrue; |
1370 i2ndRound = ETrue; |
1186 QueryL( i2ndRoundGenerateQueue ); |
1371 iUnknown = EFalse; |
|
1372 QueryL( EGenerationItemAction2ndAdd ); |
1187 } |
1373 } |
1188 |
1374 |
1189 TN_DEBUG1( "CThumbAGProcessor::RunL() - end" ); |
1375 TN_DEBUG1( "CThumbAGProcessor::RunL() - end" ); |
1190 } |
1376 } |
1191 |
1377 |
1437 // CThumbAGProcessor::ActivateAO() |
1676 // CThumbAGProcessor::ActivateAO() |
1438 // --------------------------------------------------------------------------- |
1677 // --------------------------------------------------------------------------- |
1439 // |
1678 // |
1440 void CThumbAGProcessor::ActivateAO() |
1679 void CThumbAGProcessor::ActivateAO() |
1441 { |
1680 { |
1442 #ifdef _DEBUG |
1681 UpdateItemCounts(); |
1443 TN_DEBUG6( "CThumbAGProcessor::ActivateAO() items in queue Add = %d, Mod = %d, Del = %d, Query = %d, iPlaceholder = %d", iAddQueue.Count(), iModifyQueue.Count(), iRemoveQueue.Count(), iQueryQueue.Count(), iPlaceholderQueue.Count()); |
|
1444 TN_DEBUG2( "CThumbAGProcessor::ActivateAO() items in queue 2nd Add = %d", i2ndRoundGenerateQueue.Count()); |
|
1445 TN_DEBUG3( "CThumbAGProcessor::ActivateAO() iActive = %d, iActiveCount = %d", iActive, iActiveCount); |
|
1446 TN_DEBUG3( "CThumbAGProcessor::ActivateAO() iHarvesting == %d, iMPXHarvesting == %d", iHarvesting, iMPXHarvesting); |
|
1447 TN_DEBUG4( "CThumbAGProcessor::ActivateAO() iIdle = %d, timer = %d, iForceRun = %d", iIdle, iPeriodicTimer->IsActive(), iForceRun); |
|
1448 TN_DEBUG4( "CThumbAGProcessor::ActivateAO() iModify = %d, iQueryReady = %d, iProcessingCount = %d", iModify, iQueryReady, iProcessingCount); |
|
1449 #endif |
|
1450 |
1682 |
1451 if(iFormatting) |
1683 if(iFormatting) |
1452 { |
1684 { |
1453 TN_DEBUG1( "CThumbAGProcessor::ActivateAO() - FORMATTING - DAEMON ON PAUSE"); |
1685 TN_DEBUG1( "CThumbAGProcessor::ActivateAO() - FORMATTING - DAEMON ON PAUSE"); |
1454 return; |
1686 return; |
1455 } |
1687 } |
1456 |
1688 |
1457 //check if forced run needs to continue |
1689 //check if forced run needs to continue |
1458 if (iModifyQueue.Count()) |
1690 if ( iModifyItemCount || iUnknownItemCount > 0 ) |
1459 { |
1691 { |
1460 SetForceRun( ETrue ); |
1692 SetForceRun( ETrue ); |
1461 } |
1693 } |
1462 else |
1694 else |
1463 { |
1695 { |
1464 iModify = EFalse; |
1696 iModify = EFalse; |
1465 SetForceRun( EFalse ); |
1697 SetForceRun( EFalse ); |
1466 } |
1698 } |
1467 |
1699 |
1468 if( !IsActive() && !iShutdown && ((!iActive && !iQueryActive) || iForceRun )) |
1700 if( !IsActive() && !iShutdown && ((iActiveCount == 0 && !iQueryActive) || iForceRun )) |
1469 { |
1701 { |
1470 TN_DEBUG1( "CThumbAGProcessor::ActivateAO() - Activated"); |
1702 TN_DEBUG1( "CThumbAGProcessor::ActivateAO() - Activated"); |
1471 SetActive(); |
1703 SetActive(); |
1472 TRequestStatus* statusPtr = &iStatus; |
1704 TRequestStatus* statusPtr = &iStatus; |
1473 User::RequestComplete( statusPtr, KErrNone ); |
1705 User::RequestComplete( statusPtr, KErrNone ); |
1474 } |
1706 } |
1475 |
1707 |
1476 UpdatePSValues(); |
1708 UpdatePSValues(EFalse, EFalse); |
1477 } |
1709 } |
1478 |
1710 |
1479 // --------------------------------------------------------------------------- |
1711 // --------------------------------------------------------------------------- |
1480 // CThumbAGProcessor::PeriodicTimerCallBack() |
1712 // CThumbAGProcessor::PeriodicTimerCallBack() |
1481 // --------------------------------------------------------------------------- |
1713 // --------------------------------------------------------------------------- |
1560 void CThumbAGProcessor::RemoveFromQueues( const RArray<TItemId>& aIDArray, const TBool /*aRemoveFromDelete*/ ) |
1792 void CThumbAGProcessor::RemoveFromQueues( const RArray<TItemId>& aIDArray, const TBool /*aRemoveFromDelete*/ ) |
1561 #endif |
1793 #endif |
1562 { |
1794 { |
1563 TN_DEBUG2( "CThumbAGProcessor::RemoveFromQueues() aRemoveFromDelete == %d - begin", aRemoveFromDelete ); |
1795 TN_DEBUG2( "CThumbAGProcessor::RemoveFromQueues() aRemoveFromDelete == %d - begin", aRemoveFromDelete ); |
1564 |
1796 |
1565 TInt itemIndex = KErrNotFound; |
1797 TInt itemIndex(KErrNotFound); |
1566 |
1798 |
1567 for (int i=0; i< aIDArray.Count(); i++) |
1799 for (int i=0; i< aIDArray.Count(); i++) |
1568 { |
1800 { |
|
1801 TThumbnailGenerationItem item; |
|
1802 item.iItemId = aIDArray[i]; |
1569 TN_DEBUG2( "CThumbAGProcessor::RemoveFromQueues() - %d", aIDArray[i]); |
1803 TN_DEBUG2( "CThumbAGProcessor::RemoveFromQueues() - %d", aIDArray[i]); |
1570 |
1804 |
1571 itemIndex = iPlaceholderQueue.FindInOrder(aIDArray[i], Compare); |
1805 itemIndex = iGenerationQueue.FindInOrder(item, Compare); |
1572 if(itemIndex >= 0) |
1806 if(itemIndex >= 0) |
1573 { |
1807 { |
1574 iPlaceholderQueue.Remove(itemIndex); |
1808 delete iGenerationQueue[itemIndex].iUri; |
1575 TN_DEBUG1( "CThumbAGProcessor::RemoveFromQueues() - iPlaceholderQueue" ); |
1809 iGenerationQueue[itemIndex].iUri = NULL; |
|
1810 iGenerationQueue.Remove(itemIndex); |
|
1811 TN_DEBUG1( "CThumbAGProcessor::RemoveFromQueues() - iGenerationQueue" ); |
1576 } |
1812 } |
1577 |
1813 |
1578 itemIndex = iAddQueue.FindInOrder(aIDArray[i], Compare); |
1814 itemIndex = iQueryQueue.FindInOrder(aIDArray[i], CompareId); |
1579 if(itemIndex >= 0) |
|
1580 { |
|
1581 iAddQueue.Remove(itemIndex); |
|
1582 TN_DEBUG1( "CThumbAGProcessor::RemoveFromQueues() - iAddQueue" ); |
|
1583 } |
|
1584 |
|
1585 itemIndex = i2ndRoundGenerateQueue.FindInOrder(aIDArray[i], Compare); |
|
1586 if(itemIndex >= 0) |
|
1587 { |
|
1588 i2ndRoundGenerateQueue.Remove(itemIndex); |
|
1589 TN_DEBUG1( "CThumbAGProcessor::RemoveFromQueues() - i2ndRoundGenerateQueue" ); |
|
1590 } |
|
1591 |
|
1592 itemIndex = iModifyQueue.FindInOrder(aIDArray[i], Compare); |
|
1593 if(itemIndex >= 0) |
|
1594 { |
|
1595 iModifyQueue.Remove(itemIndex); |
|
1596 TN_DEBUG1( "CThumbAGProcessor::RemoveFromQueues() - iModifyQueue" ); |
|
1597 |
|
1598 if( iModifyQueue.Count() == 0) |
|
1599 { |
|
1600 SetForceRun( EFalse ); |
|
1601 } |
|
1602 } |
|
1603 |
|
1604 itemIndex = iQueryQueue.FindInOrder(aIDArray[i], Compare); |
|
1605 if(itemIndex >= 0) |
1815 if(itemIndex >= 0) |
1606 { |
1816 { |
1607 iQueryQueue.Remove(itemIndex); |
1817 iQueryQueue.Remove(itemIndex); |
1608 TN_DEBUG1( "CThumbAGProcessor::RemoveFromQueues() - iQueryQueue" ); |
1818 TN_DEBUG1( "CThumbAGProcessor::RemoveFromQueues() - iQueryQueue" ); |
1609 } |
1819 } |
1610 |
1820 } |
1611 itemIndex = iPlaceholderQueue.FindInOrder(aIDArray[i], Compare); |
1821 |
1612 if(itemIndex >= 0) |
1822 ActivateAO(); |
1613 { |
|
1614 iPlaceholderQueue.Remove(itemIndex); |
|
1615 TN_DEBUG1( "CThumbAGProcessor::RemoveFromQueues() - iPlaceholderQueue" ); |
|
1616 } |
|
1617 } |
|
1618 |
1823 |
1619 TN_DEBUG1( "CThumbAGProcessor::RemoveFromQueues() - end" ); |
1824 TN_DEBUG1( "CThumbAGProcessor::RemoveFromQueues() - end" ); |
1620 } |
1825 } |
1621 |
1826 |
1622 // --------------------------------------------------------------------------- |
1827 // --------------------------------------------------------------------------- |
1846 // --------------------------------------------------------------------------- |
2050 // --------------------------------------------------------------------------- |
1847 // CThumbAGProcessor::UpdateItemsLeft |
2051 // CThumbAGProcessor::UpdateItemsLeft |
1848 // Update KItemsleft PS value if changed |
2052 // Update KItemsleft PS value if changed |
1849 // --------------------------------------------------------------------------- |
2053 // --------------------------------------------------------------------------- |
1850 // |
2054 // |
1851 void CThumbAGProcessor::UpdatePSValues(const TBool aDefine) |
2055 void CThumbAGProcessor::UpdatePSValues(const TBool aDefine, const TBool aForce) |
1852 { |
2056 { |
1853 TInt itemsLeft = iModifyQueue.Count() + iAddQueue.Count(); |
2057 TInt itemsLeft(KErrNotReady); |
1854 TBool daemonProcessing = EFalse; |
2058 TBool daemonProcessing = ETrue; |
1855 |
2059 |
1856 if(iShutdown) |
2060 if(iShutdown) |
1857 { |
2061 { |
1858 RProperty::Set(KTAGDPSNotification, KDaemonProcessing, EFalse); |
2062 RProperty::Set(KTAGDPSNotification, KDaemonProcessing, EFalse); |
1859 RProperty::Set(KTAGDPSNotification, KItemsleft, 0 ); |
2063 RProperty::Set(KTAGDPSNotification, KItemsleft, 0 ); |
1860 return; |
2064 return; |
1861 } |
2065 } |
1862 |
2066 |
1863 if(itemsLeft + i2ndRoundGenerateQueue.Count() + iRemoveQueue.Count() > 0 ) |
|
1864 { |
|
1865 daemonProcessing = ETrue; |
|
1866 } |
|
1867 |
|
1868 //adjust items left to containing also items not yet processed but removed from queue under processing |
|
1869 if((iLastQueue == &iModifyQueue || iLastQueue == &iAddQueue) && !i2ndRound) |
|
1870 { |
|
1871 itemsLeft +=iQueryQueue.Count(); |
|
1872 } |
|
1873 |
|
1874 //cancel 2nd round generarion when there is items in 1st round queues |
|
1875 if(itemsLeft && i2ndRound) |
|
1876 { |
|
1877 DeleteAndCancelQuery(ETrue); |
|
1878 i2ndRound = EFalse; |
|
1879 } |
|
1880 |
|
1881 TN_DEBUG2( "CThumbAGProcessor::UpdatePSValues() KItemsleft == %d", itemsLeft); |
|
1882 |
|
1883 if(aDefine) |
2067 if(aDefine) |
1884 { |
2068 { |
1885 TN_DEBUG1( "CThumbAGProcessor::UpdatePSValues() define"); |
2069 TInt ret = RProperty::Define(KTAGDPSNotification, KDaemonProcessing, RProperty::EInt); |
1886 RProperty::Define(KTAGDPSNotification, KDaemonProcessing, RProperty::EInt); |
2070 |
1887 RProperty::Set(KTAGDPSNotification, KDaemonProcessing, 0); |
2071 if( ret != KErrNone ) |
1888 daemonProcessing = EFalse; |
2072 { |
1889 RProperty::Define(KTAGDPSNotification, KItemsleft, RProperty::EInt); |
2073 TN_DEBUG2( "CThumbAGProcessor::UpdatePSValues() define KDaemonProcessing ret = %d", ret); |
1890 RProperty::Set(KTAGDPSNotification, KItemsleft, 0); |
2074 } |
1891 iPreviousItemsLeft = 0; |
2075 |
1892 } |
2076 ret = RProperty::Define(KTAGDPSNotification, KItemsleft, RProperty::EInt); |
1893 |
2077 |
1894 if( daemonProcessing != iPreviousDaemonProcessing) |
2078 if( ret != KErrNone ) |
1895 { |
2079 { |
1896 TN_DEBUG2( "CThumbAGProcessor::UpdatePSValues() update KDaemonProcessing == %d", daemonProcessing); |
2080 TN_DEBUG2( "CThumbAGProcessor::UpdatePSValues() define KItemsleft ret = %d", ret); |
1897 iPreviousDaemonProcessing = daemonProcessing; |
2081 } |
1898 RProperty::Set(KTAGDPSNotification, KDaemonProcessing, daemonProcessing); |
2082 } |
1899 } |
2083 |
1900 |
2084 // set itemsleft = KErrNotReady (-18) and daemonProcessing = ETrue if |
1901 if( itemsLeft != iPreviousItemsLeft) |
2085 // - key is initalized |
1902 { |
2086 // - mount timer is pending |
1903 TN_DEBUG2( "CThumbAGProcessor::UpdatePSValues() update KItemsleft == %d", itemsLeft); |
2087 // - harvester observer is not yet activated |
1904 iPreviousItemsLeft = itemsLeft; |
2088 // - single unknown item exists in processing queue |
1905 RProperty::Set(KTAGDPSNotification, KItemsleft, itemsLeft ); |
2089 // - forced |
1906 } |
2090 if( iMountTimer->IsActive() || aForce || aDefine || iUnknownItemCount |
|
2091 || !iHarvesterActivated ) |
|
2092 { |
|
2093 daemonProcessing = ETrue; |
|
2094 itemsLeft = KErrNotReady; |
|
2095 } |
|
2096 else |
|
2097 { |
|
2098 itemsLeft = iAddItemCount + iModifyItemCount; |
|
2099 } |
|
2100 |
|
2101 TN_DEBUG2( "CThumbAGProcessor::UpdatePSValues() KItemsleft == %d", itemsLeft); |
|
2102 |
|
2103 //cancel 2nd round generarion when there is items in 1st round queues |
|
2104 if(iAddItemCount && i2ndRound) |
|
2105 { |
|
2106 DeleteAndCancelQuery(ETrue); |
|
2107 i2ndRound = EFalse; |
|
2108 } |
|
2109 |
|
2110 if( iGenerationQueue.Count() ) |
|
2111 { |
|
2112 daemonProcessing = ETrue; |
|
2113 } |
|
2114 else |
|
2115 { |
|
2116 daemonProcessing = EFalse; |
|
2117 } |
|
2118 |
|
2119 if( daemonProcessing != iPreviousDaemonProcessing) |
|
2120 { |
|
2121 TN_DEBUG2( "CThumbAGProcessor::UpdatePSValues() update KDaemonProcessing == %d", daemonProcessing); |
|
2122 iPreviousDaemonProcessing = daemonProcessing; |
|
2123 TInt ret = RProperty::Set(KTAGDPSNotification, KDaemonProcessing, daemonProcessing); |
|
2124 |
|
2125 if(ret != KErrNone ) |
|
2126 { |
|
2127 TN_DEBUG3( "CThumbAGProcessor::UpdatePSValues() set KDaemonProcessing %d failed %d", daemonProcessing, ret); |
|
2128 } |
|
2129 } |
|
2130 |
|
2131 if( itemsLeft != iPreviousItemsLeft) |
|
2132 { |
|
2133 TN_DEBUG2( "CThumbAGProcessor::UpdatePSValues() update KItemsleft == %d", itemsLeft); |
|
2134 iPreviousItemsLeft = itemsLeft; |
|
2135 TInt ret = RProperty::Set(KTAGDPSNotification, KItemsleft, itemsLeft ); |
|
2136 |
|
2137 if(ret != KErrNone ) |
|
2138 { |
|
2139 TN_DEBUG3( "CThumbAGProcessor::UpdatePSValues() set KItemsleft %d failed %d", itemsLeft, ret); |
|
2140 } |
|
2141 } |
|
2142 |
1907 } |
2143 } |
1908 |
2144 |
1909 // --------------------------------------------------------------------------- |
2145 // --------------------------------------------------------------------------- |
1910 // CThumbAGProcessor::Compare |
2146 // CThumbAGProcessor::Compare |
1911 // Comparison function for logaritmic use of queue arrays |
2147 // Comparison function for logaritmic use of queue arrays |
1912 // --------------------------------------------------------------------------- |
2148 // --------------------------------------------------------------------------- |
1913 // |
2149 // |
1914 TInt CThumbAGProcessor::Compare(const TItemId& aLeft, const TItemId& aRight) |
2150 |
|
2151 TInt CThumbAGProcessor::Compare(const TThumbnailGenerationItem& aLeft, const TThumbnailGenerationItem& aRight) |
|
2152 { |
|
2153 return (aLeft.iItemId - aRight.iItemId); |
|
2154 } |
|
2155 |
|
2156 TInt CThumbAGProcessor::CompareId(const TItemId& aLeft, const TItemId& aRight) |
1915 { |
2157 { |
1916 return (aLeft - aRight); |
2158 return (aLeft - aRight); |
1917 } |
2159 } |
1918 |
2160 |
|
2161 void CThumbAGProcessor::UpdateItemCounts() |
|
2162 { |
|
2163 TN_DEBUG1( "CThumbAGProcessor::UpdateItemCounts()"); |
|
2164 iModifyItemCount = 0; |
|
2165 iDeleteItemCount = 0; |
|
2166 iAddItemCount = 0; |
|
2167 iUnknownItemCount = 0; |
|
2168 i2ndAddItemCount = 0; |
|
2169 iPlaceholderItemCount=0; |
|
2170 iCameraItemCount =0; |
|
2171 iImageItemCount=0; |
|
2172 iVideoItemCount=0; |
|
2173 iAudioItemCount=0; |
|
2174 |
|
2175 for(TInt i=0; i < iGenerationQueue.Count(); i++) |
|
2176 { |
|
2177 TThumbnailGenerationItem& item = iGenerationQueue[i]; |
|
2178 |
|
2179 if(item.iItemAction == EGenerationItemActionModify) |
|
2180 { |
|
2181 iModifyItemCount++; |
|
2182 } |
|
2183 |
|
2184 if(item.iItemAction == EGenerationItemActionDelete) |
|
2185 { |
|
2186 iDeleteItemCount++; |
|
2187 } |
|
2188 |
|
2189 if(item.iItemType == EGenerationItemTypeUnknown) |
|
2190 { |
|
2191 iUnknownItemCount++; |
|
2192 } |
|
2193 if(item.iItemAction == EGenerationItemAction2ndAdd) |
|
2194 { |
|
2195 i2ndAddItemCount++; |
|
2196 } |
|
2197 if(item.iPlaceholder) |
|
2198 { |
|
2199 iPlaceholderItemCount++; |
|
2200 } |
|
2201 if(item.iItemType == EGenerationItemTypeCamera) |
|
2202 { |
|
2203 iCameraItemCount++; |
|
2204 } |
|
2205 if(item.iItemAction == EGenerationItemActionAdd ) |
|
2206 { |
|
2207 iAddItemCount++; |
|
2208 } |
|
2209 if(item.iItemType == EGenerationItemTypeAudio) |
|
2210 { |
|
2211 iAudioItemCount++; |
|
2212 } |
|
2213 if(item.iItemType == EGenerationItemTypeVideo) |
|
2214 { |
|
2215 iVideoItemCount++; |
|
2216 } |
|
2217 if(item.iItemType == EGenerationItemTypeImage) |
|
2218 { |
|
2219 iImageItemCount++; |
|
2220 } |
|
2221 } |
|
2222 |
|
2223 TN_DEBUG2( "CThumbAGProcessor::UpdateItemCounts() iActiveCount = %d", |
|
2224 iActiveCount); |
|
2225 TN_DEBUG2( "CThumbAGProcessor::UpdateItemCounts() iPreviousItemsLeft = %d", |
|
2226 iPreviousItemsLeft); |
|
2227 TN_DEBUG5( "CThumbAGProcessor::UpdateItemCounts() iHarvesting == %d, iMMCHarvesting == %d, iPHHarvesting == %d, iMPXHarvesting == %d", |
|
2228 iHarvesting, iMMCHarvesting, iPHHarvesting, iMPXHarvesting); |
|
2229 TN_DEBUG5( "CThumbAGProcessor::UpdateItemCounts() iIdle = %d, iForegroundRun = %d, timer = %d, iForceRun = %d", |
|
2230 iIdle, iForegroundRun, iPeriodicTimer->IsActive(), iForceRun); |
|
2231 TN_DEBUG4( "CThumbAGProcessor::UpdateItemCounts() iModify = %d, iQueryReady = %d, iProcessingCount = %d", |
|
2232 iModify, iQueryReady, iProcessingCount); |
|
2233 TN_DEBUG2( "CThumbAGProcessor::UpdateItemCounts() iMountTimer = %d", iMountTimer->IsActive()); |
|
2234 TN_DEBUG3( "CThumbAGProcessor::UpdateItemCounts() iGenerationQueue = %d, iQueryQueue = %d", |
|
2235 iGenerationQueue.Count(), iQueryQueue.Count()); |
|
2236 TN_DEBUG5( "CThumbAGProcessor::UpdateItemCounts() iAddItemCount=%d, i2ndAddItemCount=%d, iModifyItemCount=%d, iDeleteItemCount=%d", |
|
2237 iAddItemCount, i2ndAddItemCount, iModifyItemCount, iDeleteItemCount ); |
|
2238 TN_DEBUG3( "CThumbAGProcessor::UpdateItemCounts() iUnknownItemCount=%d, iPlaceholderItemCount=%d", |
|
2239 iUnknownItemCount, iPlaceholderItemCount); |
|
2240 TN_DEBUG4( "CThumbAGProcessor::UpdateItemCounts() iAudioItemCount=%d, iVideoItemCount=%d, iImageItemCount=%d", |
|
2241 iAudioItemCount, iVideoItemCount, iImageItemCount); |
|
2242 TN_DEBUG2( "CThumbAGProcessor::UpdateItemCounts() iCameraItemCount=%d", iCameraItemCount); |
|
2243 |
|
2244 //compress queues when empty |
|
2245 if(!iGenerationQueue.Count()) |
|
2246 { |
|
2247 iGenerationQueue.Compress(); |
|
2248 } |
|
2249 |
|
2250 if(!iQueryQueue.Count()) |
|
2251 { |
|
2252 iQueryQueue.Compress(); |
|
2253 } |
|
2254 } |
|
2255 |
|
2256 |
|
2257 // --------------------------------------------------------------------------- |
|
2258 // CThumbAGProcessor::MountTimerCallBack() |
|
2259 // --------------------------------------------------------------------------- |
|
2260 // |
|
2261 TInt CThumbAGProcessor::MountTimerCallBack(TAny* aAny) |
|
2262 { |
|
2263 TN_DEBUG1( "CThumbAGProcessor::MountTimerCallBack()"); |
|
2264 CThumbAGProcessor* self = static_cast<CThumbAGProcessor*>( aAny ); |
|
2265 |
|
2266 self->iMountTimer->Cancel(); |
|
2267 |
|
2268 //activate timeout if overall or mmc harvestig is not active |
|
2269 if(!self->iHarvesting && !self->iMMCHarvesting ) |
|
2270 { |
|
2271 self->ActivateAO(); |
|
2272 } |
|
2273 |
|
2274 return KErrNone; // Return value ignored by CPeriodic |
|
2275 } |
|
2276 |
|
2277 // --------------------------------------------------------------------------- |
|
2278 // CThumbAGProcessor::SetGenerationItemAction() |
|
2279 // --------------------------------------------------------------------------- |
|
2280 // |
|
2281 void CThumbAGProcessor::SetGenerationItemAction( TThumbnailGenerationItem& aGenerationItem, TThumbnailGenerationItemType aItemType ) |
|
2282 { |
|
2283 switch( aItemType ) |
|
2284 { |
|
2285 case EGenerationItemTypeAudio: |
|
2286 aGenerationItem.iItemAction = EGenerationItemAction2ndAdd; |
|
2287 break; |
|
2288 case EGenerationItemTypeCamera: |
|
2289 aGenerationItem.iItemAction = EGenerationItemAction2ndAdd; |
|
2290 aGenerationItem.iPlaceholder = ETrue; |
|
2291 break; |
|
2292 case EGenerationItemTypeImage: |
|
2293 aGenerationItem.iItemAction = EGenerationItemActionAdd; |
|
2294 break; |
|
2295 case EGenerationItemTypeVideo: |
|
2296 //S^3 EGenerationItemActionAdd |
|
2297 //S^4 EGenerationItemAction2ndAdd |
|
2298 aGenerationItem.iItemAction = EGenerationItemActionAdd; |
|
2299 break; |
|
2300 default: |
|
2301 aGenerationItem.iItemAction = EGenerationItemActionResolveType; |
|
2302 } |
|
2303 } |
|
2304 |
|
2305 // --------------------------------------------------------------------------- |
|
2306 // CThumbAGProcessor::SetGenerationItemType() |
|
2307 // --------------------------------------------------------------------------- |
|
2308 // |
|
2309 void CThumbAGProcessor::SetGenerationItemType( TThumbnailGenerationItem& aGenerationItem, const TDefId aDefId ) |
|
2310 { |
|
2311 if(aDefId == iImageObjectDef->Id()) |
|
2312 { |
|
2313 aGenerationItem.iItemType = EGenerationItemTypeImage; |
|
2314 } |
|
2315 else if(aDefId == iAudioObjectDef->Id()) |
|
2316 { |
|
2317 aGenerationItem.iItemType = EGenerationItemTypeAudio; |
|
2318 } |
|
2319 else if(aDefId == iVideoObjectDef->Id()) |
|
2320 { |
|
2321 aGenerationItem.iItemType = EGenerationItemTypeVideo; |
|
2322 } |
|
2323 else |
|
2324 { |
|
2325 aGenerationItem.iItemType = EGenerationItemTypeUnknown; |
|
2326 } |
|
2327 |
|
2328 SetGenerationItemAction( aGenerationItem, aGenerationItem.iItemType ); |
|
2329 } |
|
2330 |
|
2331 |
|
2332 // ----------------------------------------------------------------------------- |
|
2333 // CThumbAGProcessor::AppendProcessingQueue() |
|
2334 // ----------------------------------------------------------------------------- |
|
2335 // |
|
2336 void CThumbAGProcessor::AppendProcessingQueue( TThumbnailGenerationItem& item ) |
|
2337 { |
|
2338 |
|
2339 TInt itemIndex = iGenerationQueue.FindInOrder( item, Compare ); |
|
2340 |
|
2341 if(itemIndex >= 0) |
|
2342 { |
|
2343 iGenerationQueue[itemIndex].iPlaceholder = item.iPlaceholder; |
|
2344 iGenerationQueue[itemIndex].iItemType = item.iItemType; |
|
2345 iGenerationQueue[itemIndex].iItemAction = item.iItemAction; |
|
2346 } |
|
2347 else |
|
2348 { |
|
2349 iGenerationQueue.InsertInOrder(item, Compare); |
|
2350 } |
|
2351 } |
|
2352 |
1919 |
2353 |
1920 // End of file |
2354 // End of file |