diff -r 000000000000 -r 2014ca87e772 imagehandlingutilities/thumbnailmanager/thumbagdaemon/src/thumbagprocessor.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/imagehandlingutilities/thumbnailmanager/thumbagdaemon/src/thumbagprocessor.cpp Tue Jan 26 15:18:05 2010 +0200 @@ -0,0 +1,1334 @@ +/* +* Copyright (c) 2006-2007 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: Processor +* +*/ + + +#include + +#include +#include + +#include "thumbagprocessor.h" +#include "thumbnaillog.h" +#include "thumbnailmanagerconstants.h" +#include "thumbnailmanagerprivatecrkeys.h" +#include "thumbagformatobserver.h" +#include +#include +#include + +// --------------------------------------------------------------------------- +// CThumbAGProcessor::NewL() +// --------------------------------------------------------------------------- +// +CThumbAGProcessor* CThumbAGProcessor::NewL() + { + TN_DEBUG1( "CThumbAGProcessor::NewL() - begin" ); + + CThumbAGProcessor* self = new( ELeave )CThumbAGProcessor(); + CleanupStack::PushL( self ); + self->ConstructL(); + CleanupStack::Pop( self ); + return self; + } + +// --------------------------------------------------------------------------- +// CThumbAGProcessor::CThumbAGProcessor() +// --------------------------------------------------------------------------- +// +CThumbAGProcessor::CThumbAGProcessor(): CActive( CActive::EPriorityStandard ) + { + TN_DEBUG1( "CThumbAGProcessor::CThumbAGProcessor() - begin" ); + + CActiveScheduler::Add( this ); + } + +// --------------------------------------------------------------------------- +// CThumbAGProcessor::ConstructL() +// --------------------------------------------------------------------------- +// +void CThumbAGProcessor::ConstructL() + { + TN_DEBUG1( "CThumbAGProcessor::ConstructL() - begin" ); + +#ifdef _DEBUG + iAddCounter = 0; + iModCounter = 0; + iDelCounter = 0; +#endif + + iTMSession = CThumbnailManager::NewL( *this ); + + iQuery = NULL; + iQueryActive = EFalse; + iModify = EFalse; + iProcessingCount = 0; + + iActiveCount = 0; + + // set auto create values from cenrep + CheckAutoCreateValuesL(); + + iPeriodicTimer = CPeriodic::NewL(CActive::EPriorityIdle); + + //do some initializing async in RunL() + iInit = ETrue; + iForceRun = EFalse; + iActive = EFalse; + + iFormatObserver = CThumbAGFormatObserver::NewL( this ); + + iFormatting = EFalse; + iSessionDied = EFalse; + + iCollectionUtility = NULL; + + TN_DEBUG1( "CThumbAGProcessor::ConstructL() - end" ); + } + +// --------------------------------------------------------------------------- +// CThumbAGProcessor::~CThumbAGProcessor() +// --------------------------------------------------------------------------- +// +CThumbAGProcessor::~CThumbAGProcessor() + { + TN_DEBUG1( "CThumbAGProcessor::~CThumbAGProcessor() - begin" ); + + if(iPeriodicTimer) + { + iPeriodicTimer->Cancel(); + delete iPeriodicTimer; + } + + if (!iInit) + { + iHarvesterClient.RemoveHarvesterEventObserver(*this); + iHarvesterClient.Close(); + } + + if ( iCollectionUtility ) + { + iCollectionUtility->Close(); + iCollectionUtility = NULL; + } + + Cancel(); + + if (iQuery) + { + iQuery->Cancel(); + delete iQuery; + iQuery = NULL; + } + + if (iQueryForPlaceholders) + { + iQueryForPlaceholders->Cancel(); + delete iQueryForPlaceholders; + iQueryForPlaceholders = NULL; + } + + iAddQueue.Close(); + iModifyQueue.Close(); + iRemoveQueue.Close(); + iQueryQueue.Close(); + iPresentQueue.Close(); + iTempModifyQueue.Close(); + iTempAddQueue.Close(); + iPlaceholderIDs.Close(); + + if (iTMSession) + { + delete iTMSession; + iTMSession = NULL; + } + + delete iFormatObserver; + + TN_DEBUG1( "CThumbAGProcessor::~CThumbAGProcessor() - end" ); + } + +// ----------------------------------------------------------------------------- +// CThumbAGProcessor::HandleQueryNewResults() +// ----------------------------------------------------------------------------- +// +void CThumbAGProcessor::HandleQueryNewResults( CMdEQuery& /*aQuery*/, + const TInt /*aFirstNewItemIndex*/, + const TInt /*aNewItemCount*/ ) + { + // No implementation required + } + +// ----------------------------------------------------------------------------- +// CThumbAGProcessor::HandleQueryCompleted() +// ----------------------------------------------------------------------------- +// +void CThumbAGProcessor::HandleQueryCompleted( CMdEQuery& /*aQuery*/, const TInt aError ) + { + + if( iQueryForPlaceholdersActive && iQueryForPlaceholders) + { + TN_DEBUG3( "CThumbAGProcessor::HandleQueryCompletedv2, aError == %d Count== %d", aError, iQueryForPlaceholders->Count()); + + // if no errors in query + if (aError == KErrNone ) + { + + for(TInt i = 0; i < iQueryForPlaceholders->Count(); i++) + { + const CMdEObject* object = &iQueryForPlaceholders->Result(i); + + if(!object) + continue; + + if(!object->Placeholder()) + { + TN_DEBUG2( "CThumbAGProcessor::HandleQueryCompletedv2 %d not placeholder",object->Id()); + continue; + } + + if (iPlaceholderIDs.Find( object->Id() ) == KErrNotFound) + { + TRAP_IGNORE( iPlaceholderIDs.AppendL( object->Id() )); + } + } + + } + else + { + TN_DEBUG1( "CThumbAGProcessor::HandleQueryCompleted() FAILED!"); + } + + iQueryForPlaceholdersActive = EFalse; + } + + else if(iQueryActive) + { + TN_DEBUG3( "CThumbAGProcessor::HandleQueryCompleted, aError == %d Count== %d", aError, iQuery->Count()); + iQueryReady = ETrue; + iQueryActive = EFalse; + + // if no errors in query + if (aError == KErrNone && iQuery) + { + iProcessingCount = iQuery->Count(); + } + else + { + iProcessingCount = 0; + TN_DEBUG1( "CThumbAGProcessor::HandleQueryCompleted() FAILED!"); + } + } + else + { + TN_DEBUG1( "CThumbAGProcessor::HandleQueryCompleted() - NO QUERY ACTIVE"); + } + + ActivateAO(); + } + +// ----------------------------------------------------------------------------- +// CThumbAGProcessor::ThumbnailPreviewReady() +// ----------------------------------------------------------------------------- +// +void CThumbAGProcessor::ThumbnailPreviewReady( MThumbnailData& /*aThumbnail*/, + TThumbnailRequestId /*aId*/) + { + // No implementation required + } + +// ----------------------------------------------------------------------------- +// CThumbAGProcessor::ThumbnailReady() +// ----------------------------------------------------------------------------- +// +void CThumbAGProcessor::ThumbnailReady( TInt aError, MThumbnailData& /*aThumbnail*/, + TThumbnailRequestId /*aId*/ ) + { + TN_DEBUG2( "CThumbAGProcessor::ThumbnailReady() aError == %d", aError ); + + iActive = EFalse; + + // TNM server died, delete session + if( aError == KErrServerTerminated ) + { + TN_DEBUG1( "CThumbAGProcessor::ThumbnailReady() - **** THUMBNAIL SERVER DIED ****" ); + + iSessionDied = ETrue; + + if( !iTimerActive) + { + StartTimeout(); + } + + //reset PS idle so that RunL() can startup reopen TNM session and proceed + TInt ret = RProperty::Set(KServerIdle, KIdle, ETrue); + TN_DEBUG2( "CThumbAGProcessor::ThumbnailReady() set Idle ret = %d", ret ); + + return; + } + + ActivateAO(); + TN_DEBUG1( "CThumbAGProcessor::ThumbnailReady() - end" ); + } + +// --------------------------------------------------------------------------- +// CThumbAGProcessor::SetMdESession() +// --------------------------------------------------------------------------- +// +void CThumbAGProcessor::SetMdESession( CMdESession* aMdESession ) + { + TN_DEBUG1( "CThumbAGProcessor::SetMdESession() - begin" ); + + iMdESession = aMdESession; + + TRAPD( err, iDefNamespace = &iMdESession->GetDefaultNamespaceDefL() ); + if (err != KErrNone) + { + TN_DEBUG1( "CThumbAGProcessor::SetMdESession - Error: GetDefaultNamespaceDefL leave" ); + } + ActivateAO(); + } + +// --------------------------------------------------------------------------- +// CThumbAGProcessor::AddToQueue() +// --------------------------------------------------------------------------- +// +void CThumbAGProcessor::AddToQueueL( TObserverNotificationType aType, + const RArray& aIDArray, TBool aPresent ) + { + TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - begin" ); + + if(aPresent) + { + TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - Add to SetPresentQueue" ); + for (int i=0; i= 0 ) + { + TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - harvesting now ended for this placeholder - not Real ENotifyModify" ); + iPlaceholderIDs.Remove(itemIndex); + TN_DEBUG2( "CThumbAGProcessor::AddToQueueL() - placeholders left %d", iPlaceholderIDs.Count() ); + if (iAddQueue.Find( aIDArray[i] ) == KErrNotFound) + { + iAddQueue.AppendL(aIDArray[i]); + } + if (iTempModifyQueue.Find( aIDArray[i] ) == KErrNotFound) + { + iTempModifyQueue.AppendL( aIDArray[i] ); + } + } + else if ( iTempAddQueue.Find( aIDArray[i] ) == KErrNotFound) + { + TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - Real ENotifyModify, force run" ); + iModifyQueue.InsertL( aIDArray[i], 0 ); + + TInt itemIndex = iAddQueue.Find( aIDArray[i] ); + if(itemIndex >= 0) + { + iAddQueue.Remove(itemIndex); + } + itemIndex = iPresentQueue.Find( aIDArray[i] ); + if(itemIndex >= 0) + { + iPresentQueue.Remove(itemIndex); + } + SetForceRun( ETrue ); + } + else + { + if (iTempModifyQueue.Find( aIDArray[i] ) == KErrNotFound) + { + TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - harvesting now ended for this file - not Real ENotifyModify" ); + iTempModifyQueue.AppendL( aIDArray[i] ); + } + else + { + TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - harvesting ended allready for this file - Real ENotifyModify, force run" ); + iModifyQueue.InsertL( aIDArray[i], 0 ); + TInt itemIndex = iAddQueue.Find( aIDArray[i] ); + if(itemIndex >= 0) + { + iAddQueue.Remove(itemIndex); + } + itemIndex = iPresentQueue.Find( aIDArray[i] ); + if(itemIndex >= 0) + { + iPresentQueue.Remove(itemIndex); + } + SetForceRun( ETrue ); + } + } + } + } + else if (aType == ENotifyRemove) + { + TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - ENotifyRemove" ); + + for (int i=0; i= 0) + { + iAddQueue.Remove(itemIndex); + } + // ..and Present Queue + itemIndex = iPresentQueue.Find( aIDArray[i] ); + if(itemIndex >= 0) + { + iPresentQueue.Remove(itemIndex); + } + // ..and Modify Queue + itemIndex = iModifyQueue.Find( aIDArray[i] ); + if(itemIndex >= 0) + { + iModifyQueue.Remove(itemIndex); + } + } + } + else + { + // should not come here + TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - should not come here" ); + return; + } + + ActivateAO(); + + TN_DEBUG1( "CThumbAGProcessor::AddToQueueL() - end" ); + } + +// --------------------------------------------------------------------------- +// CThumbAGProcessor::CreateThumbnailsL() +// --------------------------------------------------------------------------- +// +void CThumbAGProcessor::CreateThumbnailsL( const CMdEObject* aObject ) + { + TN_DEBUG1( "CThumbAGProcessor::CreateThumbnailsL() - begin" ); + + if( iModify ) + { + TInt orientationVal = 0; + TInt64 modifiedVal = 0; + + CMdEProperty* orientation = NULL; + CMdEObjectDef& objDef = iDefNamespace->GetObjectDefL( MdeConstants::Image::KImageObject ); + TInt orientErr = aObject->Property( objDef.GetPropertyDefL( MdeConstants::Image::KOrientationProperty ), orientation, 0 ); + + if (orientErr == KErrNone) + { + orientationVal = orientation->Uint16ValueL(); + } + + CMdEProperty* modified = NULL; + CMdEObjectDef& objDef2 = iDefNamespace->GetObjectDefL( MdeConstants::Object::KBaseObject ); + TInt modifyErr = aObject->Property( objDef2.GetPropertyDefL( MdeConstants::Object::KLastModifiedDateProperty ), modified, 0 ); + + if (modifyErr >= 0) + { + modifiedVal = modified->TimeValueL().Int64(); + } + + // modify existing thumbs + if (iTMSession) + { + // run as lower priority than getting but higher that creating thumbnails + TRAPD(err, iTMSession->UpdateThumbnailsL(aObject->Id(), aObject->Uri(), orientationVal, modifiedVal, CActive::EPriorityIdle )); + + if ( err != KErrNone ) + { + TN_DEBUG2( "CThumbAGProcessor::UpdateThumbnailsL, iTMSession error == %d", err ); + + iSessionDied = ETrue; + iActive = EFalse; + ActivateAO(); + } + else + { + iActive = ETrue; + } + } + else + { + ActivateAO(); + } + +#ifdef _DEBUG + iModCounter++; +#endif + } + else + { + CThumbnailObjectSource* source = NULL; + CMdEProperty* mimeType = NULL; + CMdEObjectDef& objDef = iDefNamespace->GetObjectDefL( MdeConstants::Object::KBaseObject ); + TInt mime = aObject->Property( objDef.GetPropertyDefL( MdeConstants::Object::KItemTypeProperty ), mimeType, 0 ); + + // create new thumbs + if (mime != KErrNotFound) + { + source = CThumbnailObjectSource::NewLC(aObject->Uri(), aObject->Id(), mimeType->TextValueL()); + } + else + { + source = CThumbnailObjectSource::NewLC(aObject->Uri(), aObject->Id()); + } + + if (iTMSession) + { + // run as very low priority task + TInt id = iTMSession->CreateThumbnails(*source, CActive::EPriorityIdle ); + if ( id < 0 ) + { + TN_DEBUG2( "CThumbAGProcessor::CreateThumbnailsL, iTMSession error == %d", id ); + + iSessionDied = ETrue; + iActive = EFalse; + CleanupStack::PopAndDestroy( source ); + ActivateAO(); + } + else + { + iActive = ETrue; + CleanupStack::PopAndDestroy( source ); + } + + } + else + { + ActivateAO(); + } + +#ifdef _DEBUG + iAddCounter++; +#endif + } + +#ifdef _DEBUG + TN_DEBUG3( "CThumbAGProcessor::OUT-COUNTERS----------, Add = %d Modify = %d", + iAddCounter, iModCounter ); +#endif + + TN_DEBUG1( "CThumbAGProcessor::CreateThumbnailsL() - end" ); + } + +// --------------------------------------------------------------------------- +// CThumbAGProcessor::QueryL() +// --------------------------------------------------------------------------- +// +void CThumbAGProcessor::QueryL( RArray& aIDArray ) + { + TN_DEBUG1( "CThumbAGProcessor::QueryL() - begin" ); + + iQueryReady = EFalse; + + // delete old query + if (iQuery) + { + delete iQuery; + iQuery = NULL; + } + + //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[0] ); + iQueryQueue.Append( aIDArray[0] ); + aIDArray.Remove( 0 ); + } + + TN_DEBUG3( "CThumbAGProcessor::QueryL() - fill end aIDArray == %d, iQueryQueue == %d", aIDArray.Count(), iQueryQueue.Count() ); + + CMdEObjectDef& objDef = iDefNamespace->GetObjectDefL( MdeConstants::Object::KBaseObject ); + iQuery = iMdESession->NewObjectQueryL( *iDefNamespace, objDef, this ); + iQuery->SetResultMode( EQueryResultModeItem ); + + CMdELogicCondition& rootCondition = iQuery->Conditions(); + rootCondition.SetOperator( ELogicConditionOperatorAnd ); + + // add IDs + CleanupClosePushL( iQueryQueue ); + rootCondition.AddObjectConditionL( iQueryQueue ); + CleanupStack::Pop( &iQueryQueue ); + + // add object type conditions + if (!iModify) + { + CMdELogicCondition& objDefCondition = rootCondition.AddLogicConditionL( ELogicConditionOperatorOr ); + + if (iAutoImage) + { + CMdEObjectDef& imageDef = iDefNamespace->GetObjectDefL( MdeConstants::Image::KImageObject ); + objDefCondition.AddObjectConditionL( imageDef ); + } + if (iAutoVideo) + { + CMdEObjectDef& videoDef = iDefNamespace->GetObjectDefL( MdeConstants::Video::KVideoObject ); + objDefCondition.AddObjectConditionL( videoDef ); + } + if (iAutoAudio) + { + CMdEObjectDef& audioDef = iDefNamespace->GetObjectDefL( MdeConstants::Audio::KAudioObject ); + objDefCondition.AddObjectConditionL( audioDef ); + } + } + + iQuery->FindL(); + + iQueryQueue.Reset(); + + TN_DEBUG1( "CThumbAGProcessor::QueryL() - end" ); + } + +// --------------------------------------------------------------------------- +// CThumbAGProcessor::RunL() +// --------------------------------------------------------------------------- +// +void CThumbAGProcessor::RunL() + { + TN_DEBUG1( "CThumbAGProcessor::RunL() - begin" ); + + if (iSessionDied) + { + delete iTMSession; + iTMSession = NULL; + } + + if (iInit) + { + TN_DEBUG1( "CThumbAGProcessor::RunL() - Do Initialisation" ); + iInit = EFalse; + TN_DEBUG1( "iHarvesterClient"); + if( iHarvesterClient.Connect() == KErrNone ) + { + TN_DEBUG1( "iHarvesterClient connected"); + iHarvesterClient.AddHarvesterEventObserver( *this, EHEObserverTypeOverall, KMaxTInt ); + iHarvesterClient.AddHarvesterEventObserver( *this, EHEObserverTypePlaceholder, KMaxTInt ); + TN_DEBUG1( "iHarvesterClient AddHarvesterEventObserver added"); + } + + TN_DEBUG1( "create MMPXCollectionUtility"); + iCollectionUtility = MMPXCollectionUtility::NewL( this, KMcModeIsolated ); + TN_DEBUG1( "CThumbAGProcessor::RunL() - Initialisation done" ); + return; + } + + // 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; + TN_DEBUG2( "CThumbAGProcessor::RunL() - Session restart failed, error == %d", err ); + } + else { + iSessionDied = EFalse; + } + } + + // do not run if request is already issued to TNM server even if forced + if( iActive) + { + if(iActiveCount <= KMaxDaemonRequests) + { + iActiveCount++; + TN_DEBUG1( "CThumbAGProcessor::RunL() - waiting for previous to complete, abort..." ); + return; + } + else + { + TN_DEBUG1( "CThumbAGProcessor::RunL() - iActive jammed - resetted" ); + iActive = EFalse; + iActiveCount = 0; + } + } + else + { + iActiveCount = 0; + } + + //Iforce run can proceed from this point + if( !iForceRun ) + { + //check if harvesting or waiting timeout + if( iHarvesting || iTimerActive || iMPXHarvesting ) + { + TN_DEBUG1( "void CThumbAGProcessor::RunL() Harvester or timer active, abort"); + return; + } + else + { + //check is server idle + TInt idle(-1); + + TInt ret = RProperty::Get(KServerIdle, KIdle, idle); + + if(ret == KErrNone ) + { + if(!idle) + { + //start wait timer and retry on after callback + TN_DEBUG1( "CThumbAGProcessor::RunL() server not idle, wait... " ); + if( !iTimerActive) + { + StartTimeout(); + } + return; + } + } + else + { + TN_DEBUG2( "CThumbAGProcessor::RunL() get KServerIdle failed %d, continue...", ret ); + } + } + } + else + { + TN_DEBUG1( "void CThumbAGProcessor::RunL() forced run"); + } + + + //Handle completed MDS Query + if( iQueryReady && iProcessingCount) + { + TInt err(KErrNone); + if((iForceRun && iModify) || (!iForceRun && !iModify)) + { + TN_DEBUG1( "CThumbAGProcessor::RunL() - iQueryReady START" ); + + + const CMdEObject* object = &iQuery->Result( iProcessingCount-1 ); + iProcessingCount--; + + // process one item at once + if ( object ) + { + TRAP( err, CreateThumbnailsL(object) ); + + if ( err != KErrNone ) + { + TN_DEBUG2( "CThumbAGProcessor::RunL(), CreateThumbnailsL error == %d", err ); + } + } + } + else + { + TN_DEBUG1( "CThumbAGProcessor::RunL() - deleting query" ); + delete iQuery; + iQuery = NULL; + iQueryReady = EFalse; + iProcessingCount = 0; + ActivateAO(); + return; + } + + //is last query item + if( iProcessingCount <= 0 ) + { + TN_DEBUG1( "CThumbAGProcessor::RunL() - iQueryReady FINISH" ); + iQueryReady = EFalse; + iQueryActive = EFalse; + iModify = EFalse; + + //check if forced run needs to continue + if (iModifyQueue.Count()) + { + iForceRun = ETrue; + } + else + { + iForceRun = EFalse; + } + + } + //keep going if processing Remove items or if Add item fails + else if( iModify || err ) + { + ActivateAO(); + } + } + //waiting for MDS query to complete + else if( iQueryActive || iQueryForPlaceholdersActive ) + { + if(iForceRun && !iModify && iQueryActive) + { + iQuery->Cancel(); + delete iQuery; + iQuery = NULL; + TN_DEBUG1( "CThumbAGProcessor::RunL() - canceling query..." ); + iQueryReady = EFalse; + iQueryActive = EFalse; + ActivateAO(); + } + else + { + TN_DEBUG1( "CThumbAGProcessor::RunL() - waiting for query to complete, abort..." ); + } + } + + // select queue to process, priority by type. Process modify events before new images + else if ( iModifyQueue.Count() > 0 ) + { + TN_DEBUG1( "void CThumbAGProcessor::RunL() update thumbnails"); + + // query for object info + iQueryActive = ETrue; + iModify = ETrue; + QueryL( iModifyQueue ); + } + else if ( iRemoveQueue.Count() > 0 ) + { + TN_DEBUG1( "void CThumbAGProcessor::RunL() delete thumbnails"); + + // delete thumbs by ID + if (iTMSession) + { + iTMSession->DeleteThumbnails( iRemoveQueue[0] ); + } + iRemoveQueue.Remove( 0 ); + +#ifdef _DEBUG + iDelCounter++; + TN_DEBUG2( "CThumbAGProcessor::OUT-COUNTERS----------, Delete = %d", iDelCounter ); +#endif + ActivateAO(); + } + else if ( iAddQueue.Count() > 0 ) + { + TN_DEBUG1( "void CThumbAGProcessor::RunL() add thumbnails"); + + // query for object info + iQueryActive = ETrue; + + QueryL( iAddQueue ); + } + else if ( iPresentQueue.Count() > 0 ) + { + TN_DEBUG1( "void CThumbAGProcessor::RunL() add thumbnails for present thumbnails" ); + + // query for object info + iQueryActive = ETrue; + + QueryL( iPresentQueue ); + } + + TN_DEBUG1( "CThumbAGProcessor::RunL() - end" ); + } + +// --------------------------------------------------------------------------- +// CThumbAGProcessor::DoCancel() +// --------------------------------------------------------------------------- +// +void CThumbAGProcessor::DoCancel() + { + // No implementation required + } + +void CThumbAGProcessor::HarvestingUpdated( + HarvesterEventObserverType aHEObserverType, + HarvesterEventState aHarvesterEventState, + TInt /*aItemsLeft*/ ) + { + TN_DEBUG3( "CThumbAGProcessor::HarvestingUpdated -- start() aHEObserverType = %d, aHarvesterEventState = %d", aHEObserverType, aHarvesterEventState ); + + if( aHEObserverType == EHEObserverTypePlaceholder) + { + TRAP_IGNORE( QueryForPlaceholdersL() ); + return; + } + + if( aHEObserverType != EHEObserverTypeOverall) + { + return; + } + + switch(aHarvesterEventState) + { + case EHEStateStarted: + case EHEStateHarvesting: + case EHEStatePaused: + case EHEStateResumed: + { + iHarvestingTemp = ETrue; + break; + } + case EHEStateFinished: + case EHEStateUninitialized: + { + iHarvestingTemp = EFalse; + break; + } + }; + + if(iHarvestingTemp == iHarvesting) + { + TN_DEBUG2( "CThumbAGProcessor::HarvestingUpdated -- no change %d", iHarvesting); + } + else + { + iHarvesting = iHarvestingTemp; + + if( iHarvesting ) + { + TN_DEBUG1( "CThumbAGProcessor::HarvestingUpdated -- MDS harvesterin started"); + CancelTimeout(); + } + else + { + TN_DEBUG1( "CThumbAGProcessor::HarvestingUpdated -- MDS harvesting finished "); + // continue processing if needed + StartTimeout(); + + iTempModifyQueue.Reset(); + iTempAddQueue.Reset(); + iPlaceholderIDs.Reset(); + } + } + + TN_DEBUG3( "CThumbAGProcessor::HarvestingUpdated -- end() iHarvesting == %d, iMPXHarvesting == %d", iHarvesting, iMPXHarvesting); + } + +// --------------------------------------------------------------------------- +// CThumbAGProcessor::StartTimeout() +// --------------------------------------------------------------------------- +// +void CThumbAGProcessor::StartTimeout() + { + CancelTimeout(); + + if(!iHarvesting && !iMPXHarvesting && !iPeriodicTimer->IsActive()) + { + iPeriodicTimer->Start( KHarvestingCompleteTimeout, KHarvestingCompleteTimeout, + TCallBack(PeriodicTimerCallBack, this)); + iTimerActive = ETrue; + } + else + { + iTimerActive = EFalse; + } + } + +// --------------------------------------------------------------------------- +// CThumbAGProcessor::StopTimeout() +// --------------------------------------------------------------------------- +// +void CThumbAGProcessor::CancelTimeout() + { + if(iTimerActive) + { + iPeriodicTimer->Cancel(); + } + iTimerActive = EFalse; + } + +// --------------------------------------------------------------------------- +// CThumbAGProcessor::RunError() +// --------------------------------------------------------------------------- +// +TInt CThumbAGProcessor::RunError(TInt aError) + { + if (aError != KErrNone) + { + TN_DEBUG2( "CThumbAGProcessor::RunError = %d", aError ); + } + + iActive = EFalse; + + // nothing to do + return KErrNone; + } + +// --------------------------------------------------------------------------- +// CThumbAGProcessor::ActivateAO() +// --------------------------------------------------------------------------- +// +void CThumbAGProcessor::ActivateAO() + { + if(iFormatting) + { + TN_DEBUG1( "CThumbAGProcessor::ActivateAO() - FORMATTING - DAEMON ON PAUSE"); + return; + } + + if( !IsActive() && (!iHarvesting || iForceRun )) + { +#ifdef _DEBUG + if( iForceRun ) + { + TN_DEBUG1( "CThumbAGProcessor::ActivateAO() - *** FORCED RUN ***"); + } +#endif + SetActive(); + TRequestStatus* statusPtr = &iStatus; + User::RequestComplete( statusPtr, KErrNone ); + } + } + +// --------------------------------------------------------------------------- +// CThumbAGProcessor::PeriodicTimerCallBack() +// --------------------------------------------------------------------------- +// +TInt CThumbAGProcessor::PeriodicTimerCallBack(TAny* aAny) + { + TN_DEBUG1( "CThumbAGProcessor::PeriodicTimerCallBack()"); + CThumbAGProcessor* self = static_cast( aAny ); + + self->CancelTimeout(); + self->ActivateAO(); + + return KErrNone; // Return value ignored by CPeriodic + } + +// --------------------------------------------------------------------------- +// CThumbAGProcessor::CheckAutoCreateValuesL() +// --------------------------------------------------------------------------- +// +void CThumbAGProcessor::CheckAutoCreateValuesL() + { + CRepository* rep = CRepository::NewL( TUid::Uid( THUMBNAIL_CENREP_UID )); + + TBool imageGrid( EFalse ); + TBool imageList( EFalse ); + TBool imageFull( EFalse ); + TBool videoGrid( EFalse ); + TBool videoList( EFalse ); + TBool videoFull( EFalse ); + TBool audioGrid( EFalse ); + TBool audioList( EFalse ); + TBool audioFull( EFalse ); + + // get cenrep values + rep->Get( KAutoCreateImageGrid, imageGrid ); + rep->Get( KAutoCreateImageList, imageList ); + rep->Get( KAutoCreateImageFullscreen, imageFull ); + rep->Get( KAutoCreateVideoGrid, videoGrid ); + rep->Get( KAutoCreateVideoList, videoList ); + rep->Get( KAutoCreateVideoFullscreen, videoFull ); + rep->Get( KAutoCreateAudioGrid, audioGrid ); + rep->Get( KAutoCreateAudioList, audioList ); + rep->Get( KAutoCreateAudioFullscreen, audioFull ); + + iAutoImage = EFalse; + iAutoVideo = EFalse; + iAutoAudio = EFalse; + + // set processing values + if (imageGrid || imageList || imageFull) + { + iAutoImage = ETrue; + } + if (videoGrid || videoList || videoFull) + { + iAutoVideo = ETrue; + } + if (audioGrid || audioList || audioFull) + { + iAutoAudio = ETrue; + } + + delete rep; + } + +// --------------------------------------------------------------------------- +// CThumbAGProcessor::RemoveFromQueues() +// --------------------------------------------------------------------------- +// +void CThumbAGProcessor::RemoveFromQueues( const RArray& aIDArray, const TBool aRemoveFromDelete ) + { + TN_DEBUG2( "CThumbAGProcessor::RemoveFromQueues() aRemoveFromDelete == %d - begin", aRemoveFromDelete ); + + TInt itemIndex = KErrNotFound; + + for (int i=0; i< aIDArray.Count(); i++) + { + TN_DEBUG2( "CThumbAGProcessor::RemoveFromQueues() - %d", aIDArray[i]); + + itemIndex = iAddQueue.Find( aIDArray[i] ); + + if(itemIndex >= 0) + { + iAddQueue.Remove(itemIndex); + TN_DEBUG1( "CThumbAGProcessor::RemoveFromQueues() - iAddQueue" ); + continue; + } + + itemIndex = iPresentQueue.Find( aIDArray[i] ); + + if(itemIndex >= 0) + { + iPresentQueue.Remove(itemIndex); + TN_DEBUG1( "CThumbAGProcessor::RemoveFromQueues() - iPresentQueue" ); + continue; + } + + itemIndex = iModifyQueue.Find( aIDArray[i] ); + + if(itemIndex >= 0) + { + iModifyQueue.Remove(itemIndex); + TN_DEBUG1( "CThumbAGProcessor::RemoveFromQueues() - iModifyQueue" ); + + if( iModifyQueue.Count() == 0) + { + iForceRun = EFalse; + } + + continue; + } + + if( aRemoveFromDelete ) + { + itemIndex = iRemoveQueue.Find( aIDArray[i] ); + + if(itemIndex >= 0) + { + iRemoveQueue.Remove(itemIndex); + TN_DEBUG1( "CThumbAGProcessor::RemoveFromQueues() - iRemoveQueue" ); + continue; + } + } + } + + TN_DEBUG1( "CThumbAGProcessor::RemoveFromQueues() - end" ); + } + +// --------------------------------------------------------------------------- +// CThumbAGProcessor::SetForceRun() +// --------------------------------------------------------------------------- +// +void CThumbAGProcessor::SetForceRun( const TBool aForceRun) + { + TN_DEBUG2( "CThumbAGProcessor::SetForceRun(%d) - end", aForceRun ); + + // enable forced run + if (aForceRun) + { + iForceRun = aForceRun; + } + } + +// --------------------------------------------------------------------------- +// CThumbAGProcessor::SetFormat() +// --------------------------------------------------------------------------- +// + +void CThumbAGProcessor::SetFormat(TBool aStatus) + { + TN_DEBUG2( "CThumbAGProcessor::SetFormat(%d) - end", aStatus ); + + iFormatting = aStatus; + if(!aStatus) + { + ActivateAO(); + } + } + +// --------------------------------------------------------------------------- +// CThumbAGProcessor::QueryForPlaceholders() +// --------------------------------------------------------------------------- +// + +void CThumbAGProcessor::QueryForPlaceholdersL() + { + TN_DEBUG1( "CThumbAGProcessor::QueryForPlaceholders" ); + if(iQueryForPlaceholdersActive) + { + TN_DEBUG1( "CThumbAGProcessor::QueryForPlaceholders - skip" ); + return; + } + + TN_DEBUG1( "CThumbAGProcessor::QueryForPlaceholders - start" ); + + // delete old query + if (iQueryForPlaceholders) + { + iQueryForPlaceholdersActive = EFalse; + iQueryForPlaceholders->Cancel(); + delete iQueryForPlaceholders; + iQueryForPlaceholders = NULL; + } + + CMdEObjectDef& imageObjDef = iDefNamespace->GetObjectDefL( MdeConstants::Image::KImageObject ); + CMdEObjectDef& videoObjDef = iDefNamespace->GetObjectDefL( MdeConstants::Video::KVideoObject ); + CMdEObjectDef& audioObjDef = iDefNamespace->GetObjectDefL( MdeConstants::Audio::KAudioObject ); + + CMdEObjectDef& objDef = iDefNamespace->GetObjectDefL( MdeConstants::Object::KBaseObject); + iQueryForPlaceholders = iMdESession->NewObjectQueryL( *iDefNamespace, objDef, this ); + + iQueryForPlaceholders->SetResultMode( EQueryResultModeItem ); + + CMdELogicCondition& rootCondition = iQueryForPlaceholders->Conditions(); + rootCondition.SetOperator( ELogicConditionOperatorOr ); + + CMdEObjectCondition& imagePHObjectCondition = rootCondition.AddObjectConditionL(imageObjDef); + imagePHObjectCondition.SetPlaceholderOnly( ETrue ); + imagePHObjectCondition.SetNotPresent( ETrue ); + + CMdEObjectCondition& videoPHObjectCondition = rootCondition.AddObjectConditionL(videoObjDef); + videoPHObjectCondition.SetPlaceholderOnly( ETrue ); + videoPHObjectCondition.SetNotPresent( ETrue ); + + CMdEObjectCondition& audioPHObjectCondition = rootCondition.AddObjectConditionL(audioObjDef); + audioPHObjectCondition.SetPlaceholderOnly( ETrue ); + audioPHObjectCondition.SetNotPresent( ETrue ); + + iQueryForPlaceholders->FindL(); + + iQueryForPlaceholdersActive = ETrue; + + TN_DEBUG1( "CThumbAGProcessor::QueryForPlaceholders - end" ); + } + +// ----------------------------------------------------------------------------- +// CThumbAGProcessor::HandleCollectionMessage +// From MMPXCollectionObserver +// Handle collection message. +// ----------------------------------------------------------------------------- +// + +void CThumbAGProcessor::HandleCollectionMessage( CMPXMessage* aMessage, + TInt aError ) + { + if ( aError != KErrNone || !aMessage ) + { + return; + } + + TN_DEBUG1( "CThumbAGProcessor::HandleCollectionMessage" ); + + TMPXMessageId generalId( *aMessage->Value( KMPXMessageGeneralId ) ); + + //we are interestead of only general system events + if ( generalId == KMPXMessageGeneral ) + { + TInt event( *aMessage->Value( KMPXMessageGeneralEvent ) ); + if ( event == TMPXCollectionMessage::EBroadcastEvent ) + { + TInt op( *aMessage->Value( KMPXMessageGeneralType ) ); + + switch( op ) + { + //when MTP sync or music collection is started then pause processing + case EMcMsgRefreshStart: + case EMcMsgUSBMTPStart: + TN_DEBUG1("CThumbAGProcessor::HandleCollectionMessage MPX refresh started" ); + iMPXHarvesting = ETrue; + CancelTimeout(); + break; + //when MTP sync or music collection refresh is complete then resume processing + case EMcMsgRefreshEnd: + case EMcMsgUSBMTPEnd: + case EMcMsgUSBMTPNotActive: + TN_DEBUG1("CThumbAGProcessor::HandleCollectionMessage MPX refresh finished/not active" ); + iMPXHarvesting = EFalse; + StartTimeout(); + break; + default: + break; + } + TN_DEBUG3( "CThumbAGProcessor::HandleCollectionMessage -- end() iHarvesting == %d, iMPXHarvesting == %d", iHarvesting, iMPXHarvesting); + } + } + } +// ----------------------------------------------------------------------------- +// CThumbAGProcessor::HandleOpenL +// From MMPXCollectionObserver +// Handles the collection entries being opened. +// ----------------------------------------------------------------------------- +// +void CThumbAGProcessor::HandleOpenL( const CMPXMedia& /*aEntries*/, + TInt /*aIndex*/, + TBool /*aComplete*/, + TInt /*aError*/ ) + { + // not needed here + } + +// ----------------------------------------------------------------------------- +// CThumbAGProcessor::HandleOpenL +// From MMPXCollectionObserver +// Handles an item being opened. +// ----------------------------------------------------------------------------- +void CThumbAGProcessor::HandleOpenL( const CMPXCollectionPlaylist& /*aPlaylist*/, TInt /*aError*/ ) + { + // not needed here + } + +// ----------------------------------------------------------------------------- +// CThumbAGProcessor::HandleCollectionMediaL +// From MMPXCollectionObserver +// Handle media properties. +// ----------------------------------------------------------------------------- +// +void CThumbAGProcessor::HandleCollectionMediaL( const CMPXMedia& /*aMedia*/, + TInt /*aError*/ ) + { + // not needed here + } + +// End of file