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

equal deleted inserted replaced

-:dea39715fc05
+:ee674526fac5
 // -----------------------------------------------------------------------------
 // CThumbAGProcessor::HandleQueryNewResults()
 // -----------------------------------------------------------------------------
 //
-void CThumbAGProcessor::HandleQueryNewResults( CMdEQuery& /*aQuery*/,
+void CThumbAGProcessor::HandleQueryNewResults( CMdEQuery& aQuery,
-const TInt /*aFirstNewItemIndex*/,
+const TInt aFirstNewItemIndex,
-const TInt /*aNewItemCount*/ )
+const TInt aNewItemCount )
 {
-// No implementation required
+// PH & AllItems query results are handled here
-}
+if (aNewItemCount > 0)
+{
-// -----------------------------------------------------------------------------
+if(&aQuery == iQueryPlaceholders)
-// CThumbAGProcessor::HandleQueryCompleted()
+{
-// -----------------------------------------------------------------------------
+TN_DEBUG2( "CThumbAGProcessor::HandleQueryNewResults - iQueryPlaceholders, %d new", aNewItemCount);
-//
-void CThumbAGProcessor::HandleQueryCompleted( CMdEQuery& aQuery, const TInt aError )
+for(TInt i = aFirstNewItemIndex; i < iQueryPlaceholders->Count(); i++)
 {
-TN_DEBUG3( "CThumbAGProcessor::HandleQueryCompleted, aError == %d Count== %d", aError, aQuery.Count());
+const CMdEObject* object = &iQueryPlaceholders->Result(i);
-if(&aQuery == iQueryPlaceholders)
-{
-TN_DEBUG1( "CThumbAGProcessor::HandleQueryCompleted - iQueryPlaceholders completed");
-iPlaceholderQueue.Reset();
-// if no errors in query
-if (aError == KErrNone )
-{
-for(TInt i = 0; i < iQueryPlaceholders->Count(); i++)
-{
-const CMdEObject* object = &iQueryPlaceholders->Result(i);
 if(!object)
 {
 continue;
 }
 if(!object->Placeholder())
 {
-TN_DEBUG2( "CThumbAGProcessor::HandleQueryCompleted %d not placeholder", object->Id());
+TN_DEBUG2( "CThumbAGProcessor::HandleQueryNewResults %d not placeholder", object->Id());
 continue;
 }
-/*if (iPlaceholderQueue.Find( object->Id() ) == KErrNotFound)
+// ignore if fails
-{
+iPlaceholderQueue.InsertInOrder(object->Id(), Compare);
-TN_DEBUG2( "CThumbAGProcessor::HandleQueryCompleted %d added to placeholder queue", object->Id());*/
+}
-TRAP_IGNORE( iPlaceholderQueue.AppendL( object->Id() ));
+}
-//}
+else if(&aQuery == iQueryAllItems)
-}
+{
-}
+TN_DEBUG2( "CThumbAGProcessor::HandleQueryNewResults - QueryAllItems, %d new", aNewItemCount);
-delete iQueryPlaceholders;
-iQueryPlaceholders = NULL;
+for(TInt i = aFirstNewItemIndex; i < iQueryAllItems->Count(); i++)
-if(iDoQueryAllItems)
-{
-iDoQueryAllItems = EFalse;
-TRAP_IGNORE(QueryAllItemsL());
-}
-}
-else if(&aQuery == iQueryAllItems)
-{
-TN_DEBUG1( "CThumbAGProcessor::HandleQueryCompleted - QueryAllItems completed");
-// if no errors in query
-if (aError == KErrNone )
-{
-for(TInt i = 0; i < iQueryAllItems->Count(); i++)
 {
 const CMdEObject* object = &iQueryAllItems->Result(i);
 if(!object)
 {
 continue;
 }
-if (iAddQueue.Find( object->Id() ) == KErrNotFound && iModifyQueue.Find( object->Id()) == KErrNotFound  )
+if (iAddQueue.FindInOrder(object->Id(), Compare) == KErrNotFound &&
+iModifyQueue.FindInOrder(object->Id(), Compare) == KErrNotFound )
 {
-TRAP_IGNORE( iAddQueue.AppendL( object->Id() ));
+// ignore if fails
+iAddQueue.InsertInOrder(object->Id(), Compare);
 }
 }
+}
+}
+else
+{
+TN_DEBUG1( "CThumbAGProcessor::HandleQueryNewResults - error, no new items");
+}
+}
+// -----------------------------------------------------------------------------
+// CThumbAGProcessor::HandleQueryCompleted()
+// -----------------------------------------------------------------------------
+//
+void CThumbAGProcessor::HandleQueryCompleted( CMdEQuery& aQuery, const TInt aError )
+{
+TN_DEBUG3( "CThumbAGProcessor::HandleQueryCompleted, aError == %d Count== %d", aError, aQuery.Count());
+if(&aQuery == iQueryPlaceholders)
+{
+TN_DEBUG1( "CThumbAGProcessor::HandleQueryCompleted - iQueryPlaceholders completed");
+iPlaceholderQueue.Reset();
+//free query
+delete iQueryPlaceholders;
+iQueryPlaceholders = NULL;
+if(iDoQueryAllItems)
+{
+iDoQueryAllItems = EFalse;
+TRAP_IGNORE(QueryAllItemsL());
+}
+}
+else if(&aQuery == iQueryAllItems)
+{
+TN_DEBUG1( "CThumbAGProcessor::HandleQueryCompleted - QueryAllItems completed");
 #ifdef _DEBUG
 TN_DEBUG2( "CThumbAGProcessor::HandleQueryCompleted IN-COUNTERS---------- Amount: %d, Add",iQueryAllItems->Count());
 #endif
-}
 //free query
 delete iQueryAllItems;
 iQueryAllItems = NULL;
 }
 else if(&aQuery == iQuery )
 {
 TN_DEBUG1( "CThumbAGProcessor::HandleQueryCompleted - Query completed");
 if(iProcessingCount != iQueryQueue.Count())
 {
 TN_DEBUG1( "CThumbAGProcessor::HandleQueryCompleted() some result items missing");
-RArray<TItemId> iQueryQueueDelta;
+RArray<TItemId> queryQueueDelta;
 TInt itemIndex(KErrNotFound);
 //search delta items
 for(TInt queryItem =0; queryItem < iQueryQueue.Count();queryItem++)
 }
 if(!found)
 {
 TN_DEBUG2( "CThumbAGProcessor::HandleQueryCompleted() missing from results item %d", iQueryQueue[queryItem] );
-iQueryQueueDelta.Append( iQueryQueue[queryItem] );
+// ignore if fails
+queryQueueDelta.InsertInOrder(iQueryQueue[queryItem], Compare);
 }
 }
-TN_DEBUG2( "CThumbAGProcessor::HandleQueryCompleted() missing items total count %d", iQueryQueueDelta.Count());
+TN_DEBUG2( "CThumbAGProcessor::HandleQueryCompleted() missing items total count %d", queryQueueDelta.Count());
 //cleanup from previous queue it item is not found from MDS
-while(iQueryQueueDelta.Count())
+while(queryQueueDelta.Count())
 {
-itemIndex = iLastQueue->Find(iQueryQueueDelta[0]);
+itemIndex = iLastQueue->FindInOrder(queryQueueDelta[0], Compare);
 if(itemIndex >= 0)
 {
 TN_DEBUG2( "CThumbAGProcessor::HandleQueryCompleted() remove items %d", iQueryQueue[0]);
 iLastQueue->Remove( itemIndex );
 }
-iQueryQueueDelta.Remove(0);
+queryQueueDelta.Remove(0);
 }
-iQueryQueueDelta.Close();
+queryQueueDelta.Close();
 }
 // no results, reset query
 if( !iProcessingCount)
 {
 TInt itemIndex(KErrNotFound);
 //cleanup current queue
 while(iQueryQueue.Count())
 {
-itemIndex = iLastQueue->Find(iQueryQueue[0]);
+itemIndex = iLastQueue->FindInOrder(iQueryQueue[0], Compare);
 if(itemIndex >= 0)
 {
 iLastQueue->Remove( itemIndex );
 }
 iQueryQueue.Remove(0);
 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)
-if (iAddQueue.Find( aIDArray[i] ) == KErrNotFound && i2ndRoundGenerateQueue.Find( aIDArray[i] ) == KErrNotFound)
+if (iAddQueue.FindInOrder(aIDArray[i], Compare) == KErrNotFound &&
-{
+i2ndRoundGenerateQueue.FindInOrder(aIDArray[i], Compare) == KErrNotFound)
-iAddQueue.AppendL(aIDArray[i]);
+{
+User::LeaveIfError(iAddQueue.InsertInOrder(aIDArray[i], Compare));
 }
 }
 }
 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.Find( aIDArray[i] );
+TInt itemIndex = iPlaceholderQueue.FindInOrder(aIDArray[i], Compare);
 if (itemIndex >= 0)
 {
 TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - remove from placeholder queue");
 iPlaceholderQueue.Remove( itemIndex );
 }
-if(iAddQueue.Find( aIDArray[i]) == KErrNotFound && i2ndRoundGenerateQueue.Find( aIDArray[i]) == KErrNotFound )
+if(iAddQueue.FindInOrder(aIDArray[i], Compare) == KErrNotFound &&
+i2ndRoundGenerateQueue.FindInOrder(aIDArray[i], Compare) == KErrNotFound)
 {
 TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - append to add queue");
-iAddQueue.Append( aIDArray[i]);
+User::LeaveIfError(iAddQueue.InsertInOrder(aIDArray[i], Compare));
 }
 }
 }
 else
 {
 TInt itemIndex(KErrNotFound);
 for (int i=0; i<aIDArray.Count(); i++)
 {
-itemIndex = iPlaceholderQueue.Find( aIDArray[i] );
+itemIndex = iPlaceholderQueue.FindInOrder(aIDArray[i], Compare);
 if (itemIndex >= 0)
 {
 TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - placeholder modify, remove from placeholder queue");
 iPlaceholderQueue.Remove( itemIndex );
 }
 else
 {
 TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - real modify");
-itemIndex = iAddQueue.Find( aIDArray[i] );
+itemIndex = iAddQueue.FindInOrder(aIDArray[i], Compare);
 if (itemIndex >= 0)
 {
 TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - remove from add queue");
 iAddQueue.Remove( itemIndex );
 }
 					else
 						{
+						itemIndex = i2ndRoundGenerateQueue.FindInOrder(aIDArray[i], Compare);
-						itemIndex = i2ndRoundGenerateQueue.Find( aIDArray[i] );
 	                    if (itemIndex >= 0)
 	                        {
 	                        TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - remove from 2nd round add queue");
 	                        i2ndRoundGenerateQueue.Remove( itemIndex );
 	                        }
 					}
 TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - append to modify queue");
-iModifyQueue.AppendL(aIDArray[i]);
+User::LeaveIfError(iModifyQueue.InsertInOrder(aIDArray[i], Compare));
 SetForceRun( ETrue );
 }
 }
 }
 TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - ENotifyRemove, remove IDs from all queues");
 for (int i=0; i<aIDArray.Count(); i++)
 {
 // can be removed from Add queue
-TInt itemIndex = iAddQueue.Find( aIDArray[i] );
+TInt itemIndex = iAddQueue.FindInOrder(aIDArray[i], Compare);
 if(itemIndex >= 0)
 {
 iAddQueue.Remove(itemIndex);
 }
 // ..and Modify Queue
-itemIndex = iModifyQueue.Find( aIDArray[i] );
+itemIndex = iModifyQueue.FindInOrder(aIDArray[i], Compare);
 if(itemIndex >= 0)
 {
 iModifyQueue.Remove(itemIndex);
 }
 }
 // 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() );
-if(i2ndRoundGenerateQueue.Find(aObject->Id()) == KErrNotFound)
+if(i2ndRoundGenerateQueue.FindInOrder(aObject->Id(), Compare) == KErrNotFound)
 {
-i2ndRoundGenerateQueue.Append( aObject->Id() );
+// ignore if fails
+i2ndRoundGenerateQueue.InsertInOrder(aObject->Id(), Compare);
 }
 }
 if( !(imageObjectDef.Id() == aObject->Def().Id() || videoObjectDef.Id() == aObject->Def().Id()) )
 {
 //move ID from source queue to Query queue
 TInt maxCount = aIDArray.Count();
 TN_DEBUG3( "CThumbAGProcessor::QueryL() - fill begin aIDArray == %d, iQueryQueue == %d", aIDArray.Count(), iQueryQueue.Count() );
 for(TInt i=0;i < KMaxQueryItems && i < maxCount; i++)
 {
 TN_DEBUG2( "CThumbAGProcessor::QueryL() - fill %d", aIDArray[i] );
-iQueryQueue.Append( aIDArray[i] );
+iQueryQueue.InsertInOrder(aIDArray[i], Compare);
 }
 TN_DEBUG3( "CThumbAGProcessor::QueryL() - fill end aIDArray == %d, iQueryQueue == %d", aIDArray.Count(), iQueryQueue.Count() );
 CMdEObjectDef& objDef = iDefNamespace->GetObjectDefL( MdeConstants::Object::KBaseObject );
 CMdEObjectCondition& audioPHObjectCondition = rootCondition.AddObjectConditionL(audioObjDef);
 audioPHObjectCondition.SetPlaceholderOnly( ETrue );
 audioPHObjectCondition.SetNotPresent( ETrue );
-iQueryPlaceholders->FindL();
+iQueryPlaceholders->FindL(KMaxTInt, KMaxQueryItems2);
 TN_DEBUG1( "CThumbAGProcessor::QueryPlaceholdersL - end" );
 }
 TN_DEBUG1( "CThumbAGProcessor::RunL() - iQueryReady START" );
 const CMdEObject* object = &iQuery->Result( iProcessingCount-1 );
 iProcessingCount--;
-TInt itemIndex = iLastQueue->Find( object->Id());
+TInt itemIndex = iLastQueue->FindInOrder(object->Id(), Compare);
 if(itemIndex >= 0)
 {
 iLastQueue->Remove(itemIndex);
 }
 // process one item at once
 if ( object )
 {
 //remove item from queryQueue when request is issued
-itemIndex = iQueryQueue.Find( object->Id());
+itemIndex = iQueryQueue.FindInOrder(object->Id(), Compare);
 if(itemIndex >= 0)
 {
 iQueryQueue.Remove(itemIndex);
 }
 //move remainig IDs in query queue back to original queue
 while(iQueryQueue.Count())
 {
 if(iLastQueue)
 {
-if(iLastQueue->Find( iQueryQueue[0]) == KErrNotFound)
+if(iLastQueue->FindInOrder(iQueryQueue[0], Compare) == KErrNotFound)
 {
-iLastQueue->Append(iQueryQueue[0]);
+//ignore if fails
+iLastQueue->InsertInOrder(iQueryQueue[0], Compare);
 }
 }
 iQueryQueue.Remove(0);
 }
 iLastQueue = NULL;
 //move remainig IDs in query queue back to original queue
 while(iQueryQueue.Count())
 {
 if(iLastQueue)
 {
-if(iLastQueue->Find( iQueryQueue[0]) == KErrNotFound)
+if(iLastQueue->FindInOrder(iQueryQueue[0], Compare) == KErrNotFound)
 {
-iLastQueue->Append(iQueryQueue[0]);
+//ignore if fails
+iLastQueue->InsertInOrder(iQueryQueue[0], Compare);
 }
 }
 iQueryQueue.Remove(0);
 }
 iLastQueue = NULL;
 {
 TN_DEBUG1( "CThumbAGProcessor::ActivateAO() - FORMATTING - DAEMON ON PAUSE");
 return;
 }
-if( !IsActive() )
+//check if forced run needs to continue
-{
+if (iModifyQueue.Count())
+{
+SetForceRun( ETrue );
+}
+else
+{
+iModify = EFalse;
+SetForceRun( EFalse );
+}
+if( !IsActive() && ((!iActive && !iQueryActive) || iForceRun ))
+{
+TN_DEBUG1( "CThumbAGProcessor::ActivateAO() - Activated");
 SetActive();
 TRequestStatus* statusPtr = &iStatus;
 User::RequestComplete( statusPtr, KErrNone );
-}
-//check if forced run needs to continue
-if (iModifyQueue.Count())
-{
-SetForceRun( ETrue );
-}
-else
-{
-iModify = EFalse;
-SetForceRun( EFalse );
 }
 UpdatePSValues();
 }
 for (int i=0; i< aIDArray.Count(); i++)
 {
 TN_DEBUG2( "CThumbAGProcessor::RemoveFromQueues() - %d", aIDArray[i]);
-itemIndex = iPlaceholderQueue.Find( aIDArray[i] );
+itemIndex = iPlaceholderQueue.FindInOrder(aIDArray[i], Compare);
 if(itemIndex >= 0)
 {
 iPlaceholderQueue.Remove(itemIndex);
 TN_DEBUG1( "CThumbAGProcessor::RemoveFromQueues() - iPlaceholderQueue" );
 }
-itemIndex = iAddQueue.Find( aIDArray[i] );
+itemIndex = iAddQueue.FindInOrder(aIDArray[i], Compare);
 if(itemIndex >= 0)
 {
 iAddQueue.Remove(itemIndex);
 TN_DEBUG1( "CThumbAGProcessor::RemoveFromQueues() - iAddQueue" );
 }
-itemIndex = i2ndRoundGenerateQueue.Find( aIDArray[i] );
+itemIndex = i2ndRoundGenerateQueue.FindInOrder(aIDArray[i], Compare);
 if(itemIndex >= 0)
 {
 i2ndRoundGenerateQueue.Remove(itemIndex);
 TN_DEBUG1( "CThumbAGProcessor::RemoveFromQueues() - i2ndRoundGenerateQueue" );
 }
-itemIndex = iModifyQueue.Find( aIDArray[i] );
+itemIndex = iModifyQueue.FindInOrder(aIDArray[i], Compare);
 if(itemIndex >= 0)
 {
 iModifyQueue.Remove(itemIndex);
 TN_DEBUG1( "CThumbAGProcessor::RemoveFromQueues() - iModifyQueue" );
 			    {
 			    SetForceRun( EFalse );
 		        }
 }
-itemIndex = iQueryQueue.Find( aIDArray[i] );
+itemIndex = iQueryQueue.FindInOrder(aIDArray[i], Compare);
 if(itemIndex >= 0)
 {
 iQueryQueue.Remove(itemIndex);
 TN_DEBUG1( "CThumbAGProcessor::RemoveFromQueues() - iQueryQueue" );
 }
-itemIndex = iPlaceholderQueue.Find( aIDArray[i] );
+itemIndex = iPlaceholderQueue.FindInOrder(aIDArray[i], Compare);
 if(itemIndex >= 0)
 	{
 iPlaceholderQueue.Remove(itemIndex);
 TN_DEBUG1( "CThumbAGProcessor::RemoveFromQueues() - iPlaceholderQueue" );
 }
-/*
-if( aRemoveFromDelete )
-{
-itemIndex = iRemoveQueue.Find( aIDArray[i] );
-if(itemIndex >= 0)
-{
-iRemoveQueue.Remove(itemIndex);
-TN_DEBUG1( "CThumbAGProcessor::RemoveFromQueues() - iRemoveQueue" );
-continue;
-}
-}*/
 }
 TN_DEBUG1( "CThumbAGProcessor::RemoveFromQueues() - end" );
 }
 CMdEObjectCondition& videoPHObjectCondition = rootCondition.AddObjectConditionL(videoObjDef);
 CMdEObjectCondition& audioPHObjectCondition = rootCondition.AddObjectConditionL(audioObjDef);
-iQueryAllItems->FindL();
+iQueryAllItems->FindL(KMaxTInt, KMaxQueryItems2);
 TN_DEBUG1( "CThumbAGProcessor::QueryAllItemsL - end" );
 }
 // -----------------------------------------------------------------------------
 iPreviousItemsLeft = itemsLeft;
 RProperty::Set(KTAGDPSNotification, KItemsleft, itemsLeft );
 }
 }
+// ---------------------------------------------------------------------------
+// CThumbAGProcessor::Compare
+// Comparison function for logaritmic use of queue arrays
+// ---------------------------------------------------------------------------
+//
+TInt CThumbAGProcessor::Compare(const TItemId& aLeft, const TItemId& aRight)
+{
+return (aLeft - aRight);
+}
 // End of file

branch	RCL_3
changeset 10	ee674526fac5
parent 9	dea39715fc05
child 11	85a88bc05e45