FCL/sf/mw/imghandling: comparison imagehandlingutilities/thumbnailmanager/thumbagdaemon/src/thumbagprocessor.cpp

equal deleted inserted replaced

-:ea43e3e86079
+:a0ee3f735f8b
 // ---------------------------------------------------------------------------
 // CThumbAGProcessor::CThumbAGProcessor()
 // ---------------------------------------------------------------------------
 //
-CThumbAGProcessor::CThumbAGProcessor(): CActive( CActive::EPriorityStandard )
+CThumbAGProcessor::CThumbAGProcessor(): CActive( CActive::EPriorityStandard ), iMMCHarvestingItemsLeftTemp(0),
+iPHHarvestingItemsLeftTemp(0)
 {
 TN_DEBUG1( "CThumbAGProcessor::CThumbAGProcessor() - begin" );
 CActiveScheduler::Add( this );
 }
 //
 void CThumbAGProcessor::ConstructL()
 {
 TN_DEBUG1( "CThumbAGProcessor::ConstructL() - begin" );
+iShutdown = EFalse;
 iTMSession = CThumbnailManager::NewL( *this );
+iTMSession->SetRequestObserver(*this);
 iQueryAllItems = NULL;
 iQueryPlaceholders = NULL;
 iQuery = NULL;
 iQueryActive = EFalse;
 iModify = EFalse;
 iActiveCount = 0;
 // set auto create values from cenrep
 CheckAutoCreateValuesL();
-iPeriodicTimer = CPeriodic::NewL(CActive::EPriorityIdle);
+iPeriodicTimer = CPeriodic::NewL(CActive::EPriorityStandard);
+iMountTimer = CPeriodic::NewL(CActive::EPriorityUserInput);
 SetForceRun( EFalse );
-iActive = EFalse;
 iFormatObserver = CTMFormatObserver::NewL( *this );
 iFormatting = EFalse;
 iSessionDied = EFalse;
 iCollectionUtility = NULL;
 iActivityManager = CTMActivityManager::NewL( this, KBackgroundGenerationIdle);
-UpdatePSValues(ETrue);
+UpdatePSValues(ETrue, ETrue);
-if(iForegroundGenerationObserver)
-{
-delete iForegroundGenerationObserver;
-iForegroundGenerationObserver = NULL;
-}
 RProperty::Define(KTAGDPSNotification, KMPXHarvesting, RProperty::EInt);
 	//start foreground generation observer
 iForegroundGenerationObserver = CTMRPropertyObserver::NewL( *this, KTAGDPSNotification, KForceBackgroundGeneration, ETrue );
 //
 CThumbAGProcessor::~CThumbAGProcessor()
 {
 TN_DEBUG1( "CThumbAGProcessor::~CThumbAGProcessor() - begin" );
-if(iForegroundGenerationObserver)
+Shutdown();
-{
-delete iForegroundGenerationObserver;
+Cancel();
-iForegroundGenerationObserver = NULL;
-}
+if (iTMSession)
+{
+iTMSession->RemoveRequestObserver();
+delete iTMSession;
+iTMSession = NULL;
+}
+if(iMountTimer)
+{
+iMountTimer->Cancel();
+delete iMountTimer;
+iMountTimer = NULL;
+}
+if(iPeriodicTimer)
+{
+iPeriodicTimer->Cancel();
+delete iPeriodicTimer;
+iPeriodicTimer = NULL;
+}
 if(iActivityManager)
 {
 delete iActivityManager;
 iActivityManager = NULL;
 }
-if (iInactivityTimer)
+if (iQuery)
 {
-iInactivityTimer->Cancel();
+iQuery->Cancel();
-delete iInactivityTimer;
+delete iQuery;
-iInactivityTimer = NULL;
+iQuery = NULL;
 }
-if(iPeriodicTimer)
-{
-iPeriodicTimer->Cancel();
-delete iPeriodicTimer;
-}
-if (!iInit)
-{
-#ifdef MDS_MODIFY_OBSERVER
-iHarvesterClient.RemoveHarvesterEventObserver(*this);
-iHarvesterClient.Close();
-#endif
-}
-if ( iCollectionUtility )
-{
-iCollectionUtility->Close();
-iCollectionUtility = NULL;
-}
-Cancel();
 if(iQueryPlaceholders)
 {
 iQueryPlaceholders->Cancel();
 delete iQueryPlaceholders;
 iQueryPlaceholders = NULL;
-}
-if (iQuery)
-{
-iQuery->Cancel();
-delete iQuery;
-iQuery = NULL;
 }
 if (iQueryAllItems)
 {
 iQueryAllItems->Cancel();
 delete iQueryAllItems;
 iQueryAllItems = NULL;
 }
-iAddQueue.Close();
+if (!iInit)
-iModifyQueue.Close();
+{
-iRemoveQueue.ResetAndDestroy();
+#ifdef MDS_MODIFY_OBSERVER
+iHarvesterClient.RemoveHarvesterEventObserver(*this);
+iHarvesterClient.Close();
+#endif
+}
+if(iForegroundGenerationObserver)
+{
+delete iForegroundGenerationObserver;
+iForegroundGenerationObserver = NULL;
+}
+if(iFormatObserver)
+{
+delete iFormatObserver;
+iFormatObserver = NULL;
+}
+if ( iCollectionUtility )
+{
+iCollectionUtility->Close();
+iCollectionUtility = NULL;
+}
+for(TInt i=0;i<iGenerationQueue.Count();i++)
+{
+delete iGenerationQueue[i].iUri;
+iGenerationQueue[i].iUri = NULL;
+}
+iGenerationQueue.Reset();
+iGenerationQueue.Close();
 iQueryQueue.Close();
-iPlaceholderQueue.Close();
-i2ndRoundGenerateQueue.Close();
-if (iTMSession)
-{
-delete iTMSession;
-iTMSession = NULL;
-}
-delete iFormatObserver;
 TN_DEBUG1( "CThumbAGProcessor::~CThumbAGProcessor() - end" );
+}
+// ---------------------------------------------------------------------------
+// CThumbAGProcessor::Shutdown()
+// ---------------------------------------------------------------------------
+//
+void CThumbAGProcessor::Shutdown()
+{
+TN_DEBUG1( "CThumbAGProcessor::Shutdown()" );
+iShutdown = ETrue;
+UpdatePSValues(EFalse, EFalse);
 }
 // -----------------------------------------------------------------------------
 // CThumbAGProcessor::HandleQueryNewResults()
 // -----------------------------------------------------------------------------
 void CThumbAGProcessor::HandleQueryNewResults( CMdEQuery& aQuery,
 const TInt aFirstNewItemIndex,
 const TInt aNewItemCount )
 {
 // PH & AllItems query results are handled here
+if(iShutdown)
+{
+return;
+}
 if (aNewItemCount > 0)
 {
 if(&aQuery == iQueryPlaceholders)
 {
 TN_DEBUG2( "CThumbAGProcessor::HandleQueryNewResults - iQueryPlaceholders, %d new", aNewItemCount);
 TN_DEBUG2( "CThumbAGProcessor::HandleQueryNewResults %d not placeholder", object->Id());
 continue;
 }
 // ignore if fails
-iPlaceholderQueue.InsertInOrder(object->Id(), Compare);
+TThumbnailGenerationItem item;
+item.iItemId = object->Id();
+item.iPlaceholder = ETrue;
+SetGenerationItemType( item, object->Def().Id());
+AppendProcessingQueue( item );
 }
 }
 else if(&aQuery == iQueryAllItems)
 {
 TN_DEBUG2( "CThumbAGProcessor::HandleQueryNewResults - QueryAllItems, %d new", aNewItemCount);
 for(TInt i = aFirstNewItemIndex; i < iQueryAllItems->Count(); i++)
 {
 const CMdEObject* object = &iQueryAllItems->Result(i);
 if(!object)
 {
 continue;
 }
-if (iAddQueue.FindInOrder(object->Id(), Compare) == KErrNotFound &&
+TThumbnailGenerationItem item;
-iModifyQueue.FindInOrder(object->Id(), Compare) == KErrNotFound )
+item.iItemId = object->Id();
-{
-// ignore if fails
+SetGenerationItemType(item, object->Def().Id());
-iAddQueue.InsertInOrder(object->Id(), Compare);
-}
+TInt itemIndex = iGenerationQueue.FindInOrder(item, Compare);
+item.iPlaceholder = object->Placeholder();
+AppendProcessingQueue( item );
 }
 }
 }
 else
 {
 //
 void CThumbAGProcessor::HandleQueryCompleted( CMdEQuery& aQuery, const TInt aError )
 {
 TN_DEBUG3( "CThumbAGProcessor::HandleQueryCompleted, aError == %d Count== %d", aError, aQuery.Count());
+if(iShutdown)
+{
+return;
+}
 if(&aQuery == iQueryPlaceholders)
 {
 TN_DEBUG1( "CThumbAGProcessor::HandleQueryCompleted - iQueryPlaceholders completed");
-iPlaceholderQueue.Reset();
 //free query
 delete iQueryPlaceholders;
 iQueryPlaceholders = NULL;
 // if no errors in query
 if (aError == KErrNone && iQuery)
 {
 iProcessingCount = iQuery->Count();
-if(iProcessingCount != iQueryQueue.Count())
+if(iProcessingCount != iQueryQueue.Count() )
 {
 TN_DEBUG1( "CThumbAGProcessor::HandleQueryCompleted() some result items missing");
 RArray<TItemId> queryQueueDelta;
-TInt itemIndex(KErrNotFound);
+//search delta items which were queried, but not found
+for(TInt queryItem =0; queryItem < iQueryQueue.Count();queryItem++)
-//search delta items which were queried, but not found
+{
-for(TInt queryItem =0; queryItem < iQueryQueue.Count();queryItem++)
+TBool found(EFalse);
-{
+for(TInt queryResult = 0; queryResult < iQuery->Count(); queryResult++)
-TBool found(EFalse);
+{
-for(TInt queryResult = 0; queryResult < iQuery->Count(); queryResult++)
+const CMdEObject* object = &iQuery->Result(queryResult);
-{
-const CMdEObject* object = &iQuery->Result(queryResult);
+if( iQueryQueue[queryItem] == object->Id())
+{
-if( iQueryQueue[queryItem] == object->Id())
+found = ETrue;
+break;
+}
+}
+if(!found)
+{
+TN_DEBUG2( "CThumbAGProcessor::HandleQueryCompleted() %d missing from query results", iQueryQueue[queryItem] );
+// ignore if fails
+queryQueueDelta.InsertInOrder(iQueryQueue[queryItem], CompareId);
+}
+}
+TN_DEBUG2( "CThumbAGProcessor::HandleQueryCompleted() missing items found %d", queryQueueDelta.Count());
+//cleanup from previous queue it item is not found from MDS
+while(queryQueueDelta.Count())
+{
+TThumbnailGenerationItem item;
+item.iItemId = queryQueueDelta[0];
+TInt itemIndex = iQueryQueue.FindInOrder(item.iItemId, CompareId);
+if(itemIndex >= 0)
+{
+TN_DEBUG2( "CThumbAGProcessor::HandleQueryCompleted() remove %d from iQueryQueue", queryQueueDelta[0]);
+iQueryQueue.Remove( itemIndex );
+//remove from procesing queue
+itemIndex = iGenerationQueue.FindInOrder(item, Compare);
+if(itemIndex >= 0)
+{
+if( iUnknown )
+{
+TN_DEBUG2( "CThumbAGProcessor::HandleQueryCompleted() mark %d as EGenerationItemTypeNotFound in iGenerationQueue", queryQueueDelta[0]);
+//mark to be removed, cleanup is done below
+iGenerationQueue[itemIndex].iItemType = EGenerationItemTypeNotFound;
+}
+else
+{
+TN_DEBUG2( "CThumbAGProcessor::HandleQueryCompleted() remove %d from iGenerationQueue", queryQueueDelta[0]);
+iGenerationQueue.Remove( itemIndex );
+}
+}
+}
+queryQueueDelta.Remove(0);
+}
+queryQueueDelta.Close();
+}
+if(iUnknown)
+{
+for(TInt i = 0; i < iQuery->Count(); i++)
+{
+const CMdEObject* object = &iQuery->Result(i);
+if(!object)
+{
+continue;
+}
+TThumbnailGenerationItem tempItem;
+tempItem.iItemId = object->Id();
+TInt itemIndex = iGenerationQueue.FindInOrder(tempItem, Compare);
+if(itemIndex >= 0)
 {
-found = ETrue;
+TThumbnailGenerationItem& item = iGenerationQueue[itemIndex];
-break;
+if(iGenerationQueue[itemIndex].iItemType == EGenerationItemTypeNotFound)
+{
+TN_DEBUG2( "CThumbAGProcessor::HandleQueryCompleted() remove EGenerationItemTypeNotFound %d item from iGenerationQueue", item.iItemId);
+iGenerationQueue.Remove(itemIndex);
+continue;
+}
+SetGenerationItemType(item, object->Def().Id());
+if(item.iItemType == EGenerationItemTypeUnknown )
+{
+TN_DEBUG2( "CThumbAGProcessor::HandleQueryCompleted() remove unknown item %d", item.iItemId);
+iGenerationQueue.Remove(itemIndex);
+continue;
+}
+item.iPlaceholder = object->Placeholder();
 }
 }
-if(!found)
+iQueryQueue.Reset();
-{
+iProcessingCount = 0;
-TN_DEBUG2( "CThumbAGProcessor::HandleQueryCompleted() missing from results item %d", iQueryQueue[queryItem] );
+iUnknown = EFalse;
+}
-// ignore if fails
-queryQueueDelta.InsertInOrder(iQueryQueue[queryItem], Compare);
-}
-}
-TN_DEBUG2( "CThumbAGProcessor::HandleQueryCompleted() missing items total count %d", queryQueueDelta.Count());
-//cleanup from previous queue it item is not found from MDS
-while(queryQueueDelta.Count())
-{
-itemIndex = iLastQueue->FindInOrder(queryQueueDelta[0], Compare);
-if(itemIndex >= 0)
-{
-TN_DEBUG2( "CThumbAGProcessor::HandleQueryCompleted() remove items %d", iQueryQueue[0]);
-iLastQueue->Remove( itemIndex );
-}
-queryQueueDelta.Remove(0);
-}
-queryQueueDelta.Close();
-}
 // no results, reset query
-if( !iProcessingCount)
+if( !iProcessingCount )
 {
 delete iQuery;
 iQuery = NULL;
-iProcessingCount = 0;
 iModify = EFalse;
 }
 }
 else
 {
 TN_DEBUG1( "CThumbAGProcessor::ThumbnailPreviewReady()");
 // No implementation required
 }
 // -----------------------------------------------------------------------------
-// CThumbAGProcessor::ThumbnailReady()
+// CThumbAGProcessor::ThumbnailReady()d
 // -----------------------------------------------------------------------------
 //
 void CThumbAGProcessor::ThumbnailReady( TInt aError, MThumbnailData& /*aThumbnail*/,
 TThumbnailRequestId /*aId*/ )
 {
 TN_DEBUG2( "CThumbAGProcessor::ThumbnailReady() aError == %d", aError );
 iActiveCount--;
-if(iActiveCount <= 0)
-{
-iActiveCount = 0;
-iActive = EFalse;
-}
 // TNM server died, delete session
 if( aError == KErrServerTerminated )
 {
 TN_DEBUG1( "CThumbAGProcessor::ThumbnailReady() - **** THUMBNAIL SERVER DIED ****" );
 ActivateAO();
 TN_DEBUG1( "CThumbAGProcessor::ThumbnailReady() - end" );
 }
+// -----------------------------------------------------------------------------
+// CThumbAGProcessor::ThumbnailRequestReady()
+// -----------------------------------------------------------------------------
+//
+void CThumbAGProcessor::ThumbnailRequestReady( TInt /*aError*/, TThumbnailRequestType aRequestType,
+TThumbnailRequestId /*aId*/ )
+{
+if (aRequestType == ERequestDeleteThumbnails)
+{
+TN_DEBUG1( "CThumbAGProcessor::ThumbnailRequestReady() - delete" );
+iActiveCount--;
+ActivateAO();
+}
+}
 // ---------------------------------------------------------------------------
 // CThumbAGProcessor::SetMdESession()
 // ---------------------------------------------------------------------------
 //
-void CThumbAGProcessor::SetMdESession( CMdESession* aMdESession )
+void CThumbAGProcessor::SetMdESessionL( CMdESession* aMdESession )
 {
 TN_DEBUG1( "CThumbAGProcessor::SetMdESession() - begin" );
 iMdESession = aMdESession;
 TRAPD( err, iDefNamespace = &iMdESession->GetDefaultNamespaceDefL() );
 if (err != KErrNone)
 {
 TN_DEBUG2( "CThumbAGProcessor::SetMdESession() GetDefaultNamespaceDefL() err = %d", err );
-}
+__ASSERT_DEBUG((iDefNamespace), User::Panic(_L("CThumbAGProcessor::SetMdESession() !iDefNamespace "), KErrBadHandle));
+}
-__ASSERT_DEBUG((iDefNamespace), User::Panic(_L("CThumbAGProcessor::SetMdESession() !iDefNamespace "), KErrBadHandle));
+else
+{
-//do async init
+iImageObjectDef = &iDefNamespace->GetObjectDefL( MdeConstants::Image::KImageObject );
-iInit = ETrue;
+__ASSERT_DEBUG((iImageObjectDef), User::Panic(_L("CThumbAGProcessor::SetMdESession() !iDefNamespace "), KErrBadHandle));
+iVideoObjectDef = &iDefNamespace->GetObjectDefL( MdeConstants::Video::KVideoObject );
-	ActivateAO();
+__ASSERT_DEBUG((iVideoObjectDef), User::Panic(_L("CThumbAGProcessor::SetMdESession() !iVideoObjectDef "), KErrBadHandle));
+iAudioObjectDef = &iDefNamespace->GetObjectDefL( MdeConstants::Audio::KAudioObject );
+__ASSERT_DEBUG((iAudioObjectDef), User::Panic(_L("CThumbAGProcessor::SetMdESession() !iAudioObjectDef "), KErrBadHandle));
+//do async init
+iInit = ETrue;
+ActivateAO();
+}
 }
 // ---------------------------------------------------------------------------
 // CThumbAGProcessor::AddToQueue()
 // ---------------------------------------------------------------------------
 //
 void CThumbAGProcessor::AddToQueueL( TObserverNotificationType aType,
+TThumbnailGenerationItemType aItemType,
 const RArray<TItemId>& aIDArray,
 const RPointerArray<HBufC>& aObjectUriArray,
 TBool /*aPresent*/ )
 {
 TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - begin" );
 // update queues
 if (aType == ENotifyAdd)
 {
 TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - ENotifyAdd" );
 for (int i=0; i<aIDArray.Count(); i++)
 {
-// do not to append to Add queue if exist already in Add or 2nd Add queue (just processed)
+TThumbnailGenerationItem item;
-if (iAddQueue.FindInOrder(aIDArray[i], Compare) == KErrNotFound &&
+item.iItemId = aIDArray[i];
-i2ndRoundGenerateQueue.FindInOrder(aIDArray[i], Compare) == KErrNotFound)
+item.iItemType = aItemType;
-{
-User::LeaveIfError(iAddQueue.InsertInOrder(aIDArray[i], Compare));
+SetGenerationItemAction(item, aItemType);
-}
+if(iPHHarvesting)
+{
+item.iPlaceholder = ETrue;
+}
+AppendProcessingQueue( item );
 }
 }
 else if (aType == ENotifyModify)
 {
 TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - ENotifyModify" );
 if(iPHHarvesting)
 {
 TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - PH  harvesting active, treat like add" );
 for (int i=0; i<aIDArray.Count(); i++)
 {
-TInt itemIndex = iPlaceholderQueue.FindInOrder(aIDArray[i], Compare);
+TThumbnailGenerationItem item;
+item.iItemId = aIDArray[i];
+item.iItemType = aItemType;
+TInt itemIndex = iGenerationQueue.FindInOrder(item, Compare);
 if (itemIndex >= 0)
 {
-TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - remove from placeholder queue");
+TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - set as non-placeholder");
-iPlaceholderQueue.Remove( itemIndex );
+iGenerationQueue[itemIndex].iPlaceholder = EFalse;
 }
+else
+{
+TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - append");
+item.iPlaceholder = EFalse;
+SetGenerationItemAction( item, aItemType );
+AppendProcessingQueue( item );
+}
+}
+}
+else
+{
+TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - PH  harvesting finished, check is real modify!" );
+TInt itemIndex(KErrNotFound);
+for (int i=0; i<aIDArray.Count(); i++)
+{
+TThumbnailGenerationItem item;
+item.iItemId = aIDArray[i];
+item.iItemType = aItemType;
-if(iAddQueue.FindInOrder(aIDArray[i], Compare) == KErrNotFound &&
+itemIndex = iGenerationQueue.FindInOrder(item, Compare);
-i2ndRoundGenerateQueue.FindInOrder(aIDArray[i], Compare) == KErrNotFound)
-{
-TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - append to add queue");
-User::LeaveIfError(iAddQueue.InsertInOrder(aIDArray[i], Compare));
-}
-}
-}
-else
-{
-TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - PH  harvesting finished, check is real modify!" );
-TInt itemIndex(KErrNotFound);
-for (int i=0; i<aIDArray.Count(); i++)
-{
-itemIndex = iPlaceholderQueue.FindInOrder(aIDArray[i], Compare);
 if (itemIndex >= 0)
 {
-TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - placeholder modify, remove from placeholder queue");
+if( iGenerationQueue[itemIndex].iPlaceholder )
-iPlaceholderQueue.Remove( itemIndex );
+{
+TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - placeholder modify");
+iGenerationQueue[itemIndex].iPlaceholder = EFalse;
+}
+else
+{
+TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - real modify");
+iGenerationQueue[itemIndex].iItemAction = EGenerationItemActionModify;
+SetForceRun( ETrue );
+}
 }
 else
 {
-TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - real modify");
+TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - append");
-itemIndex = iAddQueue.FindInOrder(aIDArray[i], Compare);
+SetGenerationItemAction( item, aItemType);
+item.iPlaceholder = EFalse;
-if (itemIndex >= 0)
+AppendProcessingQueue( item );
-{
+}
-TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - remove from add queue");
+}
-iAddQueue.Remove( itemIndex );
+}
 }
-					else
+else if (aType == ENotifyRemove && aItemType == EGenerationItemTypeAny)
-						{
-						itemIndex = i2ndRoundGenerateQueue.FindInOrder(aIDArray[i], Compare);
-	                    if (itemIndex >= 0)
-	                        {
-	                        TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - remove from 2nd round add queue");
-	                        i2ndRoundGenerateQueue.Remove( itemIndex );
-	                        }
-					}
-TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - append to modify queue");
-User::LeaveIfError(iModifyQueue.InsertInOrder(aIDArray[i], Compare));
-SetForceRun( ETrue );
-}
-}
-}
-}
-else if (aType == ENotifyRemove)
 {
 TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - ENotifyRemove, remove IDs from all queues");
 for (int i=0; i<aIDArray.Count(); i++)
 {
-// can be removed from Add queue
+TThumbnailGenerationItem item;
-TInt itemIndex = iAddQueue.FindInOrder(aIDArray[i], Compare);
+item.iItemId = aIDArray[i];
+item.iItemType = aItemType;
+TInt itemIndex = iGenerationQueue.FindInOrder(item, Compare);
 if(itemIndex >= 0)
 {
-iAddQueue.Remove(itemIndex);
+iGenerationQueue[itemIndex].iItemAction = EGenerationItemActionDelete;
-}
+delete iGenerationQueue[itemIndex].iUri;
+iGenerationQueue[itemIndex].iUri = NULL;
-// ..and Modify Queue
-itemIndex = iModifyQueue.FindInOrder(aIDArray[i], Compare);
+if( aObjectUriArray[i])
-if(itemIndex >= 0)
+{
+iGenerationQueue[itemIndex].iUri = aObjectUriArray[i]->AllocL();
+}
+else
+{
+//invalid URI remove from processing queue
+iGenerationQueue.Remove(itemIndex);
+}
+}
+else
 {
-iModifyQueue.Remove(itemIndex);
+TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - append");
-}
+item.iItemAction = EGenerationItemActionDelete;
-}
+delete item.iUri;
+item.iUri = NULL;
-TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - ENotifyRemove append URIs to remove queue");
-for (int i=0; i<aObjectUriArray.Count(); i++)
+if( aObjectUriArray[i])
 {
-HBufC* temp = aObjectUriArray[i]->AllocL();
+item.iUri = aObjectUriArray[i]->AllocL();
-iRemoveQueue.Append( temp );
+CleanupStack::PushL( item.iUri );
-TN_DEBUG2( "CThumbAGProcessor::AddToQueueL() - %S", temp);
+User::LeaveIfError( iGenerationQueue.InsertInOrder(item, Compare) );
+CleanupStack::Pop();
+}
+//owned by item
+item.iUri = NULL;
+}
+TN_DEBUG2( "CThumbAGProcessor::AddToQueueL() - %S", aObjectUriArray[i]);
 }
 }
 #ifdef _DEBUG
 else
 {
 	        TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() -  should not come here" );
+	        __ASSERT_DEBUG((EFalse), User::Panic(_L("CThumbAGProcessor::AddToQueueL()"), KErrArgument));
 	        User::Leave( KErrArgument );
 }
 #endif
 ActivateAO();
 TInt orientationVal = 0;
 TInt64 modifiedVal = 0;
 CMdEProperty* orientation = NULL;
-CMdEObjectDef& imageObjectDef = iDefNamespace->GetObjectDefL( MdeConstants::Image::KImageObject );
-TInt orientErr = aObject->Property( imageObjectDef.GetPropertyDefL( MdeConstants::Image::KOrientationProperty ), orientation, 0 );
+TInt orientErr = aObject->Property( iImageObjectDef->GetPropertyDefL( MdeConstants::Image::KOrientationProperty ), orientation, 0 );
 if (orientErr == KErrNone)
 {
 orientationVal = orientation->Uint16ValueL();
 }
 if( i2ndRound )
 {
 //generate both if needed
 TN_DEBUG1( "CThumbAGProcessor::CreateThumbnailsL() EOptimizeForQuality ");
 iTMSession->SetQualityPreferenceL( CThumbnailManager::EOptimizeForQuality );
+TN_DEBUG2( "CThumbAGProcessor::CreateThumbnailsL() - 2nd round add remove from queue", aObject->Id() );
+TThumbnailGenerationItem item;
+item.iItemId = aObject->Id();
+TInt itemIndex = iGenerationQueue.FindInOrder(item, Compare);
+if(itemIndex >=0 )
+{
+if(iGenerationQueue[itemIndex].iItemAction == EGenerationItemAction2ndAdd)
+{
+iGenerationQueue.Remove(itemIndex);
+}
+}
 }
 		// 1st roung generation
 else
 {
 //1st round
 TN_DEBUG1( "CThumbAGProcessor::CreateThumbnailsL() EOptimizeForQualityWithPreview");
 iTMSession->SetQualityPreferenceL( CThumbnailManager::EOptimizeForQualityWithPreview );
-CMdEObjectDef& videoObjectDef = iDefNamespace->GetObjectDefL( MdeConstants::Video::KVideoObject );
 // add item to 2nd round queue
-if(iLastQueue == &iAddQueue || iLastQueue == &iModifyQueue)
+TN_DEBUG2( "CThumbAGProcessor::CreateThumbnailsL() - 1st round add/modify, append to 2nd round queue", aObject->Id() );
-{
-TN_DEBUG2( "CThumbAGProcessor::CreateThumbnailsL() - 1st round add/modify, append to 2nd round queue", aObject->Id() );
+TThumbnailGenerationItem item;
-if(i2ndRoundGenerateQueue.FindInOrder(aObject->Id(), Compare) == KErrNotFound)
+item.iItemId = aObject->Id();
+TInt itemIndex = iGenerationQueue.FindInOrder(item, Compare);
+if(itemIndex >=0 )
+{
+if(iGenerationQueue[itemIndex].iItemAction == EGenerationItemActionModify)
 {
-// ignore if fails
+iGenerationQueue.Remove(itemIndex);
-i2ndRoundGenerateQueue.InsertInOrder(aObject->Id(), Compare);
+}
-}
+//change 1st round item for 2nd round processing
-}
+//2nd round item can be deleted
+else if(iGenerationQueue[itemIndex].iItemAction == EGenerationItemActionAdd)
-		   // 10.1 specific
+{
-if( imageObjectDef.Id() != aObject->Def().Id()  )
+iGenerationQueue[itemIndex].iItemAction = EGenerationItemAction2ndAdd;
-{
+}
-TN_DEBUG1( "CThumbAGProcessor::CreateThumbnailsL() 1st round not image");
+else
-ActivateAO();
+{
-return;
+iGenerationQueue.Remove(itemIndex);
+}
 }
 }
 // run as lower priority than getting but higher that creating thumbnails
 TRAPD(err, iTMSession->UpdateThumbnailsL(KNoId, aObject->Uri(), orientationVal, modifiedVal, CActive::EPriorityIdle ));
 if ( err != KErrNone )
 {
 TN_DEBUG2( "CThumbAGProcessor::CreateThumbnailsL, iTMSession error == %d", err );
 iSessionDied = ETrue;
-iActive = EFalse;
 ActivateAO();
 }
 else
 {
 iActiveCount++;
-iActive = ETrue;
 }
 }
 else
 {
 ActivateAO();
 // ---------------------------------------------------------------------------
 // CThumbAGProcessor::QueryL()
 // ---------------------------------------------------------------------------
 //
-void CThumbAGProcessor::QueryL( RArray<TItemId>& aIDArray )
+void CThumbAGProcessor::QueryL(/*RArray<TItemId>& aIDArray*/TThumbnailGenerationItemAction aAction  )
 {
 TN_DEBUG1( "CThumbAGProcessor::QueryL() - begin" );
 __ASSERT_DEBUG((iMdESession), User::Panic(_L("CThumbAGProcessor::QueryL() !iMdeSession "), KErrBadHandle));
 __ASSERT_DEBUG((iDefNamespace), User::Panic(_L("CThumbAGProcessor::QueryL() !iDefNamespace "), KErrBadHandle));
-if(!iMdESession  || !iDefNamespace)
+if(!iMdESession  || !iDefNamespace || iShutdown)
 {
 return;
 }
 	//reset query queue
 iQueryQueue.Reset();
 	//set reference to current pprocessing queue
-iLastQueue = &aIDArray;
 iQueryReady = EFalse;
 // delete old query
 if (iQuery)
 delete iQuery;
 iQuery = NULL;
 }
 //move ID from source queue to Query queue
-TInt maxCount = aIDArray.Count();
+TInt maxCount = iGenerationQueue.Count();
-TN_DEBUG3( "CThumbAGProcessor::QueryL() - fill begin aIDArray == %d, iQueryQueue == %d", aIDArray.Count(), iQueryQueue.Count() );
+TN_DEBUG3( "CThumbAGProcessor::QueryL() - fill begin iGenerationQueue == %d, iQueryQueue == %d", iGenerationQueue.Count(), iQueryQueue.Count() );
-for(TInt i=0; i < KMaxQueryItems && i < maxCount; i++)
-{
+TInt itemCount(0);
-TN_DEBUG2( "CThumbAGProcessor::QueryL() - fill %d", aIDArray[0] );
+for(TInt i=0; itemCount < KMaxQueryItems && i < maxCount; i++)
-iQueryQueue.InsertInOrder(aIDArray[0], Compare);
+{
-aIDArray.Remove(0);
+TInt itemIndex(KErrNotFound);
-}
+switch(aAction)
+{
-TN_DEBUG3( "CThumbAGProcessor::QueryL() - fill end aIDArray == %d, iQueryQueue == %d", aIDArray.Count(), iQueryQueue.Count() );
+//1st round items
+case EGenerationItemActionAdd:
+if(iGenerationQueue[i].iItemAction == aAction )
+{
+itemIndex = i;
+}
+break;
+case EGenerationItemActionModify:
+if( iGenerationQueue[i].iItemAction == aAction )
+{
+itemIndex = i;
+}
+break;
+case EGenerationItemAction2ndAdd:
+if( iGenerationQueue[i].iItemAction == aAction )
+{
+itemIndex = i;
+}
+break;
+//unknown stuff
+case EGenerationItemActionResolveType:
+if( iGenerationQueue[i].iItemType == EGenerationItemTypeUnknown )
+{
+itemIndex = i;
+}
+break;
+default:
+break;
+};
+if( itemIndex >= 0 )
+{
+TN_DEBUG2( "CThumbAGProcessor::QueryL() - fill %d", iGenerationQueue[itemIndex].iItemId );
+iQueryQueue.InsertInOrder(iGenerationQueue[itemIndex].iItemId, CompareId);
+itemCount++;
+}
+}
+if(!itemCount)
+{
+TN_DEBUG1( "CThumbAGProcessor::QueryL() - empty query, cancel?!");
+iQueryActive = EFalse;
+__ASSERT_DEBUG((iMdESession), User::Panic(_L("CThumbAGProcessor::QueryL() empty! "), KErrNotFound));
+return;
+}
+TN_DEBUG3( "CThumbAGProcessor::QueryL() - fill end iGenerationQueue == %d, iQueryQueue == %d", iGenerationQueue.Count(), iQueryQueue.Count() );
 CMdEObjectDef& objDef = iDefNamespace->GetObjectDefL( MdeConstants::Object::KBaseObject );
 iQuery = iMdESession->NewObjectQueryL( *iDefNamespace, objDef, this );
 iQuery->SetResultMode( EQueryResultModeItem );
 CleanupClosePushL( iQueryQueue );
 rootCondition.AddObjectConditionL( iQueryQueue );
 CleanupStack::Pop( &iQueryQueue );
 // add object type conditions
-if (!iModify)
+if (!(iModify || iUnknown))
 {
 CMdELogicCondition& objDefCondition = rootCondition.AddLogicConditionL( ELogicConditionOperatorOr );
 if (iAutoImage)
 {
 // ---------------------------------------------------------------------------
 // CThumbAGProcessor::QueryForPlaceholders()
 // ---------------------------------------------------------------------------
 //
-void CThumbAGProcessor::QueryPlaceholdersL()
+void CThumbAGProcessor::QueryPlaceholdersL(TBool aPresent)
 {
 TN_DEBUG1( "CThumbAGProcessor::QueryPlaceholdersL" );
 __ASSERT_DEBUG((iMdESession), User::Panic(_L("CThumbAGProcessor::QueryPlaceholdersL() !iMdeSession "), KErrBadHandle));
 __ASSERT_DEBUG((iDefNamespace), User::Panic(_L("CThumbAGProcessor::QueryPlaceholdersL() !iDefNamespace "), KErrBadHandle));
-if(!iMdESession  || !iDefNamespace)
+if(!iMdESession  || !iDefNamespace || iShutdown)
 {
 return;
 }
 if( iQueryPlaceholders )
 CMdELogicCondition& rootCondition = iQueryPlaceholders->Conditions();
 rootCondition.SetOperator( ELogicConditionOperatorOr );
 CMdEObjectCondition& imagePHObjectCondition = rootCondition.AddObjectConditionL(imageObjDef);
 imagePHObjectCondition.SetPlaceholderOnly( ETrue );
-imagePHObjectCondition.SetNotPresent( ETrue );
+imagePHObjectCondition.SetNotPresent( aPresent );
 CMdEObjectCondition& videoPHObjectCondition = rootCondition.AddObjectConditionL(videoObjDef);
 videoPHObjectCondition.SetPlaceholderOnly( ETrue );
-videoPHObjectCondition.SetNotPresent( ETrue );
+videoPHObjectCondition.SetNotPresent( aPresent );
 CMdEObjectCondition& audioPHObjectCondition = rootCondition.AddObjectConditionL(audioObjDef);
 audioPHObjectCondition.SetPlaceholderOnly( ETrue );
-audioPHObjectCondition.SetNotPresent( ETrue );
+audioPHObjectCondition.SetNotPresent( aPresent );
-iQueryPlaceholders->FindL(KMaxTInt, KMaxQueryItems2);
+iQueryPlaceholders->FindL(KMaxTInt, KMaxQueryBatchSize);
 TN_DEBUG1( "CThumbAGProcessor::QueryPlaceholdersL - end" );
 }
 // ---------------------------------------------------------------------------
 //
 void CThumbAGProcessor::RunL()
 {
 TN_DEBUG1( "CThumbAGProcessor::RunL() - begin" );
+	if(iShutdown)
+		{
+TN_DEBUG1( "CThumbAGProcessor::RunL() - shutdown" );
+		return;
+		}
 if (iSessionDied)
 {
 TN_DEBUG1( "CThumbAGProcessor::RunL() - iSessionDied" );
 delete iTMSession;
 TN_DEBUG1( "CThumbAGProcessor::RunL() - Do Initialisation 1" );
 iInit = EFalse;
 iInit2 = ETrue;
-iAddQueue.Reset();
+iGenerationQueue.Reset();
-iModifyQueue.Reset();
-iRemoveQueue.ResetAndDestroy();
 iQueryQueue.Reset();
-iPlaceholderQueue.Reset();
+		//query all not present placeholders
-TRAP_IGNORE(QueryPlaceholdersL());
+TRAP_IGNORE(QueryPlaceholdersL( ETrue ));
 		//query all items after PH query
 iDoQueryAllItems = ETrue;
 TN_DEBUG1( "CThumbAGProcessor::RunL() - Initialisation 1 done" );
 ActivateAO();
 return;
 #ifdef  MDS_MODIFY_OBSERVER
 TN_DEBUG1( "CThumbAGProcessor::RunL() do iHarvesterClient connect");
 err = iHarvesterClient.Connect();
 TN_DEBUG2( "CThumbAGProcessor::RunL() iHarvesterClient connect err = %d", err);
-__ASSERT_DEBUG((err==KErrNone), User::Panic(_L("CThumbAGProcessor::RunL(), !iHarvesterClient "), err));
+__ASSERT_DEBUG((err == KErrNone), User::Panic(_L("CThumbAGProcessor::RunL(), !iHarvesterClient "), err));
 if(  err == KErrNone )
 {
 TN_DEBUG1( "CThumbAGProcessor::RunL() add iHarvesterClient observer");
-err = iHarvesterClient.AddHarvesterEventObserver( *this, EHEObserverTypeOverall | EHEObserverTypeMMC | EHEObserverTypePlaceholder, KMaxTInt );
+err = iHarvesterClient.AddHarvesterEventObserver( *this, EHEObserverTypeOverall | EHEObserverTypeMMC | EHEObserverTypePlaceholder, 20 );
 TN_DEBUG2( "CThumbAGProcessor::RunL() iHarvesterClient observer err = %d", err);
+if( !err )
+{
+TN_DEBUG1( "CThumbAGProcessor::RunL() add iHarvesterClient observer failed");
+// if we fail observer harvester, fake it
+iHarvesterActivated = ETrue;
+}
 __ASSERT_DEBUG((err==KErrNone), User::Panic(_L("CThumbAGProcessor::RunL(), !iHarvesterClient "), err));
 }
 #endif
 TN_DEBUG1( "CThumbAGProcessor::RunL() MMPXCollectionUtility");
 // restart session if died
 if (!iTMSession)
 {
 TN_DEBUG1( "CThumbAGProcessor::RunL() - open TNM session");
-iActive = EFalse;
 TRAPD( err, iTMSession = CThumbnailManager::NewL( *this ) );
 if (err != KErrNone)
 {
 iTMSession = NULL;
 ActivateAO();
 TN_DEBUG2( "CThumbAGProcessor::RunL() - Session restart failed, error == %d", err );
 }
 else
 {
+iTMSession->SetRequestObserver(*this);
 iSessionDied = EFalse;
 }
 }
 // do not run if request is already issued to TNM server even if forced
-if( iActive)
+if(iActiveCount >= KMaxDaemonRequests)
 {
-if(iActiveCount >= KMaxDaemonRequests)
+TN_DEBUG1( "CThumbAGProcessor::RunL() - waiting for previous to complete, abort..." );
-{
+return;
-TN_DEBUG1( "CThumbAGProcessor::RunL() - waiting for previous to complete, abort..." );
+}
-return;
-}
-}
-else
-{
-iActiveCount = 0;
-}
 //force run can proceed from this point
 #ifdef _DEBUG
 	if( iForegroundRun )
 		{
 //Handle completed MDS Query
 if( iQueryReady && iProcessingCount)
 {
 TInt err(KErrNone);
 //if force or non forced
-if((iForceRun && iModify ) || (!iForceRun && !iModify ))
+		//if unknown items or mount timer is active, abort processing
+if(((iForceRun && iModify ) || (!iForceRun && !iModify )) && !iUnknownItemCount && !iMountTimer->IsActive())
 {
 TN_DEBUG1( "CThumbAGProcessor::RunL() - iQueryReady START" );
 const CMdEObject* object = &iQuery->Result( iProcessingCount-1 );
 iProcessingCount--;
 if ( object )
 {
-TInt itemIndex = iLastQueue->FindInOrder(object->Id(), Compare);
-if(itemIndex >= 0)
-{
-iLastQueue->Remove(itemIndex);
-}
 //process one item at once
 //remove item from queryQueue when request is issued
-itemIndex = iQueryQueue.FindInOrder(object->Id(), Compare);
+TInt itemIndex = iQueryQueue.FindInOrder(object->Id(), CompareId);
 if(itemIndex >= 0)
 {
 iQueryQueue.Remove(itemIndex);
 }
-TRAP( err, CreateThumbnailsL(object) );
+TRAP( err, CreateThumbnailsL( object ) );
 TN_DEBUG2( "CThumbAGProcessor::RunL(), CreateThumbnailsL error == %d", err );
 __ASSERT_DEBUG((err==KErrNone), User::Panic(_L("CThumbAGProcessor::RunL(), CreateThumbnailsL() "), err));
 }
 }
 //force is coming, but executing non-forced query complete-> cancel old
 else
 {
-			//cancel query and move items back to original processing queue
+			//cancel query
+TN_DEBUG1( "CThumbAGProcessor::RunL() - cancel processing query" );
 DeleteAndCancelQuery( ETrue );
 	        ActivateAO();
 return;
 }
 }
 //waiting for MDS query to complete
 else if( iQueryActive )
 {
 		//state mismatch
-if(iForceRun && !iModify)
+if(iForceRun && !(iModify || iUnknown))
 {
 			//cancel query and move items back to original processing queue
 DeleteAndCancelQuery(ETrue);
 ActivateAO();
 }
 else
 {
 TN_DEBUG1( "CThumbAGProcessor::RunL() - waiting for query to complete, abort..." );
 }
 }
+else if ( iUnknownItemCount > 0 )
+{
+TN_DEBUG1( "void CThumbAGProcessor::RunL() unknown items in queue");
+i2ndRound = EFalse;
+iModify = EFalse;
+iUnknown = ETrue;
+iQueryActive = ETrue;
+QueryL( EGenerationItemActionResolveType );
+}
 // no items in query queue, start new
 // select queue to process, priority by type
-else if ( iModifyQueue.Count() > 0 )
+else if ( iModifyItemCount > 0 )
 {
 TN_DEBUG1( "void CThumbAGProcessor::RunL() update thumbnails");
 i2ndRound = EFalse;
 // query for object info
 iQueryActive = ETrue;
 iModify = ETrue;
-QueryL( iModifyQueue );
+iUnknown = EFalse;
+QueryL( EGenerationItemActionModify );
 }
-else if ( iAddQueue.Count() > 0 )
+else if ( iAddItemCount > 0 )
 {
 TN_DEBUG1( "void CThumbAGProcessor::RunL() update 1st round thumbnails");
 i2ndRound = EFalse;
+iUnknown = EFalse;
 // query for object info
 iQueryActive = ETrue;
-QueryL( iAddQueue );
+QueryL( EGenerationItemActionAdd );
 }
-else if ( iRemoveQueue.Count() > 0 )
+else if ( iDeleteItemCount > 0 )
 {
 TN_DEBUG1( "void CThumbAGProcessor::RunL() delete thumbnails");
 i2ndRound = EFalse;
+iUnknown = EFalse;
 // delete thumbs by URI
 __ASSERT_DEBUG((iTMSession), User::Panic(_L("CThumbAGProcessor::RunL() !iTMSession "), KErrBadHandle));
 if(iTMSession)
 {
-HBufC* uri = iRemoveQueue[0];
+TInt itemIndex(KErrNotFound);
-TN_DEBUG2( "void CThumbAGProcessor::RunL() delete %S",  uri);
-CThumbnailObjectSource* source = NULL;
+for(TInt i=0;i<iGenerationQueue.Count() || itemIndex == KErrNotFound;i++)
-TRAPD(err,  source = CThumbnailObjectSource::NewL( *uri, KNullDesC));
+{
+if(iGenerationQueue[i].iItemAction == EGenerationItemActionDelete)
-	if(err == KErrNone)
+{
-	{
+itemIndex = i;
-iTMSession->DeleteThumbnails( *source );
+}
 }
-iRemoveQueue.Remove( 0 );
-delete source;
+if(itemIndex >= 0)
-delete uri;
+{
-}
+if(!iGenerationQueue[itemIndex].iUri)
+{
-ActivateAO();
+//URI is invalid
-}
+TN_DEBUG1( "void CThumbAGProcessor::RunL() unable to delete URI inbalid");
-else if( i2ndRoundGenerateQueue.Count() > 0)
+iGenerationQueue.Remove( itemIndex );
+ActivateAO();
+return;
+}
+TN_DEBUG2( "void CThumbAGProcessor::RunL() delete %S",  iGenerationQueue[itemIndex].iUri);
+CThumbnailObjectSource* source = NULL;
+TRAPD(err,  source = CThumbnailObjectSource::NewL( *iGenerationQueue[itemIndex].iUri, KNullDesC));
+if(err == KErrNone)
+{
+iTMSession->DeleteThumbnails( *source );
+}
+delete source;
+delete iGenerationQueue[itemIndex].iUri;
+iGenerationQueue[itemIndex].iUri = NULL;
+iGenerationQueue.Remove( itemIndex );
+iActiveCount++;
+}
+}
+}
+else if( i2ndAddItemCount > 0)
 {
 TN_DEBUG1( "void CThumbAGProcessor::RunL() update 2nd round thumbnails");
 // query for object info
 iQueryActive = ETrue;
 i2ndRound = ETrue;
-QueryL( i2ndRoundGenerateQueue );
+iUnknown = EFalse;
+QueryL( EGenerationItemAction2ndAdd );
 }
 TN_DEBUG1( "CThumbAGProcessor::RunL() - end" );
 }
 // CThumbAGProcessor::DeleteAndCancelQuery()
 // ---------------------------------------------------------------------------
 //
 void CThumbAGProcessor::DeleteAndCancelQuery(TBool aRestoreItems)
 {
-TN_DEBUG1( "CThumbAGProcessor::DeleteAndCancelQuery() in" );
+TN_DEBUG2( "CThumbAGProcessor::DeleteAndCancelQuery(aRestoreItems = %d) in", aRestoreItems );
 if(iQuery)
 {
 TN_DEBUG1( "CThumbAGProcessor::DeleteAndCancelQuery() - deleting query" );
 iQuery->Cancel();
 iProcessingCount = 0;
 //move remainig IDs in query queue back to original queue
 while(iQueryQueue.Count())
 {
-if(aRestoreItems && iLastQueue)
+if(!aRestoreItems )
 {
-if(iLastQueue->FindInOrder(iQueryQueue[0], Compare) == KErrNotFound)
+TThumbnailGenerationItem item;
-{
+item.iItemId = iQueryQueue[0];
-//ignore if fails
+TInt itemIndex = iGenerationQueue.FindInOrder(item, Compare);
-iLastQueue->InsertInOrder(iQueryQueue[0], Compare);
+if(itemIndex >= 0)
+{
+delete iGenerationQueue[itemIndex].iUri;
+iGenerationQueue[itemIndex].iUri = NULL;
+iGenerationQueue.Remove(itemIndex);
 }
 }
 iQueryQueue.Remove(0);
 }
-iLastQueue = NULL;
 TN_DEBUG1( "CThumbAGProcessor::DeleteAndCancelQuery() out" );
 }
 // ---------------------------------------------------------------------------
 // CThumbAGProcessor::DoCancel()
 }
 void CThumbAGProcessor::HarvestingUpdated(
 HarvesterEventObserverType aHEObserverType,
 HarvesterEventState aHarvesterEventState,
-TInt /*aItemsLeft*/ )
+TInt aItemsLeft )
 {
-TN_DEBUG3( "CThumbAGProcessor::HarvestingUpdated -- start() aHEObserverType = %d, aHarvesterEventState = %d", aHEObserverType, aHarvesterEventState );
+TN_DEBUG4( "CThumbAGProcessor::HarvestingUpdated -- start() aHEObserverType = %d, aHarvesterEventState = %d, aItemsLeft = %d", aHEObserverType, aHarvesterEventState, aItemsLeft );
+	if(iShutdown)
+{
+return;
+}
+if(!iHarvesterActivated)
+{
+iHarvesterActivated = ETrue;
+}
 #ifdef _DEBUG
 if( aHEObserverType == EHEObserverTypePlaceholder)
 {
 TN_DEBUG1( "CThumbAGProcessor::HarvestingUpdated -- type EHEObserverTypePlaceholder");
 }
 else if( aHEObserverType == EHEObserverTypeOverall)
 {
 TN_DEBUG1( "CThumbAGProcessor::HarvestingUpdated -- type EHEObserverTypeOverall");
+}
+else if( aHEObserverType == EHEObserverTypeMMC)
+{
+TN_DEBUG1( "CThumbAGProcessor::HarvestingUpdated -- type EHEObserverTypeMMC");
 }
 #endif
 //placeholder harvesting
 if( aHEObserverType == EHEObserverTypePlaceholder)
 TN_DEBUG1( "CThumbAGProcessor::HarvestingUpdated -- MDS placeholder harvesterin started");
 }
 else
 {
 TN_DEBUG1( "CThumbAGProcessor::HarvestingUpdated -- MDS placeholder harvesting finished");
-TRAP_IGNORE(QueryPlaceholdersL());
+//query present placeholders
-}
+TRAP_IGNORE(QueryPlaceholdersL( EFalse ));
+iDoQueryAllItems = EFalse;
+iPHHarvestingItemsLeftTemp = 0;
+}
+}
+//restart mount timout if PH item count is increasing durin MMC harvesting
+if(iMMCHarvesting && iPHHarvesting && aItemsLeft > iPHHarvestingItemsLeftTemp)
+{
+//if items count increasing, restart mount timeout
+TN_DEBUG1( "CThumbAGProcessor::HarvestingUpdated -- PH count increasing, restart mount timeout");
+if(iMountTimer->IsActive())
+{
+iMountTimer->Cancel();
+}
+iMountTimer->Start( KMountTimeout, KMountTimeout, TCallBack(MountTimerCallBack, this));
+}
+//we are interestead of only PHs during MMC harvesting
+if( iMMCHarvesting )
+{
+iPHHarvestingItemsLeftTemp = aItemsLeft;
 }
 }
 //overall harvesting
 else if ( aHEObserverType == EHEObserverTypeOverall)
 {
 {
 iHarvesting = iHarvestingTemp;
 if( iHarvesting )
 {
-TN_DEBUG1( "CThumbAGProcessor::HarvestingUpdated -- MDS harvesterin started");
+TN_DEBUG1( "CThumbAGProcessor::HarvestingUpdated -- MDS harvesting started");
 CancelTimeout();
 }
 else
 {
 TN_DEBUG1( "CThumbAGProcessor::HarvestingUpdated -- MDS harvesting finished ");
 // continue processing if needed
 StartTimeout();
+if(iMountTimer->IsActive())
+{
+iMountTimer->Cancel();
+}
 }
 }
 }
 //MMC harvesting
 else if( aHEObserverType == EHEObserverTypeMMC)
 iMMCHarvesting = iMMCHarvestingTemp;
 if( iMMCHarvesting )
 {
 TN_DEBUG1( "CThumbAGProcessor::HarvestingUpdated -- MDS MMC harvesterin started");
-if(iPreviousItemsLeft != KErrNotReady)
+UpdatePSValues(EFalse, ETrue);
+iMMCHarvestingItemsLeftTemp = 0;
+}
+else
+{
+				//activate timeout if overall harvesting is not active
+if(!iHarvesting)
 {
-iPreviousItemsLeft = KErrNotReady;
+StartTimeout();
-RProperty::Set(KTAGDPSNotification, KDaemonProcessing, iPreviousItemsLeft);
+}
-}
-}
-else
-{
 TN_DEBUG1( "CThumbAGProcessor::HarvestingUpdated -- MDS MMC harvesting finished ");
 }
 }
+//restart mount timout if MMC item count is still increasing
+if(iMMCHarvesting && aItemsLeft > iMMCHarvestingItemsLeftTemp)
+{
+TN_DEBUG1( "CThumbAGProcessor::HarvestingUpdated -- MMC count increasing, restart mount timeout");
+if(iMountTimer->IsActive())
+{
+iMountTimer->Cancel();
+}
+iMountTimer->Start( KMountTimeout, KMountTimeout, TCallBack(MountTimerCallBack, this));
+}
+iMMCHarvestingItemsLeftTemp = aItemsLeft;
 }
 TN_DEBUG4( "CThumbAGProcessor::HarvestingUpdated -- end() iHarvesting == %d, iPHHarvesting == %d iMMCHarvesting == %d ", iHarvesting, iPHHarvesting, iMMCHarvesting);
 }
 void CThumbAGProcessor::StartTimeout()
 {
 TN_DEBUG1( "CThumbAGProcessor::StartTimeout()");
 CancelTimeout();
-if(!iHarvesting && !iMPXHarvesting && !iPeriodicTimer->IsActive())
+if(!iHarvesting && !iMPXHarvesting && !iPeriodicTimer->IsActive() && !iShutdown)
 {
 iPeriodicTimer->Start( KHarvestingCompleteTimeout, KHarvestingCompleteTimeout,
 TCallBack(PeriodicTimerCallBack, this));
 }
 }
 // CThumbAGProcessor::StopTimeout()
 // ---------------------------------------------------------------------------
 //
 void CThumbAGProcessor::CancelTimeout()
 {
+TN_DEBUG1( "CThumbAGProcessor::CancelTimeout()");
 if(iPeriodicTimer->IsActive())
 {
 iPeriodicTimer->Cancel();
 }
 }
 TInt CThumbAGProcessor::RunError(TInt /*aError*/)
 #endif
 {
 TN_DEBUG2( "CThumbAGrocessor::RunError() %d", aError);
-UpdatePSValues();
+UpdatePSValues(EFalse, EFalse);
 iActiveCount--;
-if(iActiveCount <= 0)
-{
-iActiveCount = 0;
-iActive = EFalse;
-}
 	ActivateAO();
 // nothing to do
 return KErrNone;
 // CThumbAGProcessor::ActivateAO()
 // ---------------------------------------------------------------------------
 //
 void CThumbAGProcessor::ActivateAO()
 {
-#ifdef _DEBUG
+UpdateItemCounts();
-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());
-TN_DEBUG2( "CThumbAGProcessor::ActivateAO() items in queue 2nd Add = %d", i2ndRoundGenerateQueue.Count());
-TN_DEBUG3( "CThumbAGProcessor::ActivateAO() iActive = %d, iActiveCount = %d", iActive, iActiveCount);
-TN_DEBUG3( "CThumbAGProcessor::ActivateAO() iHarvesting == %d, iMPXHarvesting == %d", iHarvesting, iMPXHarvesting);
-TN_DEBUG4( "CThumbAGProcessor::ActivateAO() iIdle = %d, timer = %d, iForceRun = %d", iIdle, iPeriodicTimer->IsActive(), iForceRun);
-TN_DEBUG4( "CThumbAGProcessor::ActivateAO() iModify = %d, iQueryReady = %d, iProcessingCount = %d", iModify, iQueryReady, iProcessingCount);
-#endif
 if(iFormatting)
 {
 TN_DEBUG1( "CThumbAGProcessor::ActivateAO() - FORMATTING - DAEMON ON PAUSE");
 return;
 }
 //check if forced run needs to continue
-if (iModifyQueue.Count())
+if ( iModifyItemCount || iUnknownItemCount > 0 )
 {
 SetForceRun( ETrue );
 }
 else
 {
 iModify = EFalse;
 SetForceRun( EFalse );
 }
-if( !IsActive() && ((!iActive && !iQueryActive) || iForceRun ))
+if( !IsActive() && !iShutdown && ((iActiveCount == 0 && !iQueryActive) || iForceRun ))
 {
 TN_DEBUG1( "CThumbAGProcessor::ActivateAO() - Activated");
 SetActive();
 TRequestStatus* statusPtr = &iStatus;
 User::RequestComplete( statusPtr, KErrNone );
 }
-UpdatePSValues();
+UpdatePSValues(EFalse, EFalse);
 }
 // ---------------------------------------------------------------------------
 // CThumbAGProcessor::PeriodicTimerCallBack()
 // ---------------------------------------------------------------------------
 void CThumbAGProcessor::RemoveFromQueues( const RArray<TItemId>& aIDArray, const TBool /*aRemoveFromDelete*/ )
 #endif
 {
 TN_DEBUG2( "CThumbAGProcessor::RemoveFromQueues() aRemoveFromDelete == %d - begin", aRemoveFromDelete );
-TInt itemIndex = KErrNotFound;
+TInt itemIndex(KErrNotFound);
 for (int i=0; i< aIDArray.Count(); i++)
 {
+TThumbnailGenerationItem item;
+item.iItemId = aIDArray[i];
 TN_DEBUG2( "CThumbAGProcessor::RemoveFromQueues() - %d", aIDArray[i]);
-itemIndex = iPlaceholderQueue.FindInOrder(aIDArray[i], Compare);
+itemIndex = iGenerationQueue.FindInOrder(item, Compare);
 if(itemIndex >= 0)
 {
-iPlaceholderQueue.Remove(itemIndex);
+delete iGenerationQueue[itemIndex].iUri;
-TN_DEBUG1( "CThumbAGProcessor::RemoveFromQueues() - iPlaceholderQueue" );
+iGenerationQueue[itemIndex].iUri = NULL;
+iGenerationQueue.Remove(itemIndex);
+TN_DEBUG1( "CThumbAGProcessor::RemoveFromQueues() - iGenerationQueue" );
 }
-itemIndex = iAddQueue.FindInOrder(aIDArray[i], Compare);
+itemIndex = iQueryQueue.FindInOrder(aIDArray[i], CompareId);
-if(itemIndex >= 0)
-{
-iAddQueue.Remove(itemIndex);
-TN_DEBUG1( "CThumbAGProcessor::RemoveFromQueues() - iAddQueue" );
-}
-itemIndex = i2ndRoundGenerateQueue.FindInOrder(aIDArray[i], Compare);
-if(itemIndex >= 0)
-{
-i2ndRoundGenerateQueue.Remove(itemIndex);
-TN_DEBUG1( "CThumbAGProcessor::RemoveFromQueues() - i2ndRoundGenerateQueue" );
-}
-itemIndex = iModifyQueue.FindInOrder(aIDArray[i], Compare);
-if(itemIndex >= 0)
-{
-iModifyQueue.Remove(itemIndex);
-TN_DEBUG1( "CThumbAGProcessor::RemoveFromQueues() - iModifyQueue" );
-if( iModifyQueue.Count() == 0)
-			    {
-			    SetForceRun( EFalse );
-		        }
-}
-itemIndex = iQueryQueue.FindInOrder(aIDArray[i], Compare);
 if(itemIndex >= 0)
 {
 iQueryQueue.Remove(itemIndex);
 TN_DEBUG1( "CThumbAGProcessor::RemoveFromQueues() - iQueryQueue" );
 }
+}
-itemIndex = iPlaceholderQueue.FindInOrder(aIDArray[i], Compare);
-if(itemIndex >= 0)
+ActivateAO();
-	{
-iPlaceholderQueue.Remove(itemIndex);
-TN_DEBUG1( "CThumbAGProcessor::RemoveFromQueues() - iPlaceholderQueue" );
-}
-}
 TN_DEBUG1( "CThumbAGProcessor::RemoveFromQueues() - end" );
 }
 // ---------------------------------------------------------------------------
 iQueryAllItems->SetResultMode( EQueryResultModeItem );
 CMdELogicCondition& rootCondition = iQueryAllItems->Conditions();
 rootCondition.SetOperator( ELogicConditionOperatorOr );
-CMdEObjectCondition& imagePHObjectCondition = rootCondition.AddObjectConditionL(imageObjDef);
+CMdEObjectCondition& imageObjectCondition = rootCondition.AddObjectConditionL(imageObjDef);
-CMdEObjectCondition& videoPHObjectCondition = rootCondition.AddObjectConditionL(videoObjDef);
+CMdEObjectCondition& videoObjectCondition = rootCondition.AddObjectConditionL(videoObjDef);
-CMdEObjectCondition& audioPHObjectCondition = rootCondition.AddObjectConditionL(audioObjDef);
+CMdEObjectCondition& audioObjectCondition = rootCondition.AddObjectConditionL(audioObjDef);
-iQueryAllItems->FindL(KMaxTInt, KMaxQueryItems2);
+iQueryAllItems->FindL(KMaxTInt, KMaxQueryBatchSize);
 TN_DEBUG1( "CThumbAGProcessor::QueryAllItemsL - end" );
 }
 // -----------------------------------------------------------------------------
 // Handle collection message.
 // -----------------------------------------------------------------------------
 //
 void CThumbAGProcessor::HandleCollectionMessage( CMPXMessage* aMessage, TInt aError )
 {
-if ( aError != KErrNone || !aMessage )
+if ( aError != KErrNone || !aMessage || iShutdown )
 {
 return;
 }
 TMPXMessageId generalId( *aMessage->Value<TMPXMessageId>( KMPXMessageGeneralId ) );
 }
 else
 {
 iIdle = ETrue;
-if(iAddQueue.Count() + iModifyQueue.Count() + iRemoveQueue.Count() + i2ndRoundGenerateQueue.Count() > 0 )
+if(iGenerationQueue.Count() > 0 )
 {
 ActivateAO();
 }
 }
 }
 // ---------------------------------------------------------------------------
 // CThumbAGProcessor::UpdateItemsLeft
 // Update KItemsleft PS value if changed
 // ---------------------------------------------------------------------------
 //
-void CThumbAGProcessor::UpdatePSValues(const TBool aDefine)
+void CThumbAGProcessor::UpdatePSValues(const TBool aDefine, const TBool aForce)
 {
-TInt itemsLeft = iModifyQueue.Count() + iAddQueue.Count();
+TInt itemsLeft(KErrNotReady);
-TBool daemonProcessing = EFalse;
+TBool daemonProcessing = ETrue;
-if(itemsLeft + i2ndRoundGenerateQueue.Count() + iRemoveQueue.Count() > 0 )
+if(iShutdown)
 {
-daemonProcessing = ETrue;
+RProperty::Set(KTAGDPSNotification, KDaemonProcessing, EFalse);
-}
+RProperty::Set(KTAGDPSNotification, KItemsleft, 0 );
+return;
-//adjust items left to containing also items not yet processed but removed from queue under processing
+}
-if((iLastQueue == &iModifyQueue || iLastQueue == &iAddQueue) && !i2ndRound)
-{
-itemsLeft +=iQueryQueue.Count();
-}
-//cancel 2nd round generarion when there is items in 1st round queues
-if(itemsLeft && i2ndRound)
-{
-DeleteAndCancelQuery(ETrue);
-i2ndRound = EFalse;
-}
-TN_DEBUG2( "CThumbAGProcessor::UpdatePSValues() KItemsleft == %d", itemsLeft);
 if(aDefine)
 {
-TN_DEBUG1( "CThumbAGProcessor::UpdatePSValues() define");
+TInt ret = RProperty::Define(KTAGDPSNotification, KDaemonProcessing, RProperty::EInt);
-RProperty::Define(KTAGDPSNotification, KDaemonProcessing, RProperty::EInt);
-RProperty::Set(KTAGDPSNotification, KDaemonProcessing, 0);
+if( ret != KErrNone )
-daemonProcessing = EFalse;
+{
-RProperty::Define(KTAGDPSNotification, KItemsleft, RProperty::EInt);
+TN_DEBUG2( "CThumbAGProcessor::UpdatePSValues() define KDaemonProcessing ret = %d", ret);
-RProperty::Set(KTAGDPSNotification, KItemsleft, 0);
+}
-iPreviousItemsLeft = 0;
-}
+ret = RProperty::Define(KTAGDPSNotification, KItemsleft, RProperty::EInt);
-if( daemonProcessing != iPreviousDaemonProcessing)
+if( ret != KErrNone )
 {
-TN_DEBUG2( "CThumbAGProcessor::UpdatePSValues() update KDaemonProcessing == %d", daemonProcessing);
+TN_DEBUG2( "CThumbAGProcessor::UpdatePSValues() define KItemsleft ret = %d", ret);
-iPreviousDaemonProcessing = daemonProcessing;
+}
-RProperty::Set(KTAGDPSNotification, KDaemonProcessing, daemonProcessing);
+}
-}
+// set itemsleft = KErrNotReady (-18) and daemonProcessing = ETrue if
-if( itemsLeft != iPreviousItemsLeft)
+// - key is initalized
-{
+// - mount timer is pending
-TN_DEBUG2( "CThumbAGProcessor::UpdatePSValues() update KItemsleft == %d", itemsLeft);
+// - harvester observer is not yet activated
-iPreviousItemsLeft = itemsLeft;
+// - single unknown item exists in processing queue
-RProperty::Set(KTAGDPSNotification, KItemsleft, itemsLeft );
+// - forced
-}
+if( iMountTimer->IsActive() || aForce || aDefine  || iUnknownItemCount
+|| !iHarvesterActivated  )
+{
+daemonProcessing = ETrue;
+itemsLeft = KErrNotReady;
+}
+else
+{
+itemsLeft = iAddItemCount + iModifyItemCount;
+}
+TN_DEBUG2( "CThumbAGProcessor::UpdatePSValues() KItemsleft == %d", itemsLeft);
+//cancel 2nd round generarion when there is items in 1st round queues
+if(iAddItemCount && i2ndRound)
+{
+DeleteAndCancelQuery(ETrue);
+i2ndRound = EFalse;
+}
+if( iGenerationQueue.Count() )
+{
+daemonProcessing = ETrue;
+}
+else
+{
+daemonProcessing = EFalse;
+}
+if( daemonProcessing != iPreviousDaemonProcessing)
+{
+TN_DEBUG2( "CThumbAGProcessor::UpdatePSValues() update KDaemonProcessing == %d", daemonProcessing);
+iPreviousDaemonProcessing = daemonProcessing;
+TInt ret = RProperty::Set(KTAGDPSNotification, KDaemonProcessing, daemonProcessing);
+if(ret != KErrNone )
+{
+TN_DEBUG3( "CThumbAGProcessor::UpdatePSValues() set KDaemonProcessing %d failed %d", daemonProcessing, ret);
+}
+}
+if( itemsLeft != iPreviousItemsLeft)
+{
+TN_DEBUG2( "CThumbAGProcessor::UpdatePSValues() update KItemsleft == %d", itemsLeft);
+iPreviousItemsLeft = itemsLeft;
+TInt ret = RProperty::Set(KTAGDPSNotification, KItemsleft, itemsLeft );
+if(ret != KErrNone )
+{
+TN_DEBUG3( "CThumbAGProcessor::UpdatePSValues() set KItemsleft %d failed %d", itemsLeft, ret);
+}
+}
 }
 // ---------------------------------------------------------------------------
 // CThumbAGProcessor::Compare
 // Comparison function for logaritmic use of queue arrays
 // ---------------------------------------------------------------------------
 //
-TInt CThumbAGProcessor::Compare(const TItemId& aLeft, const TItemId& aRight)
+TInt CThumbAGProcessor::Compare(const TThumbnailGenerationItem& aLeft, const TThumbnailGenerationItem& aRight)
+{
+return (aLeft.iItemId - aRight.iItemId);
+}
+TInt CThumbAGProcessor::CompareId(const TItemId& aLeft, const TItemId& aRight)
 {
 return (aLeft - aRight);
 }
+void CThumbAGProcessor::UpdateItemCounts()
+{
+TN_DEBUG1( "CThumbAGProcessor::UpdateItemCounts()");
+iModifyItemCount = 0;
+iDeleteItemCount = 0;
+iAddItemCount = 0;
+iUnknownItemCount = 0;
+i2ndAddItemCount = 0;
+iPlaceholderItemCount=0;
+iCameraItemCount =0;
+iImageItemCount=0;
+iVideoItemCount=0;
+iAudioItemCount=0;
+for(TInt i=0; i < iGenerationQueue.Count(); i++)
+{
+TThumbnailGenerationItem& item = iGenerationQueue[i];
+if(item.iItemAction == EGenerationItemActionModify)
+{
+iModifyItemCount++;
+}
+if(item.iItemAction == EGenerationItemActionDelete)
+{
+iDeleteItemCount++;
+}
+if(item.iItemType == EGenerationItemTypeUnknown)
+{
+iUnknownItemCount++;
+}
+if(item.iItemAction == EGenerationItemAction2ndAdd)
+{
+i2ndAddItemCount++;
+}
+if(item.iPlaceholder)
+{
+iPlaceholderItemCount++;
+}
+if(item.iItemType == EGenerationItemTypeCamera)
+{
+iCameraItemCount++;
+}
+if(item.iItemAction == EGenerationItemActionAdd )
+{
+iAddItemCount++;
+}
+if(item.iItemType == EGenerationItemTypeAudio)
+{
+iAudioItemCount++;
+}
+if(item.iItemType == EGenerationItemTypeVideo)
+{
+iVideoItemCount++;
+}
+if(item.iItemType == EGenerationItemTypeImage)
+{
+iImageItemCount++;
+}
+}
+TN_DEBUG2( "CThumbAGProcessor::UpdateItemCounts() iActiveCount = %d",
+iActiveCount);
+TN_DEBUG2( "CThumbAGProcessor::UpdateItemCounts() iPreviousItemsLeft = %d",
+iPreviousItemsLeft);
+TN_DEBUG5( "CThumbAGProcessor::UpdateItemCounts() iHarvesting == %d, iMMCHarvesting == %d, iPHHarvesting == %d, iMPXHarvesting == %d",
+iHarvesting, iMMCHarvesting, iPHHarvesting, iMPXHarvesting);
+TN_DEBUG5( "CThumbAGProcessor::UpdateItemCounts() iIdle = %d, iForegroundRun = %d, timer = %d, iForceRun = %d",
+iIdle, iForegroundRun, iPeriodicTimer->IsActive(), iForceRun);
+TN_DEBUG4( "CThumbAGProcessor::UpdateItemCounts() iModify = %d, iQueryReady = %d, iProcessingCount = %d",
+iModify, iQueryReady, iProcessingCount);
+TN_DEBUG2( "CThumbAGProcessor::UpdateItemCounts() iMountTimer = %d", iMountTimer->IsActive());
+TN_DEBUG3( "CThumbAGProcessor::UpdateItemCounts() iGenerationQueue = %d, iQueryQueue = %d",
+iGenerationQueue.Count(), iQueryQueue.Count());
+TN_DEBUG5( "CThumbAGProcessor::UpdateItemCounts() iAddItemCount=%d, i2ndAddItemCount=%d, iModifyItemCount=%d, iDeleteItemCount=%d",
+iAddItemCount, i2ndAddItemCount, iModifyItemCount, iDeleteItemCount );
+TN_DEBUG3( "CThumbAGProcessor::UpdateItemCounts() iUnknownItemCount=%d, iPlaceholderItemCount=%d",
+iUnknownItemCount, iPlaceholderItemCount);
+TN_DEBUG4( "CThumbAGProcessor::UpdateItemCounts() iAudioItemCount=%d, iVideoItemCount=%d, iImageItemCount=%d",
+iAudioItemCount, iVideoItemCount, iImageItemCount);
+TN_DEBUG2( "CThumbAGProcessor::UpdateItemCounts() iCameraItemCount=%d", iCameraItemCount);
+//compress queues when empty
+if(!iGenerationQueue.Count())
+{
+iGenerationQueue.Compress();
+}
+if(!iQueryQueue.Count())
+{
+iQueryQueue.Compress();
+}
+}
+// ---------------------------------------------------------------------------
+// CThumbAGProcessor::MountTimerCallBack()
+// ---------------------------------------------------------------------------
+//
+TInt CThumbAGProcessor::MountTimerCallBack(TAny* aAny)
+{
+TN_DEBUG1( "CThumbAGProcessor::MountTimerCallBack()");
+CThumbAGProcessor* self = static_cast<CThumbAGProcessor*>( aAny );
+self->iMountTimer->Cancel();
+//activate timeout if overall or mmc harvestig is not active
+if(!self->iHarvesting && !self->iMMCHarvesting )
+{
+self->ActivateAO();
+}
+return KErrNone; // Return value ignored by CPeriodic
+}
+// ---------------------------------------------------------------------------
+// CThumbAGProcessor::SetGenerationItemAction()
+// ---------------------------------------------------------------------------
+//
+void CThumbAGProcessor::SetGenerationItemAction( TThumbnailGenerationItem& aGenerationItem, TThumbnailGenerationItemType aItemType )
+{
+switch( aItemType )
+{
+case EGenerationItemTypeAudio:
+aGenerationItem.iItemAction = EGenerationItemAction2ndAdd;
+break;
+case EGenerationItemTypeCamera:
+aGenerationItem.iItemAction = EGenerationItemAction2ndAdd;
+aGenerationItem.iPlaceholder = ETrue;
+break;
+case EGenerationItemTypeImage:
+aGenerationItem.iItemAction = EGenerationItemActionAdd;
+break;
+case EGenerationItemTypeVideo:
+//S^3 EGenerationItemActionAdd
+//S^4 EGenerationItemAction2ndAdd
+aGenerationItem.iItemAction = EGenerationItemAction2ndAdd;
+break;
+default:
+aGenerationItem.iItemAction = EGenerationItemActionResolveType;
+}
+}
+// ---------------------------------------------------------------------------
+// CThumbAGProcessor::SetGenerationItemType()
+// ---------------------------------------------------------------------------
+//
+void CThumbAGProcessor::SetGenerationItemType( TThumbnailGenerationItem& aGenerationItem, const TDefId aDefId )
+{
+if(aDefId == iImageObjectDef->Id())
+{
+aGenerationItem.iItemType = EGenerationItemTypeImage;
+}
+else if(aDefId == iAudioObjectDef->Id())
+{
+aGenerationItem.iItemType = EGenerationItemTypeAudio;
+}
+else if(aDefId == iVideoObjectDef->Id())
+{
+aGenerationItem.iItemType = EGenerationItemTypeVideo;
+}
+else
+{
+aGenerationItem.iItemType = EGenerationItemTypeUnknown;
+}
+SetGenerationItemAction( aGenerationItem, aGenerationItem.iItemType );
+}
+// -----------------------------------------------------------------------------
+// CThumbAGProcessor::AppendProcessingQueue()
+// -----------------------------------------------------------------------------
+//
+void CThumbAGProcessor::AppendProcessingQueue( TThumbnailGenerationItem& item )
+{
+TInt itemIndex = iGenerationQueue.FindInOrder( item, Compare );
+if(itemIndex >= 0)
+{
+iGenerationQueue[itemIndex].iPlaceholder = item.iPlaceholder;
+iGenerationQueue[itemIndex].iItemType = item.iItemType;
+iGenerationQueue[itemIndex].iItemAction = item.iItemAction;
+}
+else
+{
+iGenerationQueue.InsertInOrder(item, Compare);
+}
+}
 // End of file

branch	GCC_SURGE
changeset 32	a0ee3f735f8b
parent 30	b67379558a75
child 31	d429f823a6b7
child 36	c5df59b4ae2d