FCL/sf/mw/mds: comparison harvester/server/src/harvesterao.cpp

equal deleted inserted replaced

-:9422ed56ee45
+:63c982fb92f2
 #include "mdeobjecthandler.h"
 #include "harvestereventmanager.h"
 #include "harvestercenreputil.h"
 #include "restorewatcher.h"
 #include "backupsubscriber.h"
+#include "OstTraceDefinitions.h"
+#ifdef OST_TRACE_COMPILER_IN_USE
+#include "harvesteraoTraces.h"
+#endif
 // constants
 const TInt32 KFileMonitorPluginUid = 0x20007186;  // file monitor plugin implementation uid
 const TInt KPlaceholderQueueSize = 99;
 // ---------------------------------------------------------------------------
 //
 CHarvesterAO* CHarvesterAO::NewLC()
 {
 WRITELOG( "CHarvesterAO::NewLC() - begin" );
+OstTrace0( TRACE_NORMAL, CHARVESTERAO_NEWLC, "CHarvesterAO::NewLC" );
 CHarvesterAO* self = new (ELeave) CHarvesterAO();
 CleanupStack::PushL( self );
 self->ConstructL();
 return self;
 // ---------------------------------------------------------------------------
 //
 CHarvesterAO* CHarvesterAO::NewL()
 {
 WRITELOG( "CHarvesterAO::NewL() - begin" );
+OstTrace0( TRACE_NORMAL, CHARVESTERAO_NEWL, "CHarvesterAO::NewL" );
 CHarvesterAO* self = CHarvesterAO::NewLC();
 CleanupStack::Pop( self );
 return self;
 }
 // ---------------------------------------------------------------------------
 //
 CHarvesterAO::CHarvesterAO() : CActive( KHarvesterPriorityHarvestingPlugin )
 {
 WRITELOG( "CHarvesterAO::CHarvesterAO() - begin" );
+OstTrace0( TRACE_NORMAL, CHARVESTERAO_CHARVESTERAO, "CHarvesterAO::CHarvesterAO" );
 iServerPaused = ETrue;
 iNextRequest = ERequestIdle;
 iContextEngineInitialized = EFalse;
 // ---------------------------------------------------------------------------
 //
 CHarvesterAO::~CHarvesterAO()
 {
 WRITELOG( "CHarvesterAO::~CHarvesterAO()" );
+OstTrace0( TRACE_NORMAL, DUP1_CHARVESTERAO_CHARVESTERAO, "CHarvesterAO::~CHarvesterAO" );
 Cancel();
 	iFs.Close();
 // ---------------------------------------------------------------------------
 //
 void CHarvesterAO::ConstructL()
 {
 WRITELOG( "CHarvesterAO::ConstructL() - begin" );
+OstTrace0( TRACE_NORMAL, CHARVESTERAO_CONSTRUCTL, "CHarvesterAO::ConstructL - begin" );
 CActiveScheduler::Add( this );
 	User::LeaveIfError( iFs.Connect() );
 // Setting up MdE Session
 iPhoneSoundsPath = phoneSoundPath.AllocL();
 TFileName mmcSoundPath( mmcRoot );
 mmcSoundPath.Append( sounds );
 iMmcSoundsPath = mmcSoundPath.Right( mmcSoundPath.Length() - 1 ).AllocL();
+OstTrace0( TRACE_NORMAL, DUP1_CHARVESTERAO_CONSTRUCTL, "CHarvesterAO::ConstructL - end" );
 WRITELOG( "CHarvesterAO::ConstructL() - end" );
 }
 // ---------------------------------------------------------------------------
 // LoadMonitorPluginsL
 // ---------------------------------------------------------------------------
 //
 void CHarvesterAO::LoadMonitorPluginsL()
 {
 WRITELOG( "CHarvesterAO::LoadMonitorPluginsL()" );
+OstTrace0( TRACE_NORMAL, CHARVESTERAO_LOADMONITORPLUGINSL, "CHarvesterAO::LoadMonitorPluginsL" );
 RImplInfoPtrArray infoArray;
 TCleanupItem cleanupItem( MdsUtils::CleanupEComArray, &infoArray );
 CleanupStack::PushL( cleanupItem );
 }
 }
 else
 {
 WRITELOG( "CHarvesterAO::LoadMonitorPlugins() - Failed to load a monitor plugin!" );
+OstTrace0( TRACE_NORMAL, DUP1_CHARVESTERAO_LOADMONITORPLUGINSL, "CHarvesterAO::LoadMonitorPluginsL  - Failed to load a monitor plugin!" );
 delete plugin;
 plugin = NULL;
 }
 }
 // ---------------------------------------------------------------------------
 //
 void CHarvesterAO::DeleteMonitorPlugins()
 {
 WRITELOG( "CHarvesterAO::DeleteMonitorPlugins()" );
+OstTrace0( TRACE_NORMAL, CHARVESTERAO_DELETEMONITORPLUGINS, "CHarvesterAO::DeleteMonitorPlugins" );
 iMonitorPluginArray.ResetAndDestroy();
 iMonitorPluginArray.Close();
+OstTrace0( TRACE_NORMAL, DUP1_CHARVESTERAO_DELETEMONITORPLUGINS, "CHarvesterAO::DeleteMonitorPlugins - end" );
 WRITELOG( "CHarvesterAO::DeleteMonitorPlugins() - end" );
 }
 // ---------------------------------------------------------------------------
 // StartMonitoring
 // ---------------------------------------------------------------------------
 //
 void CHarvesterAO::StartMonitoring()
 {
 WRITELOG( "CHarvesterAO::StartMonitoring()" );
+OstTrace0( TRACE_NORMAL, CHARVESTERAO_STARTMONITORING, "CHarvesterAO::StartMonitoring" );
 const TInt count( iMonitorPluginArray.Count() );
 for ( TInt i = 0; i < count; i++ )
 {
 iMonitorPluginArray[i]->StartMonitoring( *iQueue, iMdESession, NULL,
 // ---------------------------------------------------------------------------
 //
 void CHarvesterAO::StopMonitoring()
 {
 WRITELOG( "CHarvesterAO::StopMonitoring()" );
+OstTrace0( TRACE_NORMAL, CHARVESTERAO_STOPMONITORING, "CHarvesterAO::StopMonitoring" );
 const TInt count( iMonitorPluginArray.Count() );
 for ( TInt i = 0; i < count; i++ )
 {
 // ---------------------------------------------------------------------------
 //
 void CHarvesterAO::PauseMonitoring()
 {
 WRITELOG( "CHarvesterAO::PauseMonitoring()" );
+OstTrace0( TRACE_NORMAL, CHARVESTERAO_PAUSEMONITORING, "CHarvesterAO::PauseMonitoring" );
 const TInt count( iMonitorPluginArray.Count() );
 for ( TInt i = 0; i<count; i++ )
 {
 iMonitorPluginArray[i]->PauseMonitoring();
 }
+OstTrace0( TRACE_NORMAL, DUP1_CHARVESTERAO_PAUSEMONITORING, "CHarvesterAO::PauseMonitoring - end" );
 WRITELOG( "CHarvesterAO::PauseMonitoring() - end" );
 }
 // ---------------------------------------------------------------------------
 // ResumeMonitoring
 // ---------------------------------------------------------------------------
 //
 void CHarvesterAO::ResumeMonitoring()
 {
 WRITELOG( "CHarvesterAO::ResumeMonitoring()" );
+OstTrace0( TRACE_NORMAL, CHARVESTERAO_RESUMEMONITORING, "CHarvesterAO::ResumeMonitoring" );
 const TInt count( iMonitorPluginArray.Count() );
 for ( TInt i=0; i < count; i++ )
 {
 // ---------------------------------------------------------------------------
 //
 void CHarvesterAO::HandleUnmount( TUint32 aMediaId )
 	{
 WRITELOG1( "CHarvesterAO::HandleUnmount(%d)", aMediaId );
+	OstTrace1( TRACE_NORMAL, CHARVESTERAO_HANDLEUNMOUNT, "CHarvesterAO::HandleUnmount;aMediaId=%d", aMediaId );
 iUnmountDetected = ETrue;
 if( !iServerPaused )
 {
 TInt err( KErrNone );
 #ifdef _DEBUG
 	WRITELOG1( "CHarvesterAO::HandleUnmount() iReadyPHArray.Count() = %d", iReadyPHArray.Count() );
+	OstTrace1( TRACE_NORMAL, DUP1_CHARVESTERAO_HANDLEUNMOUNT, "CHarvesterAO::HandleUnmount;iReadyPHArray.Count()=%d", iReadyPHArray.Count() );
 #endif
 	TInt arrayCount( iReadyPHArray.Count() );
 	if( arrayCount > 0 )
 {
 for( TInt i=arrayCount-1; i>= 0; i--)
 err = iMediaIdUtil->GetMediaId( hd->Uri(), mediaId );
 if( err == KErrNone && mediaId == aMediaId )
 {
 WRITELOG1( "CHarvesterAO::HandleUnmount() remove iReadyPHArray %d", i);
+OstTrace1( TRACE_NORMAL, DUP2_CHARVESTERAO_HANDLEUNMOUNT, "CHarvesterAO::HandleUnmount remove iReadyPHArray %d", i );
 delete hd;
 hd = NULL;
 iReadyPHArray.Remove( i );
 removed++;
 arrayCount--;
 if( iReadyPHArray.Count() == 0 )
 {
 iReadyPHArray.Compress();
 }
 WRITELOG1( "CHarvesterAO::HandleUnmount() DecreaseItemCountL iReadyPHArray %d", removed);
+OstTrace1( TRACE_NORMAL, DUP3_CHARVESTERAO_HANDLEUNMOUNT, "CHarvesterAO::HandleUnmount DecreaseItemCountL iReadyPHArray %d", removed );
 TRAP_IGNORE( iHarvesterEventManager->DecreaseItemCountL( EHEObserverTypePlaceholder, removed) );
 }
 removed = 0;
 #ifdef _DEBUG
 	WRITELOG1( "CHarvesterAO::HandleUnmount() iPHArray.Count() = %d", iPHArray.Count() );
+	OstTrace1( TRACE_NORMAL, DUP4_CHARVESTERAO_HANDLEUNMOUNT, "CHarvesterAO::HandleUnmount iPHArray.Count()=%d", iPHArray.Count() );
 #endif
 	arrayCount = iPHArray.Count();
 if( arrayCount > 0 )
 {
 for( TInt i=arrayCount-1; i>= 0; i--)
 err = iMediaIdUtil->GetMediaId( hd->Uri(), mediaId );
 if( err == KErrNone && mediaId == aMediaId )
 {
 WRITELOG1( "CHarvesterAO::HandleUnmount() remove iPHArray %d", i);
+OstTrace1( TRACE_NORMAL, DUP5_CHARVESTERAO_HANDLEUNMOUNT, "CHarvesterAO::HandleUnmount remove iPHArray %d", i );
 delete hd;
 				hd = NULL;
 iPHArray.Remove( i );
 removed++;
 arrayCount--;
 if( iPHArray.Count() == 0 )
 {
 iPHArray.Compress();
 }
 WRITELOG1( "CHarvesterAO::HandleUnmount() DecreaseItemCountL iPHArray %d", removed);
+OstTrace1( TRACE_NORMAL, DUP6_CHARVESTERAO_HANDLEUNMOUNT, "CHarvesterAO::HandleUnmount DecreaseItemCountL iPHArray %d", removed );
 TRAP_IGNORE( iHarvesterEventManager->DecreaseItemCountL( EHEObserverTypePlaceholder, removed) );
 }
 removed = 0;
 #ifdef _DEBUG
 WRITELOG1( "CHarvesterAO::HandleUnmount() iContainerPHArray.Count() = %d", iContainerPHArray.Count() );
+OstTrace1( TRACE_NORMAL, DUP7_CHARVESTERAO_HANDLEUNMOUNT, "CHarvesterAO::HandleUnmount iContainerPHArray.Count()=%d", iContainerPHArray.Count() );
 #endif
 arrayCount = iContainerPHArray.Count();
 if( arrayCount > 0 )
 {
 for( TInt i=arrayCount-1; i>= 0; i--)
 err = iMediaIdUtil->GetMediaId( hd->Uri(), mediaId );
 if( err == KErrNone && mediaId == aMediaId )
 {
 WRITELOG1( "CHarvesterAO::HandleUnmount() remove iContainerPHArray %d", i);
+OstTrace1( TRACE_NORMAL, DUP8_CHARVESTERAO_HANDLEUNMOUNT, "CHarvesterAO::HandleUnmount remove iContainerPHArray %d", i );
 delete hd;
 				hd = NULL;
 iContainerPHArray.Remove( i );
 removed++;
 arrayCount--;
 removed = 0;
 	const TUint count = iQueue->ItemsInQueue();
 	WRITELOG1( "CHarvesterAO::HandleUnmount() iQueue.Count() = %d", count );
+	OstTrace1( TRACE_NORMAL, DUP10_CHARVESTERAO_HANDLEUNMOUNT, "CHarvesterAO::HandleUnmount iQueue.Count() = %d", count );
 	if( count > 0 )
 	    {
 	    WRITELOG( "CHarvesterAO::HandleUnmount() remove iQueue" );
+	    OstTrace0( TRACE_NORMAL, DUP11_CHARVESTERAO_HANDLEUNMOUNT, "CHarvesterAO::HandleUnmount remove iQueue" );
 	    removed = iQueue->RemoveItems( aMediaId );
 	    WRITELOG1( "CHarvesterAO::HandleUnmount() removed iQueue = %d", removed );
+	    OstTrace1( TRACE_NORMAL, DUP12_CHARVESTERAO_HANDLEUNMOUNT, "CHarvesterAO::HandleUnmount removed iQueue = %d", removed );
 	    TRAP_IGNORE( iHarvesterEventManager->DecreaseItemCountL( EHEObserverTypePlaceholder, removed ) );
 TRAP_IGNORE( iHarvesterEventManager->DecreaseItemCountL( EHEObserverTypeMMC, removed ) );
 	    }
 	removed = 0;
 			}
 		if( removed )
 		    {
 WRITELOG1( "CHarvesterAO::HandleUnmount() remove from plugins = %d", removed);
+OstTrace1( TRACE_NORMAL, DUP13_CHARVESTERAO_HANDLEUNMOUNT, "CHarvesterAO::HandleUnmount remove from plugins = %d", removed );
 TRAP_IGNORE( iHarvesterEventManager->DecreaseItemCountL( EHEObserverTypePlaceholder, removed ) );
 TRAP_IGNORE( iHarvesterEventManager->DecreaseItemCountL( EHEObserverTypeMMC, removed ) );
 		    }
 		}
 // ---------------------------------------------------------------------------
 //
 void CHarvesterAO::StartComposersL()
 {
 WRITELOG( "CHarvesterAO::StartComposersL()" );
+OstTrace0( TRACE_NORMAL, CHARVESTERAO_STARTCOMPOSERSL, "CHarvesterAO::StartComposersL" );
 RImplInfoPtrArray infoArray;
 TCleanupItem cleanupItem( MdsUtils::CleanupEComArray, &infoArray );
 CleanupStack::PushL( cleanupItem );
 CComposerPlugin::ListImplementationsL( infoArray );
 const TInt count( infoArray.Count() );
 // ---------------------------------------------------------------------------
 //
 void CHarvesterAO::StopComposers()
 {
 WRITELOG( "CHarvesterAO::StopComposers()" );
+OstTrace0( TRACE_NORMAL, CHARVESTERAO_STOPCOMPOSERS, "CHarvesterAO::StopComposers" );
 const TInt count( iComposerPluginArray.Count() );
 for ( TInt i = count; --i >= 0; )
 {
 iComposerPluginArray[i]->RemoveSession();
 // ---------------------------------------------------------------------------
 //
 void CHarvesterAO::DeleteComposers()
 {
 WRITELOG( "CHarvesterAO::DeleteComposers()" );
+OstTrace0( TRACE_NORMAL, CHARVESTERAO_DELETECOMPOSERS, "CHarvesterAO::DeleteComposers" );
 iComposerPluginArray.ResetAndDestroy();
 iComposerPluginArray.Close();
 WRITELOG( "CHarvesterAO::DeleteComposers() - end" );
 // ---------------------------------------------------------------------------
 //
 TBool CHarvesterAO::IsComposingReady()
 {
 WRITELOG( "CHarvesterAO::IsComposingReady()" );
+OstTrace0( TRACE_NORMAL, CHARVESTERAO_ISCOMPOSINGREADY, "CHarvesterAO::IsComposingReady" );
 const TInt count( iComposerPluginArray.Count() );
 for ( TInt i = count; --i >= 0; )
 {
 if ( iComposerPluginArray[i]->IsComposingComplete() == EFalse )
 // ---------------------------------------------------------------------------
 //
 void CHarvesterAO::ReadItemFromQueueL()
 {
 WRITELOG( "CHarvesterAO::ReadItemFromQueueL()" );
+OstTrace0( TRACE_NORMAL, CHARVESTERAO_READITEMFROMQUEUEL, "CHarvesterAO::ReadItemFromQueueL" );
 CHarvesterData* hd = iQueue->GetNextItem();
 if ( hd->ObjectType() == EPlaceholder )
 	{
 // ---------------------------------------------------------------------------
 //
 void CHarvesterAO::HandlePlaceholdersL( TBool aCheck )
 	{
 	WRITELOG( "CHarvesterAO::HandlePlaceholdersL()" );
+OstTrace0( TRACE_NORMAL, CHARVESTERAO_HANDLEPLACEHOLDERSL, "CHarvesterAO::HandlePlaceholdersL" );
 	RPointerArray<CMdEObject> mdeObjectArray;
 	CleanupClosePushL( mdeObjectArray );
 	TTimeIntervalSeconds timeOffsetSeconds = User::UTCOffset();
 		    const TDesC& uri = hd->Uri();
 		    const TInt err = iFs.Entry( uri, *entry );
 		    if ( err != KErrNone )
 		    	{
 		    	WRITELOG( "CHarvesterAO::HandlePlaceholdersL() - cannot create placeholder data object for camera. file does not exists" );
+		    	OstTrace0( TRACE_NORMAL, DUP1_CHARVESTERAO_HANDLEPLACEHOLDERSL, "CHarvesterAO::HandlePlaceholdersL- cannot create placeholder data object for camera. file does not exists" );
 	    		// notify observer
 	    	    HarvestCompleted( hd->ClientId(), hd->Uri(), err );
 				delete hd;
 				hd = NULL;
 				iPHArray.Remove( i );
 			{
 			phData = static_cast<CPlaceholderData*> ( hd->ClientData() );
 		    if( !phData )
 		    	{
 		    	WRITELOG( "CHarvesterAO::HandlePlaceholdersL() - Placeholder data object NULL - abort" );
+		    	OstTrace0( TRACE_NORMAL, DUP2_CHARVESTERAO_HANDLEPLACEHOLDERSL, "CHarvesterAO::HandlePlaceholdersL - Placeholder data object NULL - abort" );
 		    	const TInt error( KErrUnknown );
 	    		// notify observer
 	    	    HarvestCompleted( hd->ClientId(), hd->Uri(), error );
 				delete hd;
 				hd = NULL;
 	    const TInt isPreinstalled = ph->Preinstalled();
 	    if( isPreinstalled == MdeConstants::MediaObject::EPreinstalled )
 	    	{
 	    	WRITELOG("CHarvesterAO::HandlePlaceholdersL() - preinstalled");
+	    	OstTrace0( TRACE_NORMAL, DUP3_CHARVESTERAO_HANDLEPLACEHOLDERSL, "CHarvesterAO::HandlePlaceholdersL - preinstalled" );
 	    	mdeObject->AddInt32PropertyL( *iPropDefs->iPreinstalledPropertyDef, isPreinstalled );
 	    	}
 	    hd->SetEventType( EHarvesterEdit );
 }
 		if( objDefStr.Length() == 0 )
 			{
 			WRITELOG( "CHarvesterAO::CheckFileExtensionAndHarvestL() - cannot get object definition" );
+			OstTrace0( TRACE_NORMAL, CHARVESTERAO_CHECKFILEEXTENSIONANDHARVESTL, "CHarvesterAO::CheckFileExtensionAndHarvestL - cannot get object definition" );
 			isError = ETrue;
 			}
 		else if( objDefStr == KInUse )
 		    {
 aHD->SetErrorCode( KMdEErrHarvestingFailed );
 				aHD->SetEventType( EHarvesterEdit );
 				}
 			else
 				{
 				WRITELOG( "CHarvesterAO::CheckFileExtensionAndHarvestL() - getting mdeobject" );
+				OstTrace0( TRACE_NORMAL, DUP1_CHARVESTERAO_CHECKFILEEXTENSIONANDHARVESTL, "CHarvesterAO::CheckFileExtensionAndHarvestL - getting mdeobject" );
 				TRAP( mdeError, mdeObject = iMdeObjectHandler->GetMetadataObjectL( *aHD, objDefStr ) );
 				}
 			TInt harvesterError = KErrNone;
 			if( mdeError != KErrNone)
 				{
 				WRITELOG1( "CHarvesterAO::CheckFileExtensionAndHarvestL() - cannot get mde object. error: %d", mdeError );
+				OstTrace1( TRACE_NORMAL, DUP2_CHARVESTERAO_CHECKFILEEXTENSIONANDHARVESTL, "CHarvesterAO::CheckFileExtensionAndHarvestL - cannot get mde object. error: %d", mdeError );
 				MdsUtils::ConvertTrapError( mdeError, harvesterError );
 				if( harvesterError == KMdEErrHarvestingFailedPermanent )
 					{
 					WRITELOG( "CHarvesterAO::CheckFileExtensionAndHarvestL() - permanent fail" );
+					OstTrace0( TRACE_NORMAL, DUP3_CHARVESTERAO_CHECKFILEEXTENSIONANDHARVESTL, "CHarvesterAO::CheckFileExtensionAndHarvestL - permanent fail" );
 					isError = ETrue;
 					}
 				else if ( harvesterError == KMdEErrHarvestingFailed )
 					{
 	                WRITELOG( "CHarvesterAO::CheckFileExtensionAndHarvestL() - KMdEErrHarvestingFailed");
+	                OstTrace0( TRACE_NORMAL, DUP4_CHARVESTERAO_CHECKFILEEXTENSIONANDHARVESTL, "CHarvesterAO::CheckFileExtensionAndHarvestL - KMdEErrHarvestingFailed" );
 	                aHD->SetErrorCode( KMdEErrHarvestingFailed );
 	                HarvestingCompleted( aHD );
 	                return;
 					}
 				}
 			if( !mdeObject )
 				{
 				WRITELOG( "CHarvesterAO::CheckFileExtensionAndHarvestL() - mde object is null. stop harvesting" );
+				OstTrace0( TRACE_NORMAL, DUP5_CHARVESTERAO_CHECKFILEEXTENSIONANDHARVESTL, "CHarvesterAO::CheckFileExtensionAndHarvestL - mde object is null. stop harvesting" );
 				isError = ETrue;
 				}
 			}
 		if( isError )
 			{
 	TInt pluginErr = KErrNone;
 TRAPD( err, pluginErr = iHarvesterPluginFactory->HarvestL( aHD ));
 if ( err != KErrNone )
 	{
 	WRITELOG1( "CHarvesterAO::CheckFileExtensionAndHarvestL() - plugin error: %d", err );
+	OstTrace1( TRACE_NORMAL, DUP6_CHARVESTERAO_CHECKFILEEXTENSIONANDHARVESTL, "CHarvesterAO::CheckFileExtensionAndHarvestL - plugin error: %d", err );
 	if ( err == KErrInUse )
 		{
 WRITELOG( "CHarvesterAO::CheckFileExtensionAndHarvestL() - item in use" );
+OstTrace0( TRACE_NORMAL, DUP7_CHARVESTERAO_CHECKFILEEXTENSIONANDHARVESTL, "CHarvesterAO::CheckFileExtensionAndHarvestL - item in use" );
 aHD->SetErrorCode( KMdEErrHarvestingFailed );
 HarvestingCompleted( aHD );
 return;
 		}
 	HarvestingCompleted( aHD );
 	return;
 	}
 WRITELOG1("CHarvesterAO::CheckFileExtensionAndHarvestL() - ends with error %d", pluginErr );
+OstTrace1( TRACE_NORMAL, DUP8_CHARVESTERAO_CHECKFILEEXTENSIONANDHARVESTL, "CHarvesterAO::CheckFileExtensionAndHarvestL) - ends with error %d", pluginErr );
 SetNextRequest( ERequestHarvest );
 }
 // ---------------------------------------------------------------------------
 // HarvestingCompleted
 // ---------------------------------------------------------------------------
 //
 void CHarvesterAO::HarvestingCompleted( CHarvesterData* aHD )
 {
 WRITELOG( "CHarvesterAO::HarvestingCompleted()" );
+OstTrace0( TRACE_NORMAL, CHARVESTERAO_HARVESTINGCOMPLETED, "CHarvesterAO::HarvestingCompleted" );
 if ( aHD->ErrorCode() == KErrNone )
 {
 iReHarvester->CheckItem( *aHD );
 TInt mdeError = KErrNone;
 if( !aHD->TakeSnapshot() )
 	{
 	WRITELOG( "CHarvesterAO::HarvestingCompleted() origin is not camera or clf" );
+	OstTrace0( TRACE_NORMAL, DUP2_CHARVESTERAO_HARVESTINGCOMPLETED, "CHarvesterAO::HarvestingCompleted origin is not camera or clf" );
 aHD->MdeObject().SetPlaceholder( EFalse );
 TRAP_IGNORE( iHarvesterEventManager->DecreaseItemCountL( EHEObserverTypePlaceholder ) );
 	TRAP( mdeError, iMdeObjectHandler->SetMetadataObjectL( *aHD ) );
 	}
 if(mdeError != KErrNone)
 	{
 	WRITELOG( "==============================ERROR===============================" );
 WRITELOG( "CHarvesterAO::HarvestingCompleted() - cannot set metadata object" );
 WRITELOG( "==============================ERROR done =========================" );
+OstTrace0( TRACE_NORMAL, DUP3_CHARVESTERAO_HARVESTINGCOMPLETED, "CHarvesterAO::HarvestingCompleted - cannot set metadata object" );
 delete aHD;
 aHD = NULL;
 TRAP_IGNORE( iHarvesterEventManager->DecreaseItemCountL( EHEObserverTypeMMC, 1 ) );
 	}
 else
 	{
 	WRITELOG( "CHarvesterAO::HarvestingCompleted() mdeError == KErrNone" );
+	OstTrace0( TRACE_NORMAL, DUP4_CHARVESTERAO_HARVESTINGCOMPLETED, "CHarvesterAO::HarvestingCompleted mdeError == KErrNone" );
 	        if ( aHD->TakeSnapshot() && iCtxEngine )
 	            {
 	            WRITELOG( "CHarvesterAO::HarvestingCompleted() - Taking a context snapshot." );
+	            OstTrace0( TRACE_NORMAL, DUP5_CHARVESTERAO_HARVESTINGCOMPLETED, "CHarvesterAO::HarvestingCompleted - Taking a context snapshot." );
 	            iCtxEngine->ContextSnapshot( *this, *aHD );
 	            }
 	        else
 	        	{
 	        	TLocationData* locData = aHD->LocationData();
 	        	if( locData )
 	        		{
 	        		WRITELOG( "CHarvesterAO::HarvestingCompleted() - Creating location object. " );
+	        		OstTrace0( TRACE_NORMAL, DUP6_CHARVESTERAO_HARVESTINGCOMPLETED, "CHarvesterAO::HarvestingCompleted - Creating location object." );
 	        		RLocationObjectManipulator lo;
 	        		const TInt loError = lo.Connect();
 	        		if (loError == KErrNone)
 	        			{
 	        			TInt err = lo.CreateLocationObject( *locData, aHD->MdeObject().Id() );
 	        			if( err != KErrNone )
 	        				{
 	        				WRITELOG( "CHarvesterAO::HarvestingCompleted() - Location object creation failed!!!" );
+	        				OstTrace0( TRACE_NORMAL, DUP7_CHARVESTERAO_HARVESTINGCOMPLETED, "CHarvesterAO::HarvestingCompleted - Location object creation failed!!!" );
 	        				}
 	        			}
 	        		else
 	        			{
 	        			WRITELOG( "CHarvesterAO::HarvestingCompleted() - LocationObjectManipulator connect failed!!!" );
+	        			OstTrace0( TRACE_NORMAL, DUP8_CHARVESTERAO_HARVESTINGCOMPLETED, "CHarvesterAO::HarvestingCompleted - LocationObjectManipulator connect failed!!" );
 	        			}
 	        		lo.Close();
 	        		}
 else
 {
 #ifdef _DEBUG
 WRITELOG( "==============================ERROR===============================" );
 WRITELOG1( "CHarvesterAO::HarvestingCompleted() - not OK! Error: %d", aHD->ErrorCode() );
+OstTrace1( TRACE_NORMAL, DUP9_CHARVESTERAO_HARVESTINGCOMPLETED, "CHarvesterAO::HarvestingCompleted - not OK! Error: %d", aHD->ErrorCode() );
 #endif
 		const TInt errorCode( aHD->ErrorCode() );
 if ( errorCode== KMdEErrHarvestingFailed )
 {
 #ifdef _DEBUG
 WRITELOG1("CHarvesterAO::HarvestingCompleted() - KMdEErrHarvestingFailed - %S - reharvesting", &aHD->Uri() );
+OstTrace0( TRACE_NORMAL, DUP1_CHARVESTERAO_HARVESTINGCOMPLETED, "CHarvesterAO::HarvestingCompleted - KMdEErrHarvestingFailed - reharvesting" );
 #endif
 iReHarvester->AddItem( aHD );
 }
 else if ( errorCode == KMdEErrHarvestingFailedPermanent ||
 errorCode == KMdEErrHarvestingFailedUnknown )
 {
 WRITELOG( "CHarvesterAO::HarvestingCompleted() - KMdEErrHarvestingFailedPermanent - no need to re-harvest!" );
+OstTrace0( TRACE_NORMAL, DUP10_CHARVESTERAO_HARVESTINGCOMPLETED, "CHarvesterAO::HarvestingCompleted - KMdEErrHarvestingFailedPermanent - no need to re-harvest!" );
 TRAP_IGNORE( iHarvesterEventManager->DecreaseItemCountL( EHEObserverTypeMMC, 1 ) );
 delete aHD;
 			aHD = NULL;
 }
 else
 {
 WRITELOG1( "CHarvesterAO::HarvestingCompleted() - unknown error: %d", errorCode );
+OstTrace1( TRACE_NORMAL, DUP11_CHARVESTERAO_HARVESTINGCOMPLETED, "CHarvesterAO::HarvestingCompleted - unknown error: %d", errorCode );
 delete aHD;
 aHD = NULL;
 }
 WRITELOG( "==============================ERROR done =========================" );
+OstTrace0( TRACE_NORMAL, DUP12_CHARVESTERAO_HARVESTINGCOMPLETED, "==============================ERROR done =========================" );
 }
 SetNextRequest( ERequestHarvest );
 }
 // ---------------------------------------------------------------------------
 //
 void CHarvesterAO::HandleSessionOpened( CMdESession& aSession, TInt aError )
 {
 WRITELOG( "HarvesterThread::HandleSessionOpened()" );
+OstTrace0( TRACE_NORMAL, CHARVESTERAO_HANDLESESSIONOPENED, "CHarvesterAO::HandleSessionOpened" );
 if ( KErrNone == aError )
 {
 TBool isTNMDaemonEnabled( EFalse );
 TRAP_IGNORE( CHarvesterCenRepUtil::IsThumbnailDaemonEnabledL( isTNMDaemonEnabled ) );
 	iMdeSessionInitialized = ETrue;
 }
 else
 	{
 WRITELOG( "CHarvesterAO::HandleSessionOpened() - error creating mde harvester session" );
+OstTrace0( TRACE_NORMAL, DUP1_CHARVESTERAO_HANDLESESSIONOPENED, "CHarvesterAO::HandleSessionOpened) - error creating mde harvester session" );
 	}
 // Setting up context Engine (initialization is ready when ContextInitializationStatus -callback is called)
 TRAP( errorTrap, iCtxEngine = CContextEngine::GetInstanceL( this ) ); // Create the context engine
 if ( errorTrap != KErrNone )
 {
 WRITELOG( "CHarvesterAO::HandleSessionOpened() - Context Engine creation failed" );
+OstTrace0( TRACE_NORMAL, DUP2_CHARVESTERAO_HANDLESESSIONOPENED, "CHarvesterAO::HandleSessionOpened - Context Engine creation failed" );
 }
 #ifdef _DEBUG
 TRAP( errorTrap, iMdeObjectHandler = CMdeObjectHandler::NewL( *iMdESession ) );
 if ( errorTrap != KErrNone )
 {
 WRITELOG( "CHarvesterAO::HandleSessionOpened() - ObjectHandler creation failed" );
+OstTrace0( TRACE_NORMAL, DUP3_CHARVESTERAO_HANDLESESSIONOPENED, "CHarvesterAO::HandleSessionOpened - ObjectHandler creation failed" );
 }
 // Setting up monitor plugins
 TRAP( errorTrap, LoadMonitorPluginsL() );
 if ( errorTrap != KErrNone )
 {
 WRITELOG( "CHarvesterAO::HandleSessionOpened() - error loading monitor plugins" );
+OstTrace0( TRACE_NORMAL, DUP4_CHARVESTERAO_HANDLESESSIONOPENED, "CHarvesterAO::HandleSessionOpened - error loading monitor plugins" );
 }
 // To check if the default namespace structure is in order
 TRAP( errorTrap, PreallocateNamespaceL( aSession.GetDefaultNamespaceDefL() ) );
 if ( errorTrap != KErrNone )
 {
 WRITELOG( "CHarvesterAO::HandleSessionOpened() - error loading default schema" );
+OstTrace0( TRACE_NORMAL, DUP5_CHARVESTERAO_HANDLESESSIONOPENED, "CHarvesterAO::HandleSessionOpened - error loading default schema" );
 }
 TRAP( errorTrap, StartComposersL() );
 if ( errorTrap != KErrNone )
 {
 WRITELOG( "CHarvesterAO::HandleSessionOpened() - couldn't start composer plugins" );
+OstTrace0( TRACE_NORMAL, DUP6_CHARVESTERAO_HANDLESESSIONOPENED, "CHarvesterAO::HandleSessionOpened - couldn't start composer plugins" );
 }
 #else
 // The idea here is that all of these  methods needs to be called,
 // even if some leave, thus the several TRAPs
 TRAP_IGNORE( iMdeObjectHandler = CMdeObjectHandler::NewL( *iMdESession ) );
 TRAP( errorTrap, iDiskFullNotifier = CMdSHarvesterDiskspaceObserverAO::NewL( *this, KDiskFullThreshold, KMdsSqlDbDefaultName ) );
 if ( errorTrap != KErrNone )
 {
 WRITELOG( "CHarvesterAO::HandleSessionOpened() - couldn't start diskspace observer" );
+OstTrace0( TRACE_NORMAL, DUP7_CHARVESTERAO_HANDLESESSIONOPENED, "CHarvesterAO::HandleSessionOpened - couldn't start diskspace observer" );
 }
 TRAP( errorTrap, iOnDemandAO = COnDemandAO::NewL( *iMdESession, *iQueue,
 		*iHarvesterPluginFactory, &iReadyPHArray ) );
 if ( errorTrap == KErrNone )
 	{
 	TRAP( errorTrap, iOnDemandAO->StartL() );
 	if ( errorTrap != KErrNone )
 		{
 		WRITELOG( "CHarvesterAO::HandleSessionOpened() - couldn't start on demand observer" );
+		OstTrace0( TRACE_NORMAL, DUP8_CHARVESTERAO_HANDLESESSIONOPENED, "CHarvesterAO::HandleSessionOpened - couldn't start on demand observer" );
 		}
 	}
 else
 	{
 	WRITELOG( "CHarvesterAO::HandleSessionOpened() - couldn't create on demand observer" );
+	OstTrace0( TRACE_NORMAL, DUP9_CHARVESTERAO_HANDLESESSIONOPENED, "CHarvesterAO::HandleSessionOpened - couldn't create on demand observer" );
 	}
 // Initializing pause indicator
 iServerPaused = EFalse;
 #ifdef _DEBUG
 WRITELOG( "HarvesterThread::HandleSessionOpened() - Succeeded!" );
+OstTrace0( TRACE_NORMAL, DUP10_CHARVESTERAO_HANDLESESSIONOPENED, "CHarvesterAO::HandleSessionOpened - Succeeded!" );
 TBool isRomScanEnabled( EFalse );
 TRAP_IGNORE( CHarvesterCenRepUtil::IsRomScanEnabledL( isRomScanEnabled ) );
 if( isRomScanEnabled )
 {
 TRAP( errorTrap, BootRomScanL() );
 if( errorTrap != KErrNone )
 {
 WRITELOG1( "CHarvesterAO::HandleSessionOpened() - BootRomScanL() returned error: %d", errorTrap );
+OstTrace1( TRACE_NORMAL, DUP11_CHARVESTERAO_HANDLESESSIONOPENED, "CHarvesterAO::HandleSessionOpened - BootRomScanL() returned error: %d", errorTrap );
 }
 }
 TRAP( errorTrap, BootPartialRestoreScanL() );
 if( errorTrap != KErrNone )
 	{
 	WRITELOG1( "CHarvesterAO::HandleSessionOpened() - BootPartialRestoreScanL() returned error: %d", errorTrap );
+	OstTrace1( TRACE_NORMAL, DUP12_CHARVESTERAO_HANDLESESSIONOPENED, "CHarvesterAO::HandleSessionOpened - BootPartialRestoreScanL() returned error: %d", errorTrap );
 	}
 #else
 // The idea here is that all of these three methods needs to be called,
 // even if some leave, thus the two TRAPs
 TBool isRomScanEnabled( EFalse );
 }
 else
 {
 iServerPaused = ETrue;
 WRITELOG1( "HarvesterThread::HandleSessionOpened() - Failed: %d!", aError );
+OstTrace1( TRACE_NORMAL, DUP13_CHARVESTERAO_HANDLESESSIONOPENED, "CHarvesterAO::HandleSessionOpened - Failed: %d!", aError );
 }
 }
 // ---------------------------------------------------------------------------
 // HandleSessionError
 //
 void CHarvesterAO::HandleSessionError( CMdESession& /*aSession*/, TInt aError )
 {
 if ( KErrNone != aError )
 {
 WRITELOG1( "HarvesterThread::HandleSessionError() - Error: %d!", aError );
+OstTrace1( TRACE_NORMAL, CHARVESTERAO_HANDLESESSIONERROR, "CHarvesterAO::HandleSessionError - Error: %d!", aError );
 }
 }
 // ---------------------------------------------------------------------------
 // ContextInitializationStatus
 // ---------------------------------------------------------------------------
 //
 void CHarvesterAO::ContextInitializationStatus( TInt aErrorCode )
 {
 WRITELOG( "CHarvesterAO::ContextInitializationStatus()" );
+OstTrace0( TRACE_NORMAL, CHARVESTERAO_CONTEXTINITIALIZATIONSTATUS, "CHarvesterAO::ContextInitializationStatus" );
 if ( KErrNone == aErrorCode )
 {
 WRITELOG( "HarvesterThread::ContextInitializationStatus() - Succeeded!" );
+OstTrace0( TRACE_NORMAL, DUP1_CHARVESTERAO_CONTEXTINITIALIZATIONSTATUS, "CHarvesterAO::ContextInitializationStatus - Succeeded!" );
 iContextEngineInitialized = ETrue;
 if ( iMdeSessionInitialized )
 {
 iCtxEngine->SetMdeSession( iMdESession );
 }
 }
 else
 {
 WRITELOG1( "HarvesterThread::ContextInitializationStatus() - Failed: %d!", aErrorCode );
+OstTrace1( TRACE_NORMAL, DUP2_CHARVESTERAO_CONTEXTINITIALIZATIONSTATUS, "CHarvesterAO::ContextInitializationStatus - Failed: %d!", aErrorCode );
 }
 }
 // ---------------------------------------------------------------------------
 // PauseHarvester
 // ---------------------------------------------------------------------------
 //
 TInt CHarvesterAO::PauseHarvester()
 {
 WRITELOG( "CHarvesterAO::PauseHarvester()" );
+OstTrace0( TRACE_NORMAL, CHARVESTERAO_PAUSEHARVESTER, "CHarvesterAO::PauseHarvester" );
 iHarvesterPluginFactory->PauseHarvester( ETrue );
 iServerPaused = ETrue;
 if( !iRamFull && !iDiskFull && !iUnmountDetected )
 iManualPauseEnabled = ETrue;
 }
 // Everything is paused
 WRITELOG( "CHarvesterAO::PauseHarvester() - Moving paused state paused" );
+OstTrace0( TRACE_NORMAL, DUP1_CHARVESTERAO_PAUSEHARVESTER, "CHarvesterAO::PauseHarvester - Moving paused state paused" );
 return KErrNone;
 }
 // ---------------------------------------------------------------------------
 // ResumeHarvester
 // ---------------------------------------------------------------------------
 //
 void CHarvesterAO::ResumeHarvesterL()
 {
 WRITELOG( "CHarvesterAO::ResumeHarvesterL()" );
+OstTrace0( TRACE_NORMAL, CHARVESTERAO_RESUMEHARVESTERL, "CHarvesterAO::ResumeHarvesterL" );
 iHarvesterPluginFactory->PauseHarvester( EFalse );
 iServerPaused = EFalse;
 if( !iManualPauseEnabled &&
 // ---------------------------------------------------------------------------
 //
 void CHarvesterAO::RunL()
 {
 WRITELOG( "CHarvesterAO::RunL" );
+OstTrace0( TRACE_NORMAL, CHARVESTERAO_RUNL, "CHarvesterAO::RunL" );
 // check if pause is requested
 if ( this->iServerPaused && iNextRequest != ERequestPause && iNextRequest != ERequestResume)
 	{
 	iNextRequest = ERequestIdle;
 	}
 {
 // no more items in queue
 case ERequestIdle:
 {
 WRITELOG( "CHarvesterAO::RunL - ERequestIdle" );
+OstTrace0( TRACE_NORMAL, DUP1_CHARVESTERAO_RUNL, "CHarvesterAO::RunL - ERequestIdle" );
 iReadyPHArray.Compress();
 iContainerPHArray.Compress();
 iPHArray.Compress();
 iTempReadyPHArray.Compress();
 }
 // data added to harvester queue
 case ERequestHarvest:
 {
 WRITELOG( "CHarvesterAO::RunL - ERequestHarvest" );
+OstTrace0( TRACE_NORMAL, DUP2_CHARVESTERAO_RUNL, "CHarvesterAO::RunL - ERequestHarvest" );
 // harvest new items first...
 if ( iQueue->ItemsInQueue() > 0 )
 {
 WRITELOG( "CHarvesterAO::RunL - Items in queue - calling ReadItemFromQueueL()" );
 const TInt arrayCount( iReadyPHArray.Count() );
 				if( arrayCount > 0 )
 		{
 #ifdef _DEBUG
 		WRITELOG1("CHarvesterAO::RunL - items in ready pharray: %d", arrayCount );
+		OstTrace1( TRACE_NORMAL, DUP3_CHARVESTERAO_RUNL, "CHarvesterAO::RunL - items in ready pharray: %d", arrayCount );
 #endif
 		TInt endIndex( KPlaceholderQueueSize );
 		if( arrayCount < KPlaceholderQueueSize )
 		    {
 		    endIndex = arrayCount;
 case ERequestContainerPlaceholder:
 	{
 #ifdef _DEBUG
 	WRITELOG( "CHarvesterAO::RunL - ERequestContainerPlaceholder" );
+	OstTrace0( TRACE_NORMAL, DUP4_CHARVESTERAO_RUNL, "CHarvesterAO::RunL - ERequestContainerPlaceholder" );
 	WRITELOG1( "CHarvesterAO::RunL - Items in container pharray: %d", iContainerPHArray.Count() );
+	OstTrace1( TRACE_NORMAL, DUP5_CHARVESTERAO_RUNL, "CHarvesterAO::RunL - Items in container pharray: %d", iContainerPHArray.Count() );
 #endif
 	TInt count = iContainerPHArray.Count() > KContainerPlaceholderQueueSize ? KContainerPlaceholderQueueSize : iContainerPHArray.Count();
 	TInt i = 0;
 	while( i < count )
 		{
 // pause request
 case ERequestPause:
 {
 WRITELOG( "CHarvesterAO::RunL - ERequestPause" );
+OstTrace0( TRACE_NORMAL, DUP6_CHARVESTERAO_RUNL, "CHarvesterAO::RunL - ERequestPause" );
 User::LeaveIfError( PauseHarvester() );
 iHarvesterEventManager->SendEventL( EHEObserverTypeOverall, EHEStatePaused );
 if( iHarvesterStatusObserver )
 	{
 	iHarvesterStatusObserver->PauseReady( KErrNone );
 // resume request
 case ERequestResume:
 {
 WRITELOG( "CHarvesterAO::RunL - ERequestResume" );
+OstTrace0( TRACE_NORMAL, DUP7_CHARVESTERAO_RUNL, "CHarvesterAO::RunL - ERequestResume" );
 ResumeHarvesterL();
 iHarvesterEventManager->SendEventL( EHEObserverTypeOverall, EHEStateResumed );
 if( iHarvesterStatusObserver )
 	{
 iHarvesterStatusObserver->ResumeReady( KErrNone );
 break;
 default:
 {
 WRITELOG( "CHarvesterAO::RunL - Not supported request" );
+OstTrace0( TRACE_NORMAL, DUP8_CHARVESTERAO_RUNL, "CHarvesterAO::RunL - Not supported request" );
 User::Leave( KErrNotSupported );
 }
 break;
 }
 }
 // ---------------------------------------------------------------------------
 //
 void CHarvesterAO::DoCancel()
 {
 WRITELOG( "CHarvesterAO::DoCancel()" );
+OstTrace0( TRACE_NORMAL, CHARVESTERAO_DOCANCEL, "CHarvesterAO::DoCancel" );
 }
 // ---------------------------------------------------------------------------
 // RunError
 // ---------------------------------------------------------------------------
 //
 TInt CHarvesterAO::RunError( TInt aError )
 {
 WRITELOG( "CHarvesterAO::RunError" );
+OstTrace0( TRACE_NORMAL, CHARVESTERAO_RUNERROR, "CHarvesterAO::RunError" );
 switch( iNextRequest )
 {
 case ERequestHarvest:
 {
 WRITELOG( "CHarvesterAO::RunError - state ERequestHarvest" );
+OstTrace0( TRACE_NORMAL, DUP1_CHARVESTERAO_RUNERROR, "CHarvesterAO::RunError - state ERequestHarvest" );
 }
 break;
 case ERequestPause:
 {
 WRITELOG( "CHarvesterAO::RunError - state ERequestPause" );
+OstTrace0( TRACE_NORMAL, DUP2_CHARVESTERAO_RUNERROR, "CHarvesterAO::RunError - state ERequestPause" );
 if ( aError == KErrNotReady )
 {
 SetNextRequest( ERequestPause );
 }
 else if( iHarvesterStatusObserver )
 break;
 case ERequestResume:
 {
 WRITELOG( "CHarvesterAO::RunError - state ERequestResume" );
+OstTrace0( TRACE_NORMAL, DUP3_CHARVESTERAO_RUNERROR, "CHarvesterAO::RunError - state ERequestResume" );
 if( iHarvesterStatusObserver )
 	{
 iHarvesterStatusObserver->ResumeReady( aError );
 	}
 }
 break;
 default:
 {
 WRITELOG( "CHarvesterAO::RunError - unknown state" );
+OstTrace0( TRACE_NORMAL, DUP4_CHARVESTERAO_RUNERROR, "CHarvesterAO::RunError - unknown state" );
 }
 break;
 }
 return KErrNone;
 // ---------------------------------------------------------------------------
 //
 void CHarvesterAO::SetNextRequest( TRequest aRequest )
 {
 WRITELOG( "CHarvesterAO::SetNextRequest" );
+OstTrace0( TRACE_NORMAL, CHARVESTERAO_SETNEXTREQUEST, "CHarvesterAO::SetNextRequest" );
 iNextRequest = aRequest;
 if ( !IsActive() )
 {
 iStatus = KRequestPending;
 // ---------------------------------------------------------------------------
 //
 TBool CHarvesterAO::IsServerPaused()
 {
 WRITELOG( "CHarvesterAO::IsServerPaused" );
+OstTrace0( TRACE_NORMAL, CHARVESTERAO_ISSERVERPAUSED, "CHarvesterAO::IsServerPaused" );
 return iServerPaused;
 }
 // ---------------------------------------------------------------------------
 // From MBackupRestoreObserver.
 //
 void CHarvesterAO::BackupRestoreStart()
 {
 // close blacklist database connection
 WRITELOG( "CHarvesterAO::BackupRestoreStart" );
+OstTrace0( TRACE_NORMAL, CHARVESTERAO_BACKUPRESTORESTART, "CHarvesterAO::BackupRestoreStart" );
 iBlacklist->CloseDatabase();
 }
 // ---------------------------------------------------------------------------
 // From MBackupRestoreObserver.
 //
 void CHarvesterAO::BackupRestoreReady()
 {
 // restart blacklist database connection
 WRITELOG( "CHarvesterAO::BackupRestoreReady" );
+OstTrace0( TRACE_NORMAL, CHARVESTERAO_BACKUPRESTOREREADY, "CHarvesterAO::BackupRestoreReady" );
 iBlacklist->OpenDatabase();
 }
 // ---------------------------------------------------------------------------
 // From MMdSHarvesterDiskSpaceObserver.
 // ---------------------------------------------------------------------------
 //
 void CHarvesterAO::HandleDiskSpaceNotificationL( TDiskSpaceDirection aDiskSpaceDirection )
 {
 WRITELOG("CHarvesterAO::HandleDiskSpaceNotificationL()");
+OstTrace0( TRACE_NORMAL, CHARVESTERAO_HANDLEDISKSPACENOTIFICATIONL, "CHarvesterAO::HandleDiskSpaceNotificationL" );
 if( MMdSHarvesterDiskSpaceObserver::EMore == aDiskSpaceDirection )
 {
 WRITELOG("CHarvesterAO::HandleDiskSpaceNotificationL() - disk full");
+OstTrace0( TRACE_NORMAL, DUP1_CHARVESTERAO_HANDLEDISKSPACENOTIFICATIONL, "CHarvesterAO::HandleDiskSpaceNotificationL - disk full" );
 iDiskFull = EFalse;
 }
 else
 {
 WRITELOG("CHarvesterAO::HandleDiskSpaceNotificationL() - disk space available");
+OstTrace0( TRACE_NORMAL, DUP2_CHARVESTERAO_HANDLEDISKSPACENOTIFICATIONL, "CHarvesterAO::HandleDiskSpaceNotificationL - disk space available" );
 iDiskFull = ETrue;
 if( iServerPaused )
 {
 return;
 }
 // ---------------------------------------------------------------------------
 //
 void CHarvesterAO::HarvestFile( const RMessage2& aMessage )
 {
 WRITELOG( "CHarvesterAO::HarvestFile" );
+OstTrace0( TRACE_NORMAL, CHARVESTERAO_HARVESTFILE, "CHarvesterAO::HarvestFile" );
 const TInt KParamUri = 0;
 const TInt KParamAlbumIds = 1;
 const TInt KParamAddLocation = 2;
 // read uri
 HBufC* uri = HBufC::New( KMaxFileName );
 if ( ! uri )
 {
 WRITELOG( "CHarvesterAO::HarvestFile - out of memory creating uri container" );
+OstTrace0( TRACE_NORMAL, DUP1_CHARVESTERAO_HARVESTFILE, "CHarvesterAO::HarvestFile - out of memory creating uri container" );
 if (!aMessage.IsNull())
 {
 aMessage.Complete( KErrNoMemory );
 }
 return;
 TPtr uriPtr( uri->Des() );
 TInt err = aMessage.Read( KParamUri, uriPtr );
 if ( err != KErrNone )
 {
 WRITELOG1( "CHarvesterAO::HarvestFile - error in reading aMessage (uri): %d", err );
+OstTrace1( TRACE_NORMAL, DUP2_CHARVESTERAO_HARVESTFILE, "CHarvesterAO::HarvestFile - error in reading aMessage (uri): %d", err );
 if (!aMessage.IsNull())
 {
 aMessage.Complete( err );
 }
 delete uri;
 {
 HBufC8* albumIdBuf = HBufC8::New( KAlbumIdsLength );
 if ( !albumIdBuf )
 {
 WRITELOG( "CHarvesterAO::HarvestFile - error creating album id buffer." );
+OstTrace0( TRACE_NORMAL, DUP3_CHARVESTERAO_HARVESTFILE, "CHarvesterAO::HarvestFile - error creating album id buffer." );
 if (!aMessage.IsNull())
 {
 aMessage.Complete( KErrNoMemory );
 }
 delete uri;
 TPtr8 ptr( albumIdBuf->Des() );
 err = aMessage.Read( KParamAlbumIds, ptr );
 if ( err != KErrNone )
 {
 WRITELOG1( "CHarvesterAO::HarvestFile - error in reading aMessage (albumIds): %d", err );
+OstTrace1( TRACE_NORMAL, DUP4_CHARVESTERAO_HARVESTFILE, "CHarvesterAO::HarvestFile - error in reading aMessage (albumIds): %d", err );
 delete albumIdBuf;
 albumIdBuf = NULL;
 delete uri;
 uri = NULL;
 if (!aMessage.IsNull())
 TRAPD( err, DeserializeArrayL( ptr, albumIds ) );
 if ( err != KErrNone )
 {
 WRITELOG1( "CHarvesterAO::HarvestFile - error in reading album id array: %d", err );
+OstTrace1( TRACE_NORMAL, DUP5_CHARVESTERAO_HARVESTFILE, "CHarvesterAO::HarvestFile - error in reading album id array: %d", err );
 delete albumIdBuf;
 albumIdBuf = NULL;
 delete uri;
 uri = NULL;
 if (!aMessage.IsNull())
 delete albumIdBuf;
 albumIdBuf = NULL;
 WRITELOG1( "CHarvesterAO::HarvestFile - album id count: %d", albumIds.Count() );
+OstTrace1( TRACE_NORMAL, DUP6_CHARVESTERAO_HARVESTFILE, "CHarvesterAO::HarvestFile - album id count: %d", albumIds.Count() );
 }
 TBool addLocation;
 TPckg<TBool> location( addLocation );
 		err = aMessage.Read(KParamAddLocation, location);
 		if ( err != KErrNone )
 			{
 			WRITELOG1( "CHarvesterAO::HarvestFile - error in reading aMessage (addLocation): %d", err );
+			OstTrace1( TRACE_NORMAL, DUP7_CHARVESTERAO_HARVESTFILE, "CHarvesterAO::HarvestFile - error in reading aMessage (addLocation): %d", err );
 			delete uri;
 			uri = NULL;
 			if (!aMessage.IsNull())
 				{
 				aMessage.Complete( err );
 				}
 			return;
 			}
 		WRITELOG1( "RHarvesterClient::HarvestFile - add location: %d", addLocation );
+		OstTrace1( TRACE_NORMAL, DUP8_CHARVESTERAO_HARVESTFILE, "CHarvesterAO::HarvestFile - add location: %d", addLocation );
 CHarvesterData* hd = NULL;
 TRAP( err, hd = CHarvesterData::NewL( uri ) );
 if ( err != KErrNone || !hd )
 {
 WRITELOG( "CHarvesterAO::HarvestFile - creating harvUri failed" );
+OstTrace0( TRACE_NORMAL, DUP9_CHARVESTERAO_HARVESTFILE, "CHarvesterAO::HarvestFile - creating harvUri failed" );
 albumIds.Close();
 delete uri;
 uri = NULL;
 if (!aMessage.IsNull())
 {
 hd->SetClientData( clientData ); // ownership is transferred
 }
 else
 {
 WRITELOG( "CHarvesterAO::HarvestFile - creating clientData failed" );
+OstTrace0( TRACE_NORMAL, DUP10_CHARVESTERAO_HARVESTFILE, "CHarvesterAO::HarvestFile - creating clientData failed" );
 }
 if( iQueue )
 {
 iQueue->Append( hd );
 // ---------------------------------------------------------------------------
 //
 void CHarvesterAO::HarvestFileWithUID( const RMessage2& aMessage )
 {
 WRITELOG( "CHarvesterAO::HarvestFileWithUID" );
+OstTrace0( TRACE_NORMAL, CHARVESTERAO_HARVESTFILEWITHUID, "CHarvesterAO::HarvestFileWithUID" );
 const TInt KParamUri = 0;
 const TInt KParamAlbumIds = 1;
 const TInt KParamAddLocation = 2;
 // read uri
 HBufC* uri = HBufC::New( KMaxFileName );
 if ( ! uri )
 {
 WRITELOG( "CHarvesterAO::HarvestFileWithUID - out of memory creating uri container" );
+OstTrace0( TRACE_NORMAL, DUP1_CHARVESTERAO_HARVESTFILEWITHUID, "CHarvesterAO::HarvestFileWithUID - out of memory creating uri container" );
 if (!aMessage.IsNull())
 {
 aMessage.Complete( KErrNoMemory );
 }
 return;
 TPtr uriPtr( uri->Des() );
 TInt err = aMessage.Read( KParamUri, uriPtr );
 if ( err != KErrNone )
 {
 WRITELOG1( "CHarvesterAO::HarvestFileWithUID - error in reading aMessage (uri): %d", err );
+OstTrace1( TRACE_NORMAL, DUP2_CHARVESTERAO_HARVESTFILEWITHUID, "CHarvesterAO::HarvestFileWithUID - error in reading aMessage (uri): %d", err );
 if (!aMessage.IsNull())
 {
 aMessage.Complete( err );
 }
 delete uri;
 {
 HBufC8* albumIdBuf = HBufC8::New( KAlbumIdsLength );
 if ( !albumIdBuf )
 {
 WRITELOG( "CHarvesterAO::HarvestFileWithUID - error creating album id buffer." );
+OstTrace0( TRACE_NORMAL, DUP3_CHARVESTERAO_HARVESTFILEWITHUID, "CHarvesterAO::HarvestFileWithUID - error creating album id buffer." );
 if (!aMessage.IsNull())
 {
 aMessage.Complete( KErrNoMemory );
 }
 delete uri;
 TPtr8 ptr( albumIdBuf->Des() );
 err = aMessage.Read( KParamAlbumIds, ptr );
 if ( err != KErrNone )
 {
 WRITELOG1( "CHarvesterAO::HarvestFileWithUID - error in reading aMessage (albumIds): %d", err );
+OstTrace1( TRACE_NORMAL, DUP4_CHARVESTERAO_HARVESTFILEWITHUID, "CHarvesterAO::HarvestFileWithUID - error in reading aMessage (albumIds): %d", err );
 delete albumIdBuf;
 albumIdBuf = NULL;
 delete uri;
 uri = NULL;
 if (!aMessage.IsNull())
 TRAPD( err, DeserializeArrayL( ptr, albumIds ) );
 if ( err != KErrNone )
 {
 WRITELOG1( "CHarvesterAO::HarvestFileWithUID - error in reading album id array: %d", err );
+OstTrace1( TRACE_NORMAL, DUP5_CHARVESTERAO_HARVESTFILEWITHUID, "CHarvesterAO::HarvestFileWithUID - error in reading album id array: %d", err );
 delete albumIdBuf;
 albumIdBuf = NULL;
 delete uri;
 uri = NULL;
 if (!aMessage.IsNull())
 delete albumIdBuf;
 albumIdBuf = NULL;
 #ifdef _DEBUG
 WRITELOG1( "CHarvesterAO::HarvestFileWithUID - album id count: %d", albumIds.Count() );
+OstTrace1( TRACE_NORMAL, DUP6_CHARVESTERAO_HARVESTFILEWITHUID, "CHarvesterAO::HarvestFileWithUID - album id count: %d", albumIds.Count() );
 #endif
 }
 TBool addLocation;
 TPckg<TBool> location( addLocation );
 err = aMessage.Read(KParamAddLocation, location);
 if ( err != KErrNone )
 {
 WRITELOG1( "CHarvesterAO::HarvestFileWithUID - error in reading aMessage (addLocation): %d", err );
+OstTrace1( TRACE_NORMAL, DUP7_CHARVESTERAO_HARVESTFILEWITHUID, "CHarvesterAO::HarvestFileWithUID - error in reading aMessage (addLocation): %d", err );
 delete uri;
 uri = NULL;
 if (!aMessage.IsNull())
 {
 aMessage.Complete( err );
 }
 return;
 }
 WRITELOG1( "RHarvesterClient::HarvestFileWithUID - add location: %d", addLocation );
+OstTrace1( TRACE_NORMAL, DUP8_CHARVESTERAO_HARVESTFILEWITHUID, "CHarvesterAO::HarvestFileWithUID - add location: %d", addLocation );
 CHarvesterData* hd = NULL;
 TRAP( err, hd = CHarvesterData::NewL( uri ) );
 if ( err != KErrNone || !hd )
 {
 WRITELOG( "CHarvesterAO::HarvestFileWithUID - creating harvUri failed" );
+OstTrace0( TRACE_NORMAL, DUP9_CHARVESTERAO_HARVESTFILEWITHUID, "CHarvesterAO::HarvestFileWithUID - creating harvUri failed" );
 albumIds.Close();
 delete uri;
 uri = NULL;
 if (!aMessage.IsNull())
 {
 hd->SetClientData( clientData ); // ownership is transferred
 }
 else
 {
 WRITELOG( "CHarvesterAO::HarvestFileWithUID - creating clientData failed" );
+OstTrace0( TRACE_NORMAL, DUP10_CHARVESTERAO_HARVESTFILEWITHUID, "CHarvesterAO::HarvestFileWithUID - creating clientData failed" );
 }
 if( iQueue )
 	{
 	iQueue->Append( hd );
 // ---------------------------------------------------------------------------
 //
 void CHarvesterAO::RegisterProcessOrigin( const RMessage2& aMessage )
 {
 WRITELOG( "CHarvesterAO::RegisterProcessOrigin" );
+OstTrace0( TRACE_NORMAL, CHARVESTERAO_REGISTERPROCESSORIGIN, "CHarvesterAO::RegisterProcessOrigin" );
 if ( !iProcessOriginMapper )
 {
 WRITELOG( "CHarvesterAO::RegisterProcessOrigin - mapper not available." );
+OstTrace0( TRACE_NORMAL, DUP1_CHARVESTERAO_REGISTERPROCESSORIGIN, "CHarvesterAO::RegisterProcessOrigin - mapper not available." );
 if (!aMessage.IsNull())
 {
 aMessage.Complete( KErrNotSupported );
 }
 return;
 TUid processId = { 0 };
 processId.iUid = aMessage.Int0();
 if ( MdsUtils::IsValidProcessId( processId ) )
 {
 WRITELOG1( "CHarvesterAO::RegisterProcessOrigin - error reading processId. Read: %d", processId.iUid );
+OstTrace1( TRACE_NORMAL, DUP2_CHARVESTERAO_REGISTERPROCESSORIGIN, "CHarvesterAO::RegisterProcessOrigin - error reading processId. Read: %d", processId.iUid );
 if (!aMessage.IsNull())
 {
 aMessage.Complete( KErrCorrupt );
 }
 return;
 // read origin
 TOrigin origin = STATIC_CAST( TOrigin, aMessage.Int1() );
 WRITELOG1( "CHarvesterAO::RegisterProcessOrigin - origin: %d", origin );
+OstTrace1( TRACE_NORMAL, DUP3_CHARVESTERAO_REGISTERPROCESSORIGIN, "CHarvesterAO::RegisterProcessOrigin - origin: %d", origin );
 if ( origin < 0 )
 {
 WRITELOG( "CHarvesterAO::RegisterProcessOrigin - error reading origin from aMessage (negative)." );
+OstTrace0( TRACE_NORMAL, DUP4_CHARVESTERAO_REGISTERPROCESSORIGIN, "CHarvesterAO::RegisterProcessOrigin - error reading origin from aMessage (negative)." );
 if (!aMessage.IsNull())
 {
 aMessage.Complete( KErrCorrupt );
 }
 return;
 TRAPD( err, iProcessOriginMapper->RegisterProcessL( processId, origin ) );
 if ( err != KErrNone )
 {
 WRITELOG1( "CHarvesterAO::RegisterProcessOrigin - error registering mapping: %d", err );
+OstTrace1( TRACE_NORMAL, DUP5_CHARVESTERAO_REGISTERPROCESSORIGIN, "CHarvesterAO::RegisterProcessOrigin - error registering mapping: %d", err );
 if (!aMessage.IsNull())
 {
 aMessage.Complete( err );
 }
 return;
 // ---------------------------------------------------------------------------
 //
 void CHarvesterAO::UnregisterProcessOrigin( const RMessage2& aMessage )
 {
 WRITELOG( "CHarvesterAO::UnregisterProcessOrigin" );
+OstTrace0( TRACE_NORMAL, CHARVESTERAO_UNREGISTERPROCESSORIGIN, "CHarvesterAO::UnregisterProcessOrigin" );
 if ( !iProcessOriginMapper )
 {
 WRITELOG( "CHarvesterAO::RegisterProcessOrigin - mapper not available." );
+OstTrace0( TRACE_NORMAL, DUP1_CHARVESTERAO_UNREGISTERPROCESSORIGIN, "CHarvesterAO::UnregisterProcessOrigin - mapper not available." );
 if (!aMessage.IsNull())
 {
 aMessage.Complete( KErrNotSupported );
 }
 return;
 TUid processId = { 0 };
 processId.iUid = aMessage.Int0();
 if ( MdsUtils::IsValidProcessId( processId ) )
 {
 WRITELOG1( "CHarvesterAO::UnregisterProcessOrigin - error reading processId. Read: %d", processId.iUid );
+OstTrace1( TRACE_NORMAL, DUP2_CHARVESTERAO_UNREGISTERPROCESSORIGIN, "CHarvesterAO::UnregisterProcessOrigin - error reading processId. Read: %d", processId.iUid );
 if (!aMessage.IsNull())
 {
 aMessage.Complete( KErrCorrupt );
 }
 return;
 TRAPD( err, iProcessOriginMapper->UnregisterProcessL( processId ) );
 if ( err != KErrNone )
 {
 WRITELOG1( "CHarvesterAO::UnregisterProcessOrigin - error unregistering mapping: %d", err );
+OstTrace1( TRACE_NORMAL, DUP3_CHARVESTERAO_UNREGISTERPROCESSORIGIN, "CHarvesterAO::UnregisterProcessOrigin - error unregistering mapping: %d", err );
 if (!aMessage.IsNull())
 {
 aMessage.Complete( err );
 }
 return;
 // ---------------------------------------------------------------------------
 //
 TInt CHarvesterAO::RegisterHarvestComplete( const CHarvesterServerSession& aSession, const RMessage2& aMessage )
 {
 WRITELOG( "CHarvesterAO::RegisterHarvestComplete" );
+OstTrace0( TRACE_NORMAL, CHARVESTERAO_REGISTERHARVESTCOMPLETE, "CHarvesterAO::RegisterHarvestComplete" );
 return iHarvestFileMessages.Append(
 		THarvestFileRequest( aSession, aMessage ) );
 }
 // ---------------------------------------------------------------------------
 // ---------------------------------------------------------------------------
 //
 TInt CHarvesterAO::UnregisterHarvestComplete( const CHarvesterServerSession& aSession )
 {
 WRITELOG( "CHarvesterAO::UnregisterHarvestComplete" );
+OstTrace0( TRACE_NORMAL, CHARVESTERAO_UNREGISTERHARVESTCOMPLETE, "CHarvesterAO::UnregisterHarvestComplete" );
 TInt err( KErrNotFound );
 if ( iHarvestFileMessages.Count() > 0 )
 {
 for ( TInt i = iHarvestFileMessages.Count()-1; i >= 0; --i )
 // ---------------------------------------------------------------------------
 //
 void CHarvesterAO::RegisterHarvesterEvent( const RMessage2& aMessage )
 {
 WRITELOG( "CHarvesterAO::RegisterHarvesterEvent" );
+OstTrace0( TRACE_NORMAL, CHARVESTERAO_REGISTERHARVESTEREVENT, "CHarvesterAO::RegisterHarvesterEvent" );
 TRAPD( err, iHarvesterEventManager->RegisterEventObserverL( aMessage ) );
 aMessage.Complete( err );
 }
 // ---------------------------------------------------------------------------
 //
 void CHarvesterAO::UnregisterHarvesterEvent( const RMessage2& aMessage )
 {
 WRITELOG( "CHarvesterAO::UnregisterHarvesterEvent" );
+OstTrace0( TRACE_NORMAL, CHARVESTERAO_UNREGISTERHARVESTEREVENT, "CHarvesterAO::UnregisterHarvesterEvent" );
 const TInt err = iHarvesterEventManager->UnregisterEventObserver( aMessage );
 aMessage.Complete( err );
 }
 void CHarvesterAO::GetLastObserverId( const RMessage2& aMessage )
 	{
 	WRITELOG( "CHarvesterAO::GetLastObserverId" );
+	OstTrace0( TRACE_NORMAL, CHARVESTERAO_GETLASTOBSERVERID, "CHarvesterAO::GetLastObserverId" );
 	TUint observerId = iHarvesterEventManager->GetLastClientId();
 	TPckg<TUint> pckgId( observerId );
 	aMessage.Write( 0, pckgId );
 // ---------------------------------------------------------------------------
 //
 void CHarvesterAO::ContextSnapshotStatus( CHarvesterData* aHD )
 {
 WRITELOG( "CHarvesterAO::ContextSnapshotStatus()" );
+OstTrace0( TRACE_NORMAL, CHARVESTERAO_CONTEXTSNAPSHOTSTATUS, "CHarvesterAO::ContextSnapshotStatus" );
 HarvestCompleted( aHD->ClientId(), aHD->Uri(), aHD->ErrorCode() );
 const TInt errorCode = aHD->ErrorCode();
 if( errorCode != KErrNone && errorCode != KErrCompletion )
 	{
 WRITELOG1( "CHarvesterAO::ContextSnapshotStatus() - error occurred: %d", errorCode );
+OstTrace1( TRACE_NORMAL, DUP1_CHARVESTERAO_CONTEXTSNAPSHOTSTATUS, "CHarvesterAO::ContextSnapshotStatus - error occurred: %d", errorCode );
 	}
 else
 	{
 if( errorCode == KErrCompletion )
 {
 WRITELOG( "CHarvesterAO::ContextSnapshotStatus() - snapshot could not be completed" );
+OstTrace0( TRACE_NORMAL, DUP2_CHARVESTERAO_CONTEXTSNAPSHOTSTATUS, "CHarvesterAO::ContextSnapshotStatus - snapshot could not be completed" );
 WRITELOG( "CHarvesterAO::ContextSnapshotStatus() - processing non-context data anyway" );
+OstTrace0( TRACE_NORMAL, DUP3_CHARVESTERAO_CONTEXTSNAPSHOTSTATUS, "CHarvesterAO::ContextSnapshotStatus - processing non-context data anyway" );
 }
 else
 {
 WRITELOG( "CHarvesterAO::ContextSnapshotStatus() - successfully completed" );
+OstTrace0( TRACE_NORMAL, DUP4_CHARVESTERAO_CONTEXTSNAPSHOTSTATUS, "CHarvesterAO::ContextSnapshotStatus - successfully completed" );
 }
 if( aHD->Origin() == MdeConstants::Object::ECamera )
 	{
 aHD->MdeObject().SetPlaceholder( EFalse );
 TRAP_IGNORE( iHarvesterEventManager->DecreaseItemCountL( EHEObserverTypePlaceholder ) );
 	if(mdeError != KErrNone)
 	{
 	WRITELOG( "==============================ERROR===============================" );
 WRITELOG( "CHarvesterAO::HarvestingCompleted() - cannot set metadata object" );
 WRITELOG( "==============================ERROR done =========================" );
+OstTrace0( TRACE_NORMAL, DUP5_CHARVESTERAO_CONTEXTSNAPSHOTSTATUS, "CHarvesterAO::ContextSnapshotStatus - cannot set metadata object" );
 	}
 	}
 	}
 delete aHD;
 {
 RMessage2& msg = iHarvestFileMessages[i].iMessage;
 if ( aClientId == msg.Identity() )
 {
 WRITELOG1( "CHarvesterAO::HarvestingCompleted() - Completing Fast Harvest request! Error code: %d", aErr );
+OstTrace1( TRACE_NORMAL, CHARVESTERAO_HARVESTCOMPLETED, "CHarvesterAO::HarvestCompleted - Completing Fast Harvest request! Error code: %d", aErr );
 if (!msg.IsNull())
 	{
 	msg.Write( KParamUri, aUri );
 	msg.Complete( aErr );
 	}
 else
 	{
 	WRITELOG("CHarvesterAO::HarvestingCompleted() NOT COMPLETING AS msg->iMessage->IsNull returns ETrue");
+	OstTrace0( TRACE_NORMAL, DUP1_CHARVESTERAO_HARVESTCOMPLETED, "CHarvesterAO::HarvestCompleted NOT COMPLETING AS msg->iMessage->IsNull returns ETrue" );
 	}
 iHarvestFileMessages.Remove( i );
 if( iHarvestFileMessages.Count() == 0 )
 {
 iHarvestFileMessages.Compress();
 	}
 void CHarvesterAO::BootRomScanL()
 	{
 	WRITELOG("CHarvesterAO::BootRomScanL()");
+OstTrace0( TRACE_NORMAL, CHARVESTERAO_BOOTROMSCANL, "CHarvesterAO::BootRomScanL" );
 if( !iMdeSessionInitialized )
 {
 return;
 }
 	    }
 	iMdEHarvesterSession->ChangeCDriveMediaId();
 	WRITELOG("CHarvesterAO::BootPartialRestoreScanL() - partial restore");
+OstTrace0( TRACE_NORMAL, CHARVESTERAO_BOOTPARTIALRESTORESCANL, "CHarvesterAO::BootPartialRestoreScanL - partial restore" );
 	RPointerArray<TScanItem> scanItems;
 	TCleanupItem cleanupItem( MdsUtils::CleanupPtrArray<TScanItem>, &scanItems );
 CleanupStack::PushL( cleanupItem );
 	CHarvesterCenRepUtil::GetPartialRestorePathsL( scanItems );
 	CHarvesterCenRepUtil::GetIgnoredPartialRestorePathsL( ignorePaths );
 	BootScanL( scanItems, ignorePaths, EFalse );
 	WRITELOG("CHarvesterAO::BootPartialRestoreScanL() - iRestoreWatcher->UnregisterL()");
+	OstTrace0( TRACE_NORMAL, DUP1_CHARVESTERAO_BOOTPARTIALRESTORESCANL, "CHarvesterAO::BootPartialRestoreScanL - iRestoreWatcher->UnregisterL()" );
 	iRestoreWatcher->UnregisterL();
 	CleanupStack::PopAndDestroy( &ignorePaths );
 	CleanupStack::PopAndDestroy( &scanItems );
 	}
 void CHarvesterAO::BootScanL( RPointerArray<TScanItem>& aScanItems,
 		const RPointerArray<HBufC>& aIgnorePaths,
 TBool aCheckDrive )
 	{
 	WRITELOG("CHarvesterAO::BootScanL() - begin");
+OstTrace0( TRACE_NORMAL, CHARVESTERAO_BOOTSCANL, "CHarvesterAO::BootScanL - begin" );
 TInt drive( -1 );
 TInt massStorageError( DriveInfo::GetDefaultDrive( DriveInfo::EDefaultMassStorage, drive ) );
 if( massStorageError == KErrNone )
 {
 TVolumeInfo massStorageVolumeInfo;
 	_LIT( KDirectorySeparator, "\\" );
 #ifdef _DEBUG
 	WRITELOG1("CHarvesterAO::BootScanL() - item count: %d", aScanItems.Count() );
+	OstTrace1( TRACE_NORMAL, DUP1_CHARVESTERAO_BOOTSCANL, "CHarvesterAO::BootScanL - item count: %d", aScanItems.Count() );
 #endif
 	RPointerArray<CHarvesterData> hdArray;
 	CleanupClosePushL( hdArray );
 	TBool rootDir( ETrue );
 						path.Set( (*name).Mid( 2 ) );
 						}
 					if( !IsDescInArray( path, aIgnorePaths ) )
 						{
 						WRITELOG("CHarvesterAO::BootScanL() - scanFolders.AppendL");
+						OstTrace0( TRACE_NORMAL, DUP2_CHARVESTERAO_BOOTSCANL, "CHarvesterAO::BootScanL - scanFolders.AppendL" );
 						TScanItem* item = new (ELeave) TScanItem();
 						item->iPath = name->AllocL();
 						item->iPreinstalled = MdeConstants::MediaObject::ENotPreinstalled;
 						aScanItems.AppendL( item );
 						}
 						filename.Set( (*name).Mid( 2 ) );
 						}
 					if( !IsDescInArray( filename, aIgnorePaths ) )
 						{
 						WRITELOG("CHarvesterAO::BootScanL() - check files");
+						OstTrace0( TRACE_NORMAL, DUP3_CHARVESTERAO_BOOTSCANL, "CHarvesterAO::BootScanL - check files" );
 					    RArray<TPtrC> uris;
 					    RArray<TMdSFileInfo> fileInfos;
 					    RArray<TFilePresentStates> results;
 					    CleanupClosePushL( uris );
 		delete aScanItems[0];
 		aScanItems.Remove( 0 );
 		}
 	WRITELOG("CHarvesterAO::BootScanL() - iQueue->Append");
+	OstTrace0( TRACE_NORMAL, DUP4_CHARVESTERAO_BOOTSCANL, "CHarvesterAO::BootScanL - iQueue->Append" );
 	iQueue->MonitorEvent( hdArray );
 	CleanupStack::PopAndDestroy( &hdArray );
 	iMdEHarvesterSession->RemoveFilesNotPresent( volumeInfo.iUniqueID, ETrue );
 	iMassMemoryIdChecked = ETrue;
 	WRITELOG("CHarvesterAO::BootScanL() - end");
+	OstTrace0( TRACE_NORMAL, DUP5_CHARVESTERAO_BOOTSCANL, "CHarvesterAO::BootScanL - end" );
 	}
 void CHarvesterAO::SetHarvesterStatusObserver( MHarvesterStatusObserver* aObserver )
 	{
 	iHarvesterStatusObserver = aObserver;
 }
 void CHarvesterAO::MemoryLow()
 	{
 WRITELOG("CHarvesterAO::MemoryLow()");
+OstTrace0( TRACE_NORMAL, CHARVESTERAO_MEMORYLOW, "CHarvesterAO::MemoryLow" );
 iRamFull = ETrue;
 if( iServerPaused )
 {
 return;
 	}
 void CHarvesterAO::MemoryGood()
 	{
 WRITELOG("CHarvesterAO::MemoryGood()");
+OstTrace0( TRACE_NORMAL, CHARVESTERAO_MEMORYGOOD, "CHarvesterAO::MemoryGood" );
 iRamFull = EFalse;
 if( !iDiskFull && !iManualPauseEnabled && iServerPaused )
 {
 // resume monitoring

branch	RCL_3
changeset 46	63c982fb92f2
parent 34	9422ed56ee45
child 47	b73252188534