--- a/imagehandlingutilities/thumbnailmanager/thumbagdaemon/src/thumbagprocessor.cpp Mon Jun 21 16:00:46 2010 +0300
+++ b/imagehandlingutilities/thumbnailmanager/thumbagdaemon/src/thumbagprocessor.cpp Thu Jul 15 18:59:26 2010 +0300
@@ -50,7 +50,8 @@
// CThumbAGProcessor::CThumbAGProcessor()
// ---------------------------------------------------------------------------
//
-CThumbAGProcessor::CThumbAGProcessor(): CActive( CActive::EPriorityStandard )
+CThumbAGProcessor::CThumbAGProcessor(): CActive( CActive::EPriorityStandard ), iMMCHarvestingItemsLeftTemp(0),
+ iPHHarvestingItemsLeftTemp(0)
{
TN_DEBUG1( "CThumbAGProcessor::CThumbAGProcessor() - begin" );
@@ -82,10 +83,11 @@
// 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 );
@@ -96,7 +98,7 @@
iActivityManager = CTMActivityManager::NewL( this, KBackgroundGenerationIdle);
- UpdatePSValues(ETrue);
+ UpdatePSValues(ETrue, ETrue);
RProperty::Define(KTAGDPSNotification, KMPXHarvesting, RProperty::EInt);
@@ -118,6 +120,20 @@
Cancel();
+ if (iTMSession)
+ {
+ iTMSession->RemoveRequestObserver();
+ delete iTMSession;
+ iTMSession = NULL;
+ }
+
+ if(iMountTimer)
+ {
+ iMountTimer->Cancel();
+ delete iMountTimer;
+ iMountTimer = NULL;
+ }
+
if(iPeriodicTimer)
{
iPeriodicTimer->Cancel();
@@ -177,21 +193,17 @@
iCollectionUtility->Close();
iCollectionUtility = NULL;
}
-
- iAddQueue.Close();
- iModifyQueue.Close();
- iRemoveQueue.ResetAndDestroy();
+
+ 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)
- {
- iTMSession->RemoveRequestObserver();
- delete iTMSession;
- iTMSession = NULL;
- }
TN_DEBUG1( "CThumbAGProcessor::~CThumbAGProcessor() - end" );
}
@@ -204,7 +216,7 @@
{
TN_DEBUG1( "CThumbAGProcessor::Shutdown()" );
iShutdown = ETrue;
- UpdatePSValues();
+ UpdatePSValues(EFalse, EFalse);
}
// -----------------------------------------------------------------------------
@@ -244,13 +256,19 @@
}
// 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);
@@ -259,13 +277,17 @@
{
continue;
}
-
- if (iAddQueue.FindInOrder(object->Id(), Compare) == KErrNotFound &&
- iModifyQueue.FindInOrder(object->Id(), Compare) == KErrNotFound )
- {
- // ignore if fails
- iAddQueue.InsertInOrder(object->Id(), Compare);
- }
+
+ TThumbnailGenerationItem item;
+ item.iItemId = object->Id();
+
+ SetGenerationItemType(item, object->Def().Id());
+
+ TInt itemIndex = iGenerationQueue.FindInOrder(item, Compare);
+
+ item.iPlaceholder = object->Placeholder();
+
+ AppendProcessingQueue( item );
}
}
}
@@ -292,8 +314,6 @@
{
TN_DEBUG1( "CThumbAGProcessor::HandleQueryCompleted - iQueryPlaceholders completed");
- iPlaceholderQueue.Reset();
-
//free query
delete iQueryPlaceholders;
iQueryPlaceholders = NULL;
@@ -331,60 +351,123 @@
{
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++)
- {
- TBool found(EFalse);
- for(TInt queryResult = 0; queryResult < iQuery->Count(); queryResult++)
- {
- const CMdEObject* object = &iQuery->Result(queryResult);
-
- if( iQueryQueue[queryItem] == object->Id())
+ //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++)
+ {
+ const CMdEObject* object = &iQuery->Result(queryResult);
+
+ 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;
- break;
+ TThumbnailGenerationItem& item = iGenerationQueue[itemIndex];
+
+ 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)
- {
- TN_DEBUG2( "CThumbAGProcessor::HandleQueryCompleted() missing from results item %d", iQueryQueue[queryItem] );
-
- // 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();
- }
+
+ iQueryQueue.Reset();
+ iProcessingCount = 0;
+ iUnknown = EFalse;
+ }
// no results, reset query
- if( !iProcessingCount)
+ if( !iProcessingCount )
{
delete iQuery;
iQuery = NULL;
- iProcessingCount = 0;
iModify = EFalse;
}
}
@@ -416,7 +499,7 @@
}
// -----------------------------------------------------------------------------
-// CThumbAGProcessor::ThumbnailReady()
+// CThumbAGProcessor::ThumbnailReady()d
// -----------------------------------------------------------------------------
//
void CThumbAGProcessor::ThumbnailReady( TInt aError, MThumbnailData& /*aThumbnail*/,
@@ -426,12 +509,6 @@
iActiveCount--;
- if(iActiveCount <= 0)
- {
- iActiveCount = 0;
- iActive = EFalse;
- }
-
// TNM server died, delete session
if( aError == KErrServerTerminated )
{
@@ -469,12 +546,6 @@
iActiveCount--;
- if(iActiveCount <= 0)
- {
- iActiveCount = 0;
- iActive = EFalse;
- }
-
ActivateAO();
}
}
@@ -483,7 +554,7 @@
// CThumbAGProcessor::SetMdESession()
// ---------------------------------------------------------------------------
//
-void CThumbAGProcessor::SetMdESession( CMdESession* aMdESession )
+void CThumbAGProcessor::SetMdESessionL( CMdESession* aMdESession )
{
TN_DEBUG1( "CThumbAGProcessor::SetMdESession() - begin" );
@@ -495,14 +566,22 @@
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));
-
- //do async init
- iInit = ETrue;
-
- ActivateAO();
+ else
+ {
+ iImageObjectDef = &iDefNamespace->GetObjectDefL( MdeConstants::Image::KImageObject );
+ __ASSERT_DEBUG((iImageObjectDef), User::Panic(_L("CThumbAGProcessor::SetMdESession() !iDefNamespace "), KErrBadHandle));
+ iVideoObjectDef = &iDefNamespace->GetObjectDefL( MdeConstants::Video::KVideoObject );
+ __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();
+ }
}
// ---------------------------------------------------------------------------
@@ -510,11 +589,13 @@
// ---------------------------------------------------------------------------
//
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)
@@ -523,12 +604,18 @@
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.FindInOrder(aIDArray[i], Compare) == KErrNotFound &&
- i2ndRoundGenerateQueue.FindInOrder(aIDArray[i], Compare) == KErrNotFound)
+ TThumbnailGenerationItem item;
+ item.iItemId = aIDArray[i];
+ item.iItemType = aItemType;
+
+ SetGenerationItemAction(item, aItemType);
+
+ if(iPHHarvesting)
{
- User::LeaveIfError(iAddQueue.InsertInOrder(aIDArray[i], Compare));
+ item.iPlaceholder = ETrue;
}
+
+ AppendProcessingQueue( item );
}
}
else if (aType == ENotifyModify)
@@ -540,19 +627,24 @@
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");
- iPlaceholderQueue.Remove( itemIndex );
+ TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - set as non-placeholder");
+ iGenerationQueue[itemIndex].iPlaceholder = EFalse;
}
-
- if(iAddQueue.FindInOrder(aIDArray[i], Compare) == KErrNotFound &&
- i2ndRoundGenerateQueue.FindInOrder(aIDArray[i], Compare) == KErrNotFound)
+ else
{
- TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - append to add queue");
- User::LeaveIfError(iAddQueue.InsertInOrder(aIDArray[i], Compare));
+ TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - append");
+
+ item.iPlaceholder = EFalse;
+ SetGenerationItemAction( item, aItemType );
+ AppendProcessingQueue( item );
}
}
}
@@ -564,75 +656,91 @@
for (int i=0; i<aIDArray.Count(); i++)
{
- itemIndex = iPlaceholderQueue.FindInOrder(aIDArray[i], Compare);
+ TThumbnailGenerationItem item;
+ item.iItemId = aIDArray[i];
+ item.iItemType = aItemType;
+
+ itemIndex = iGenerationQueue.FindInOrder(item, Compare);
if (itemIndex >= 0)
{
- TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - placeholder modify, remove from placeholder queue");
- iPlaceholderQueue.Remove( itemIndex );
+ if( iGenerationQueue[itemIndex].iPlaceholder )
+ {
+ 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");
- 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);
-
- 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 );
- }
+ TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - append");
+ SetGenerationItemAction( item, aItemType);
+ item.iPlaceholder = EFalse;
+ AppendProcessingQueue( item );
+ }
}
}
}
- else if (aType == ENotifyRemove)
+ else if (aType == ENotifyRemove && aItemType == EGenerationItemTypeAny)
{
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.FindInOrder(aIDArray[i], Compare);
- if(itemIndex >= 0)
- {
- iAddQueue.Remove(itemIndex);
- }
-
- // ..and Modify Queue
- itemIndex = iModifyQueue.FindInOrder(aIDArray[i], Compare);
+ TThumbnailGenerationItem item;
+ item.iItemId = aIDArray[i];
+ item.iItemType = aItemType;
+
+ TInt itemIndex = iGenerationQueue.FindInOrder(item, Compare);
+
if(itemIndex >= 0)
{
- iModifyQueue.Remove(itemIndex);
+ iGenerationQueue[itemIndex].iItemAction = EGenerationItemActionDelete;
+ delete iGenerationQueue[itemIndex].iUri;
+ iGenerationQueue[itemIndex].iUri = NULL;
+
+ if( aObjectUriArray[i])
+ {
+ iGenerationQueue[itemIndex].iUri = aObjectUriArray[i]->AllocL();
+ }
+ else
+ {
+ //invalid URI remove from processing queue
+ iGenerationQueue.Remove(itemIndex);
+ }
}
- }
-
- TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - ENotifyRemove append URIs to remove queue");
- for (int i=0; i<aObjectUriArray.Count(); i++)
- {
- HBufC* temp = aObjectUriArray[i]->AllocL();
- iRemoveQueue.Append( temp );
- TN_DEBUG2( "CThumbAGProcessor::AddToQueueL() - %S", temp);
+ else
+ {
+ TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - append");
+ item.iItemAction = EGenerationItemActionDelete;
+ delete item.iUri;
+ item.iUri = NULL;
+
+ if( aObjectUriArray[i])
+ {
+ item.iUri = aObjectUriArray[i]->AllocL();
+ CleanupStack::PushL( item.iUri );
+ 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
@@ -662,8 +770,8 @@
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)
{
@@ -688,6 +796,20 @@
//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
@@ -696,35 +818,29 @@
TN_DEBUG1( "CThumbAGProcessor::CreateThumbnailsL() EOptimizeForQualityWithPreview");
iTMSession->SetQualityPreferenceL( CThumbnailManager::EOptimizeForQualityWithPreview );
- CMdEObjectDef& videoObjectDef = iDefNamespace->GetObjectDefL( MdeConstants::Video::KVideoObject );
+ // add item to 2nd round queue
+ TN_DEBUG2( "CThumbAGProcessor::CreateThumbnailsL() - 1st round add/modify, append to 2nd round queue", aObject->Id() );
- // 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.FindInOrder(aObject->Id(), Compare) == KErrNotFound)
- {
- // ignore if fails
- i2ndRoundGenerateQueue.InsertInOrder(aObject->Id(), Compare);
- }
- }
+ TThumbnailGenerationItem item;
+ item.iItemId = aObject->Id();
+ TInt itemIndex = iGenerationQueue.FindInOrder(item, Compare);
- /*CMdEProperty* inDefaultFolder = NULL;
- TBool inDefaultFolderVal(ETrue);
- TInt inDefaultFolderErr = aObject->Property( baseObjDef.GetPropertyDefL( MdeConstants::Object::KInDefaultFolder ), inDefaultFolder, 0 );
-
- if(inDefaultFolder && inDefaultFolderErr >= 0 )
+ if(itemIndex >=0 )
{
- inDefaultFolderVal = inDefaultFolder->BoolValueL();
- }*/
-
- // Symbian^3 specific
- if( !(( imageObjectDef.Id() == aObject->Def().Id() || videoObjectDef.Id() == aObject->Def().Id())
- /*&& inDefaultFolderVal*/ ) )
- {
- TN_DEBUG1( "CThumbAGProcessor::CreateThumbnailsL() 1st round; not image or video in default folder, skip");
- ActivateAO();
- return;
+ if(iGenerationQueue[itemIndex].iItemAction == EGenerationItemActionModify)
+ {
+ iGenerationQueue.Remove(itemIndex);
+ }
+ //change 1st round item for 2nd round processing
+ //2nd round item can be deleted
+ else if(iGenerationQueue[itemIndex].iItemAction == EGenerationItemActionAdd)
+ {
+ iGenerationQueue[itemIndex].iItemAction = EGenerationItemAction2ndAdd;
+ }
+ else
+ {
+ iGenerationQueue.Remove(itemIndex);
+ }
}
}
@@ -736,13 +852,11 @@
TN_DEBUG2( "CThumbAGProcessor::CreateThumbnailsL, iTMSession error == %d", err );
iSessionDied = ETrue;
- iActive = EFalse;
ActivateAO();
}
else
{
iActiveCount++;
- iActive = ETrue;
}
}
else
@@ -757,7 +871,7 @@
// CThumbAGProcessor::QueryL()
// ---------------------------------------------------------------------------
//
-void CThumbAGProcessor::QueryL( RArray<TItemId>& aIDArray )
+void CThumbAGProcessor::QueryL(/*RArray<TItemId>& aIDArray*/TThumbnailGenerationItemAction aAction )
{
TN_DEBUG1( "CThumbAGProcessor::QueryL() - begin" );
@@ -772,7 +886,6 @@
//reset query queue
iQueryQueue.Reset();
//set reference to current pprocessing queue
- iLastQueue = &aIDArray;
iQueryReady = EFalse;
@@ -784,18 +897,64 @@
}
//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);
+ for(TInt i=0; itemCount < KMaxQueryItems && i < maxCount; i++)
{
- TN_DEBUG2( "CThumbAGProcessor::QueryL() - fill %d", aIDArray[0] );
- iQueryQueue.InsertInOrder(aIDArray[0], Compare);
- aIDArray.Remove(0);
+ TInt itemIndex(KErrNotFound);
+ switch(aAction)
+ {
+ //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++;
+ }
}
- TN_DEBUG3( "CThumbAGProcessor::QueryL() - fill end aIDArray == %d, iQueryQueue == %d", aIDArray.Count(), iQueryQueue.Count() );
+ 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 );
@@ -810,7 +969,7 @@
CleanupStack::Pop( &iQueryQueue );
// add object type conditions
- if (!iModify)
+ if (!(iModify || iUnknown))
{
CMdELogicCondition& objDefCondition = rootCondition.AddLogicConditionL( ELogicConditionOperatorOr );
@@ -842,7 +1001,7 @@
// ---------------------------------------------------------------------------
//
-void CThumbAGProcessor::QueryPlaceholdersL()
+void CThumbAGProcessor::QueryPlaceholdersL(TBool aPresent)
{
TN_DEBUG1( "CThumbAGProcessor::QueryPlaceholdersL" );
@@ -884,17 +1043,17 @@
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" );
}
@@ -928,13 +1087,11 @@
iInit = EFalse;
iInit2 = ETrue;
- iAddQueue.Reset();
- iModifyQueue.Reset();
- iRemoveQueue.ResetAndDestroy();
+ iGenerationQueue.Reset();
iQueryQueue.Reset();
- iPlaceholderQueue.Reset();
- TRAP_IGNORE(QueryPlaceholdersL());
+ //query all not present placeholders
+ TRAP_IGNORE(QueryPlaceholdersL( ETrue ));
//query all items after PH query
iDoQueryAllItems = ETrue;
TN_DEBUG1( "CThumbAGProcessor::RunL() - Initialisation 1 done" );
@@ -954,13 +1111,20 @@
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
@@ -984,7 +1148,6 @@
if (!iTMSession)
{
TN_DEBUG1( "CThumbAGProcessor::RunL() - open TNM session");
- iActive = EFalse;
TRAPD( err, iTMSession = CThumbnailManager::NewL( *this ) );
if (err != KErrNone)
@@ -1001,19 +1164,11 @@
}
// 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
@@ -1062,7 +1217,9 @@
{
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" );
@@ -1071,21 +1228,16 @@
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));
}
@@ -1093,7 +1245,8 @@
//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;
@@ -1113,7 +1266,7 @@
else if( iQueryActive )
{
//state mismatch
- if(iForceRun && !iModify)
+ if(iForceRun && !(iModify || iUnknown))
{
//cancel query and move items back to original processing queue
DeleteAndCancelQuery(ETrue);
@@ -1124,10 +1277,20 @@
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");
@@ -1136,54 +1299,77 @@
// 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];
- TN_DEBUG2( "void CThumbAGProcessor::RunL() delete %S", uri);
- CThumbnailObjectSource* source = NULL;
- TRAPD(err, source = CThumbnailObjectSource::NewL( *uri, KNullDesC));
-
- if(err == KErrNone)
- {
- iTMSession->DeleteThumbnails( *source );
+ TInt itemIndex(KErrNotFound);
+
+ for(TInt i=0;i<iGenerationQueue.Count() || itemIndex == KErrNotFound;i++)
+ {
+ if(iGenerationQueue[i].iItemAction == EGenerationItemActionDelete)
+ {
+ itemIndex = i;
+ }
}
- iRemoveQueue.Remove( 0 );
- delete source;
- delete uri;
-
- iActiveCount++;
- iActive = ETrue;
+
+ if(itemIndex >= 0)
+ {
+ if(!iGenerationQueue[itemIndex].iUri)
+ {
+ //URI is invalid
+ TN_DEBUG1( "void CThumbAGProcessor::RunL() unable to delete URI inbalid");
+ 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( i2ndRoundGenerateQueue.Count() > 0)
+ 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" );
@@ -1212,18 +1398,22 @@
//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];
+ TInt itemIndex = iGenerationQueue.FindInOrder(item, Compare);
+
+ if(itemIndex >= 0)
{
- //ignore if fails
- iLastQueue->InsertInOrder(iQueryQueue[0], Compare);
+ delete iGenerationQueue[itemIndex].iUri;
+ iGenerationQueue[itemIndex].iUri = NULL;
+ iGenerationQueue.Remove(itemIndex);
}
}
iQueryQueue.Remove(0);
}
- iLastQueue = NULL;
-
+
TN_DEBUG1( "CThumbAGProcessor::DeleteAndCancelQuery() out" );
}
@@ -1239,15 +1429,20 @@
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)
+ if(iShutdown)
{
return;
}
+ if(!iHarvesterActivated)
+ {
+ iHarvesterActivated = ETrue;
+ }
+
#ifdef _DEBUG
if( aHEObserverType == EHEObserverTypePlaceholder)
{
@@ -1257,6 +1452,10 @@
{
TN_DEBUG1( "CThumbAGProcessor::HarvestingUpdated -- type EHEObserverTypeOverall");
}
+ else if( aHEObserverType == EHEObserverTypeMMC)
+ {
+ TN_DEBUG1( "CThumbAGProcessor::HarvestingUpdated -- type EHEObserverTypeMMC");
+ }
#endif
//placeholder harvesting
@@ -1291,9 +1490,32 @@
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)
@@ -1322,7 +1544,7 @@
if( iHarvesting )
{
- TN_DEBUG1( "CThumbAGProcessor::HarvestingUpdated -- MDS harvesterin started");
+ TN_DEBUG1( "CThumbAGProcessor::HarvestingUpdated -- MDS harvesting started");
CancelTimeout();
}
else
@@ -1330,6 +1552,11 @@
TN_DEBUG1( "CThumbAGProcessor::HarvestingUpdated -- MDS harvesting finished ");
// continue processing if needed
StartTimeout();
+
+ if(iMountTimer->IsActive())
+ {
+ iMountTimer->Cancel();
+ }
}
}
}
@@ -1361,17 +1588,34 @@
if( iMMCHarvesting )
{
TN_DEBUG1( "CThumbAGProcessor::HarvestingUpdated -- MDS MMC harvesterin started");
- if(iPreviousItemsLeft != KErrNotReady)
- {
- iPreviousItemsLeft = KErrNotReady;
- RProperty::Set(KTAGDPSNotification, KDaemonProcessing, iPreviousItemsLeft);
- }
+ UpdatePSValues(EFalse, ETrue);
+ iMMCHarvestingItemsLeftTemp = 0;
}
else
{
+ //activate timeout if overall harvesting is not active
+ if(!iHarvesting)
+ {
+ StartTimeout();
+ }
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);
@@ -1399,6 +1643,7 @@
//
void CThumbAGProcessor::CancelTimeout()
{
+ TN_DEBUG1( "CThumbAGProcessor::CancelTimeout()");
if(iPeriodicTimer->IsActive())
{
iPeriodicTimer->Cancel();
@@ -1417,16 +1662,10 @@
{
TN_DEBUG2( "CThumbAGrocessor::RunError() %d", aError);
- UpdatePSValues();
+ UpdatePSValues(EFalse, EFalse);
iActiveCount--;
- if(iActiveCount <= 0)
- {
- iActiveCount = 0;
- iActive = EFalse;
- }
-
ActivateAO();
// nothing to do
@@ -1439,23 +1678,16 @@
//
void CThumbAGProcessor::ActivateAO()
{
-#ifdef _DEBUG
- 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
+ UpdateItemCounts();
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 );
}
@@ -1465,7 +1697,7 @@
SetForceRun( EFalse );
}
- if( !IsActive() && !iShutdown && ((!iActive && !iQueryActive) || iForceRun ))
+ if( !IsActive() && !iShutdown && ((iActiveCount == 0 && !iQueryActive) || iForceRun ))
{
TN_DEBUG1( "CThumbAGProcessor::ActivateAO() - Activated");
SetActive();
@@ -1473,7 +1705,7 @@
User::RequestComplete( statusPtr, KErrNone );
}
- UpdatePSValues();
+ UpdatePSValues(EFalse, EFalse);
}
// ---------------------------------------------------------------------------
@@ -1562,60 +1794,33 @@
{
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);
- if(itemIndex >= 0)
- {
- iPlaceholderQueue.Remove(itemIndex);
- TN_DEBUG1( "CThumbAGProcessor::RemoveFromQueues() - iPlaceholderQueue" );
- }
-
- itemIndex = iAddQueue.FindInOrder(aIDArray[i], Compare);
+ itemIndex = iGenerationQueue.FindInOrder(item, Compare);
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" );
+ delete iGenerationQueue[itemIndex].iUri;
+ iGenerationQueue[itemIndex].iUri = NULL;
+ iGenerationQueue.Remove(itemIndex);
+ TN_DEBUG1( "CThumbAGProcessor::RemoveFromQueues() - iGenerationQueue" );
}
-
- 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);
+
+ itemIndex = iQueryQueue.FindInOrder(aIDArray[i], CompareId);
if(itemIndex >= 0)
{
iQueryQueue.Remove(itemIndex);
TN_DEBUG1( "CThumbAGProcessor::RemoveFromQueues() - iQueryQueue" );
}
-
- itemIndex = iPlaceholderQueue.FindInOrder(aIDArray[i], Compare);
- if(itemIndex >= 0)
- {
- iPlaceholderQueue.Remove(itemIndex);
- TN_DEBUG1( "CThumbAGProcessor::RemoveFromQueues() - iPlaceholderQueue" );
- }
}
+ ActivateAO();
+
TN_DEBUG1( "CThumbAGProcessor::RemoveFromQueues() - end" );
}
@@ -1674,13 +1879,13 @@
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" );
}
@@ -1795,8 +2000,7 @@
{
iIdle = ETrue;
- if(iAddQueue.Count() + iModifyQueue.Count() + iRemoveQueue.Count() +
- iQueryQueue.Count() + i2ndRoundGenerateQueue.Count() > 0 )
+ if(iGenerationQueue.Count() > 0 )
{
ActivateAO();
}
@@ -1848,10 +2052,10 @@
// 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();
- TBool daemonProcessing = EFalse;
+ TInt itemsLeft(KErrNotReady);
+ TBool daemonProcessing = ETrue;
if(iShutdown)
{
@@ -1859,51 +2063,83 @@
RProperty::Set(KTAGDPSNotification, KItemsleft, 0 );
return;
}
-
- if(itemsLeft + i2ndRoundGenerateQueue.Count() + iRemoveQueue.Count() > 0 )
- {
- daemonProcessing = ETrue;
- }
-
- //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");
- RProperty::Define(KTAGDPSNotification, KDaemonProcessing, RProperty::EInt);
- RProperty::Set(KTAGDPSNotification, KDaemonProcessing, 0);
- daemonProcessing = EFalse;
- RProperty::Define(KTAGDPSNotification, KItemsleft, RProperty::EInt);
- RProperty::Set(KTAGDPSNotification, KItemsleft, 0);
- iPreviousItemsLeft = 0;
+ TInt ret = RProperty::Define(KTAGDPSNotification, KDaemonProcessing, RProperty::EInt);
+
+ if( ret != KErrNone )
+ {
+ TN_DEBUG2( "CThumbAGProcessor::UpdatePSValues() define KDaemonProcessing ret = %d", ret);
+ }
+
+ ret = RProperty::Define(KTAGDPSNotification, KItemsleft, RProperty::EInt);
+
+ if( ret != KErrNone )
+ {
+ TN_DEBUG2( "CThumbAGProcessor::UpdatePSValues() define KItemsleft ret = %d", ret);
+ }
}
- if( daemonProcessing != iPreviousDaemonProcessing)
- {
- TN_DEBUG2( "CThumbAGProcessor::UpdatePSValues() update KDaemonProcessing == %d", daemonProcessing);
- iPreviousDaemonProcessing = daemonProcessing;
- RProperty::Set(KTAGDPSNotification, KDaemonProcessing, daemonProcessing);
- }
+ // set itemsleft = KErrNotReady (-18) and daemonProcessing = ETrue if
+ // - key is initalized
+ // - mount timer is pending
+ // - harvester observer is not yet activated
+ // - single unknown item exists in processing queue
+ // - 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( itemsLeft != iPreviousItemsLeft)
- {
- TN_DEBUG2( "CThumbAGProcessor::UpdatePSValues() update KItemsleft == %d", itemsLeft);
- iPreviousItemsLeft = itemsLeft;
- RProperty::Set(KTAGDPSNotification, KItemsleft, itemsLeft );
- }
+ 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);
+ }
+ }
+
}
// ---------------------------------------------------------------------------
@@ -1911,10 +2147,208 @@
// 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 = EGenerationItemActionAdd;
+ 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