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

equal deleted inserted replaced

-:2872ae438bf7
+:e538444823de
 #include <e32svr.h>
 #include <caf/caf.h>
 #include <driveinfo.h>
+#include <rlocationobjectmanipulator.h>
 #include <placeholderdata.h>
 #include <harvesterclientdata.h>
 #include <pathinfo.h>
 using namespace ContentAccess;
 // constants
 const TInt32 KFileMonitorPluginUid = 0x20007186;  // file monitor plugin implementation uid
 const TInt KPlaceholderQueueSize = 99;
 const TInt KContainerPlaceholderQueueSize = 10;
-const TInt KReadyPlaceholderQueueSize = 10;
 const TInt KObjectDefStrSize = 20;
 _LIT( KTAGDaemonName, "ThumbAGDaemon" );
 _LIT( KTAGDaemonExe, "thumbagdaemon.exe" );
 _LIT(KVideo, "Video");
 _LIT(KInUse, "InUse");
-_LIT(KUndefined, " ");
+_LIT(KUndefinedMime, " ");
 _LIT( KExtensionMp4,   "mp4" );
 _LIT( KExtensionMpg4,  "mpg4" );
 _LIT( KExtensionMpeg4, "mpeg4" );
 _LIT( KExtension3gp,   "3gp" );
 	{
 	}
 void CHarvesterAoPropertyDefs::ConstructL(CMdEObjectDef& aObjectDef)
 	{
-SetByObjectDefL( aObjectDef );
+	CMdENamespaceDef& nsDef = aObjectDef.NamespaceDef();
+	// Common property definitions
+	CMdEObjectDef& objectDef = nsDef.GetObjectDefL( MdeConstants::Object::KBaseObject );
+	iCreationDatePropertyDef = &objectDef.GetPropertyDefL( MdeConstants::Object::KCreationDateProperty );
+	iLastModifiedDatePropertyDef = &objectDef.GetPropertyDefL( MdeConstants::Object::KLastModifiedDateProperty );
+	iSizePropertyDef = &objectDef.GetPropertyDefL( MdeConstants::Object::KSizeProperty );
+	iOriginPropertyDef = &objectDef.GetPropertyDefL( MdeConstants::Object::KOriginProperty );
+	iItemTypePropertyDef = &objectDef.GetPropertyDefL( MdeConstants::Object::KItemTypeProperty );
+	iTitlePropertyDef = &objectDef.GetPropertyDefL( MdeConstants::Object::KTitleProperty );
+	iDefaultFolderPropertyDef = &objectDef.GetPropertyDefL( MdeConstants::Object::KInDefaultFolder );
+	CMdEObjectDef& mediaDef = nsDef.GetObjectDefL( MdeConstants::MediaObject::KMediaObject );
+	iPreinstalledPropertyDef = &mediaDef.GetPropertyDefL( MdeConstants::MediaObject::KPreinstalledProperty );
 	}
-CHarvesterAoPropertyDefs* CHarvesterAoPropertyDefs::NewL()
+CHarvesterAoPropertyDefs* CHarvesterAoPropertyDefs::NewL(CMdEObjectDef& aObjectDef)
-{
+	{
-CHarvesterAoPropertyDefs* self =
+	CHarvesterAoPropertyDefs* self =
-new (ELeave) CHarvesterAoPropertyDefs();
+		new (ELeave) CHarvesterAoPropertyDefs();
-return self;
+	CleanupStack::PushL( self );
-}
+	self->ConstructL( aObjectDef );
+	CleanupStack::Pop( self );
-void CHarvesterAoPropertyDefs::SetByObjectDefL(CMdEObjectDef& aObjectDef)
+	return self;
-{
+	}
-CMdENamespaceDef& nsDef = aObjectDef.NamespaceDef();
-// Common property definitions
-CMdEObjectDef& objectDef = nsDef.GetObjectDefL( MdeConstants::Object::KBaseObject );
-iCreationDatePropertyDef = &objectDef.GetPropertyDefL( MdeConstants::Object::KCreationDateProperty );
-iLastModifiedDatePropertyDef = &objectDef.GetPropertyDefL( MdeConstants::Object::KLastModifiedDateProperty );
-iSizePropertyDef = &objectDef.GetPropertyDefL( MdeConstants::Object::KSizeProperty );
-iOriginPropertyDef = &objectDef.GetPropertyDefL( MdeConstants::Object::KOriginProperty );
-iItemTypePropertyDef = &objectDef.GetPropertyDefL( MdeConstants::Object::KItemTypeProperty );
-iTitlePropertyDef = &objectDef.GetPropertyDefL( MdeConstants::Object::KTitleProperty );
-iDefaultFolderPropertyDef = &objectDef.GetPropertyDefL( MdeConstants::Object::KInDefaultFolder );
-CMdEObjectDef& mediaDef = nsDef.GetObjectDefL( MdeConstants::MediaObject::KMediaObject );
-iPreinstalledPropertyDef = &mediaDef.GetPropertyDefL( MdeConstants::MediaObject::KPreinstalledProperty );
-}
 // ---------------------------------------------------------------------------
 // NewLC
 // ---------------------------------------------------------------------------
 //
 CHarvesterAO* CHarvesterAO::NewLC()
 iManualPauseEnabled = EFalse;
 iFastHarvestNeeded = EFalse;
 iHarvestingPlaceholders = EFalse;
 iUnmountDetected = EFalse;
-iUnmountHandlingOngoing = EFalse;
 iPriorityInterruptDetected = EFalse;
-iLocManipulatorConnected = EFalse;
 }
 // ---------------------------------------------------------------------------
 // ~CHarvesterAO
 // ---------------------------------------------------------------------------
 OstTrace0( TRACE_NORMAL, DUP1_CHARVESTERAO_CHARVESTERAO, "CHarvesterAO::~CHarvesterAO" );
 Cancel();
 	iFs.Close();
-	iLocManipulator.Close();
 	if (iCtxEngine)
 		{
 		iCtxEngine->ReleaseInstance();
 		}
 StopComposers();
 DeleteComposers();
 delete iDiskFullNotifier;
-iDiskFullNotifier = NULL;
 	delete iBackupSubscriber;
-	iBackupSubscriber = NULL;
 if (iBlacklist)
 		{
 		iBlacklist->CloseDatabase();
 		delete iBlacklist;
-		iBlacklist = NULL;
 		}
 	delete iReHarvester;
-	iReHarvester = NULL;
 if ( iHarvestFileMessages.Count() > 0 )
 {
 for ( TInt i = iHarvestFileMessages.Count()-1; i >= 0; --i )
 {
 iTempReadyPHArray.ResetAndDestroy();
 iTempReadyPHArray.Close();
 	delete iHarvesterOomAO;
-	iHarvesterOomAO = NULL;
 delete iRestoreWatcher;
-iRestoreWatcher = NULL;
 	delete iOnDemandAO;
-	iOnDemandAO = NULL;
 	delete iMdEHarvesterSession;
-	iMdEHarvesterSession = NULL;
 	delete iMdESession;
-	iMdESession = NULL;
 	delete iQueue;
-	iQueue = NULL;
 	delete iHarvesterPluginFactory;
-	iHarvesterPluginFactory = NULL;
 	delete iMdeObjectHandler;
-	iMdeObjectHandler = NULL;
 	delete iUnmountHandlerAO;
-	iUnmountHandlerAO = NULL;
 	delete iPropDefs;
-	iPropDefs = NULL;
 	delete iCameraExtensionArray;
-	iCameraExtensionArray = NULL;
 delete iPhoneImagesPath;
-iPhoneImagesPath = NULL;
 delete iMmcImagesPath;
-iMmcImagesPath = NULL;
 delete iPhoneVideosPath;
-iPhoneVideosPath = NULL;
 delete iMmcVideosPath;
-iMmcVideosPath = NULL;
 delete iPhoneSoundsPath;
-iPhoneSoundsPath = NULL;
 delete iMmcSoundsPath;
-iMmcSoundsPath = NULL;
 	RMediaIdUtil::ReleaseInstance();
 REComSession::FinalClose();
 }
 iHarvesterPluginFactory->SetBlacklist( *iBlacklist );
 // Reset harvesting status for clients in case blacklisted file was handled
 iHarvesterPluginFactory->SendHarvestingStatusEventL( EFalse );
-iPropDefs = CHarvesterAoPropertyDefs::NewL();
 iCameraExtensionArray = new ( ELeave ) CDesCArraySeg( 6 );
 iCameraExtensionArray->InsertIsqL( KExtensionMp4 );
 iCameraExtensionArray->InsertIsqL( KExtensionMpg4 );
 iCameraExtensionArray->InsertIsqL( KExtensionMpeg4 );
 iCameraExtensionArray->InsertIsqL( KExtension3gp );
 TCleanupItem cleanupItem( MdsUtils::CleanupEComArray, &infoArray );
 CleanupStack::PushL( cleanupItem );
 CMonitorPlugin::ListImplementationsL( infoArray );
-const TInt count( infoArray.Count() );
+TInt count( 0 );
+count = infoArray.Count();
 CMonitorPlugin* plugin = NULL;
 for ( TInt i = 0; i < count; i++ )
 {
 TUid uid = infoArray[i]->ImplementationUid();    // Create the plug-ins
 //
 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" );
-for( TInt i = iMonitorPluginArray.Count() - 1; i >=0; i-- )
+const TInt count( iMonitorPluginArray.Count() );
+for ( TInt i = 0; i < count; i++ )
 {
 iMonitorPluginArray[i]->StopMonitoring();
 }
 }
 void CHarvesterAO::PauseMonitoring()
 {
 WRITELOG( "CHarvesterAO::PauseMonitoring()" );
 OstTrace0( TRACE_NORMAL, CHARVESTERAO_PAUSEMONITORING, "CHarvesterAO::PauseMonitoring" );
-for( TInt i = iMonitorPluginArray.Count() - 1; i >=0; i-- )
+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" );
 }
 // ---------------------------------------------------------------------------
 	{
 WRITELOG1( "CHarvesterAO::HandleUnmount(%d)", aMediaId );
 	OstTrace1( TRACE_NORMAL, CHARVESTERAO_HANDLEUNMOUNT, "CHarvesterAO::HandleUnmount;aMediaId=%d", aMediaId );
 iUnmountDetected = ETrue;
-iUnmountHandlingOngoing = ETrue;
 if( !iServerPaused )
 {
 // Stop harvesting for unmount
 PauseMonitoring();
 		}
 iMediaIdUtil->RemoveMediaId( aMediaId );
 	// resume harvesting from last state
-iUnmountHandlingOngoing = EFalse;
+if( !iRamFull && !iDiskFull )
-// resume monitoring
+{
-ResumeMonitoring();
+// resume monitoring
-TRAP_IGNORE( ResumeHarvesterL() );
+ResumeMonitoring();
+TRAP_IGNORE( ResumeHarvesterL() );
+}
 	}
 // ---------------------------------------------------------------------------
 // StartComposersL
 // ---------------------------------------------------------------------------
 iHarvestingPlaceholders = ETrue;
 if( !iFastHarvestNeeded )
 {
 SetPriority( KHarvesterCustomImportantPriority );
 }
-	while( hd &&
+	while( hd != NULL &&
-			   iPHArray.Count() < KPlaceholderQueueSize &&
+				iPHArray.Count() < KPlaceholderQueueSize &&
-			   hd->ObjectType() == EPlaceholder )
+				hd->ObjectType() == EPlaceholder )
 		{
-	if(iPHArray.Append( hd ) != KErrNone)
+	iPHArray.Append( hd );
+	if( hd->Origin() == MdeConstants::Object::ECamera ||
+	    hd->ObjectType() == EFastHarvest  )
 	    {
-	    HarvestCompleted( hd->ClientId(), hd->Uri(), KErrNoMemory );
+	    if( !iFastHarvestNeeded )
-	    iHarvesterEventManager->DecreaseItemCountL( EHEObserverTypeMMC, 1 );
+	        {
-delete hd;
+iFastHarvestNeeded = ETrue;
-hd = NULL;
+// Fast harvest event must be handled even if MMC handling would be ongoing
+SetPriority( KHarvesterPriorityMonitorPlugin );
+	        }
+	    break;
 	    }
-	else
+	else if( iFastHarvestNeeded )
 	    {
-if( hd->Origin() == MdeConstants::Object::ECamera ||
+	    iFastHarvestNeeded = EFalse;
-hd->ObjectType() == EFastHarvest  )
+	    SetPriority( KHarvesterCustomImportantPriority );
-{
-if( !iFastHarvestNeeded )
-{
-iFastHarvestNeeded = ETrue;
-// Fast harvest event must be handled even if MMC handling would be ongoing
-SetPriority( KHarvesterPriorityMonitorPlugin );
-}
-break;
-}
-else if( iFastHarvestNeeded )
-{
-iFastHarvestNeeded = EFalse;
-SetPriority( KHarvesterCustomImportantPriority );
-	    	}
 	    }
 	hd = iQueue->GetNextItem();
 		}
 	if( iFastHarvestNeeded && iPHArray.Count() > 0 )
 	    {
 TRAPD( err, HandlePlaceholdersL( ETrue ) );
-// make sure that when HandlePlaceholdersL leaves unexpectedly, iPHArray is cleared
+// make sure that when HandlePlaceholdersL leaves, iPHArray is cleared
 if ( err != KErrNone )
 {
-if( err != KErrDiskFull )
+iPHArray.ResetAndDestroy();
-{
+iTempReadyPHArray.ResetAndDestroy();
-iPHArray.ResetAndDestroy();
-iTempReadyPHArray.ResetAndDestroy();
-}
 User::Leave( err );
 }
 TInt count( iReadyPHArray.Count() );
 for( TInt i = 0; i < count; i++ )
 		if( hd )
 		{
 	    	if( hd->ObjectType() == EPlaceholder )
 	    		{
-	        	if( iPHArray.Append( hd ) != KErrNone )
+	        	iPHArray.Append( hd );
-	        	    {
-	        	    HarvestCompleted( hd->ClientId(), hd->Uri(), KErrNoMemory );
-	        	    iHarvesterEventManager->DecreaseItemCountL( EHEObserverTypeMMC, 1 );
-delete hd;
-hd = NULL;
-	        	    }
 	    		}
 	    	else
 	    		{
-if( iReadyPHArray.Append( hd ) != KErrNone)
+	    		CheckFileExtensionAndHarvestL( hd );
-{
+	    		if( iUnmountDetected )
-delete hd;
+	    		    {
-hd = NULL;
+	    		    iQueue->Append( hd );
-}
+	    		    return;
+	    		    }
 	    		}
 		}
 	if( iPHArray.Count() > 0 )
 		{
 	    	TRAPD( err, HandlePlaceholdersL( ETrue ) );
-	    	// make sure that when HandlePlaceholdersL leaves unexpectedly, iPHArray is cleared
+	    	// make sure that when HandlePlaceholdersL leaves, iPHArray is cleared
 	    	if ( err != KErrNone )
 	    		{
-	    	    if( err != KErrDiskFull )
+	    		iPHArray.ResetAndDestroy();
-	    	        {
+	    		iTempReadyPHArray.ResetAndDestroy();
-	    	        iPHArray.ResetAndDestroy();
-	    	        iTempReadyPHArray.ResetAndDestroy();
-	    	        }
 	    		User::Leave( err );
 	    		}
 		}
 	}
 else
 {
 SetPriority( KHarvesterPriorityHarvestingPlugin );
 }
 iHarvestingPlaceholders = EFalse;
 CheckFileExtensionAndHarvestL( hd );
-if( iUnmountDetected && hd )
+if( iUnmountDetected )
 {
 iQueue->Append( hd );
 }
 	}
 }
 	RPointerArray<CMdEObject> mdeObjectArray;
 	CleanupClosePushL( mdeObjectArray );
 	TTimeIntervalSeconds timeOffsetSeconds = User::UTCOffset();
-	CMdENamespaceDef& defNS = iMdESession->GetDefaultNamespaceDefL();
 	TInt endindex( iPHArray.Count() );
 	for( TInt i = 0; i < endindex; i++ )
 		{
 		CHarvesterData* hd = iPHArray[i];
-		if( aCheck &&
+		if( aCheck && iHarvesterPluginFactory->IsContainerFileL( hd->Uri() ) )
-		    hd->Origin() != MdeConstants::Object::ECamera &&
-		    iHarvesterPluginFactory->IsContainerFileL( hd->Uri() ) )
 			{
-			if( iContainerPHArray.Append( hd ) != KErrNone )
+			iContainerPHArray.Append( hd );
-			    {
-			    HarvestCompleted( hd->ClientId(), hd->Uri(), KErrNoMemory );
-			    iHarvesterEventManager->DecreaseItemCountL( EHEObserverTypeMMC, 1 );
-delete hd;
-hd = NULL;
-			    }
 			iPHArray.Remove( i );
-			i--;
+i--;
-			endindex--;
+endindex--;
 			continue;
 			}
 		TBuf<KObjectDefStrSize> objDefStr;
 		if( !CheckForCameraItem( hd, objDefStr ) )
 		    {
-		    iHarvesterPluginFactory->GetObjectDefL( hd, objDefStr );
+		    iHarvesterPluginFactory->GetObjectDefL( *hd, objDefStr );
 		    }
 		// GetObjectDef can cause context switch, and if unmount happens when this execution is
 		// interrupted, the ph arrays can be invalid. Thus, abort whole run, and start over to make sure
 		// the arrays are valid.
 		if( iUnmountDetected )
 		    {
 		    WRITELOG( "CHarvesterAO::HandlePlaceholdersL() - Unmount detected during execution!" );
 		    for( TInt y( iTempReadyPHArray.Count() -1 ); y >=0; y-- )
 		        {
-		        CHarvesterData* tempHd = iTempReadyPHArray[y];
+		        CHarvesterData* hd = iTempReadyPHArray[y];
+		        iPHArray.Insert( hd, 0 );
-		        if(iPHArray.Insert( tempHd, 0 ) != KErrNone)
-		            {
-		            HarvestCompleted( tempHd->ClientId(), tempHd->Uri(), KErrNoMemory );
-		            iHarvesterEventManager->DecreaseItemCountL( EHEObserverTypeMMC, 1 );
-delete tempHd;
-tempHd = NULL;
-		            }
 		        }
 		    iTempReadyPHArray.Reset();
 		    CleanupStack::PopAndDestroy( &mdeObjectArray );
 		    return;
 		    }
 		    {
 WRITELOG( "CHarvesterAO::HandlePlaceholdersL() - Priority interrupt during execution!" );
 const TInt currentPHArrayCount( iPHArray.Count() );
 for( TInt y( iTempReadyPHArray.Count() -1 ); y >=0; y-- )
 {
-CHarvesterData* tempHd = iTempReadyPHArray[y];
+CHarvesterData* hd = iTempReadyPHArray[y];
-if(iPHArray.Insert( tempHd, 0 ) != KErrNone)
+if( currentPHArrayCount )
 {
-HarvestCompleted( tempHd->ClientId(), tempHd->Uri(), KErrNoMemory );
+// Leave the first item in the array as it is the priority item
-iHarvesterEventManager->DecreaseItemCountL( EHEObserverTypeMMC, 1 );
+iPHArray.Insert( hd, 1 );
-delete tempHd;
+}
-tempHd = NULL;
+else
+{
+iPHArray.Insert( hd, 0 );
 }
 }
 iTempReadyPHArray.Reset();
 CleanupStack::PopAndDestroy( &mdeObjectArray );
 return;
 		    }
-	    // Check if disk is full
-	    // If disk is detected to be full, no items can be added to MDS db, thus abort the run, and start over
-		// when disk space is available to make sure the arrays are valid.
-		else if( iDiskFull )
-		    {
-WRITELOG( "CHarvesterAO::HandlePlaceholdersL() - No disk space available!" );
-for( TInt y( iTempReadyPHArray.Count() -1 ); y >=0; y-- )
-{
-CHarvesterData* tempHd = iTempReadyPHArray[y];
-if(iPHArray.Insert( tempHd, 0 ) != KErrNone)
-{
-HarvestCompleted( tempHd->ClientId(), tempHd->Uri(), KErrNoMemory );
-iHarvesterEventManager->DecreaseItemCountL( EHEObserverTypeMMC, 1 );
-delete tempHd;
-tempHd = NULL;
-}
-}
-iTempReadyPHArray.Reset();
-CleanupStack::PopAndDestroy( &mdeObjectArray );
-User::Leave( KErrDiskFull );
-		    }
 		if( objDefStr.Length() == 0 ||
 		    ( objDefStr == KInUse ) )
 			{
-#ifdef _DEBUG
+		    WRITELOG( "CHarvesterAO::HandlePlaceholdersL() - no objectDef or in use, failing harvesting" );
-		    if( objDefStr.Length() == 0 )
-		        {
-		        WRITELOG( "CHarvesterAO::HandlePlaceholdersL() - no objectDef failing harvesting" );
-		        }
-		    else
-		        {
-		        WRITELOG( "CHarvesterAO::HandlePlaceholdersL() - in use, failing harvesting" );
-		        }
-		    WRITELOG1( "CHarvesterAO::HandlePlaceholdersL() - harvesting failed, uri: %S", &(hd->Uri()) );
-#endif
-		    // If object has not been created in the device so that monitors would have
-		    // picked up creation event, and the file is in use, subclose event will
-		    // not trigger the file to be harvester when closed, thus it needs to be moved
-		    // to reharvesting queue
-		    if( objDefStr == KInUse &&
-		        !hd->TakeSnapshot() )
-		        {
-		        iPHArray.Remove( i );
-		        i--;
-		        endindex--;
-		        iReHarvester->AddItem( hd );
-		        continue;
-		        }
 			const TInt error( KErrUnknown );
 // notify observer, notification is needed even if file is not supported
 HarvestCompleted( hd->ClientId(), hd->Uri(), error );
 			delete hd;
 			hd = NULL;
 endindex--;
 			iHarvesterEventManager->DecreaseItemCountL( EHEObserverTypeMMC, 1 );
 			continue;
 			}
+		CMdENamespaceDef& defNS = iMdESession->GetDefaultNamespaceDefL();
 		CMdEObjectDef& mdeObjectDef = defNS.GetObjectDefL( objDefStr );
-		HBufC* hdUri = hd->Uri().AllocL();
+		CMdEObject* mdeObject = iMdESession->NewObjectL( mdeObjectDef, hd->Uri() );
-		CleanupStack::PushL( hdUri );
-		CMdEObject* mdeObject = iMdESession->NewObjectL( mdeObjectDef, *hdUri );
-		CleanupStack::PopAndDestroy( hdUri );
 		CleanupStack::PushL( mdeObject );
 		CPlaceholderData* phData = NULL;
 		if( hd->TakeSnapshot() )
 		mdeObject->SetMediaId( phData->MediaId() );
 	    // set placeholder
 	    mdeObject->SetPlaceholder( ETrue );
-	    if( !iPropDefs->iCreationDatePropertyDef )
+	    if( !iPropDefs )
-	        {
+	    	{
-iPropDefs->SetByObjectDefL( defNS.GetObjectDefL( MdeConstants::Object::KBaseObject ) );
+	    	iPropDefs = CHarvesterAoPropertyDefs::NewL( defNS.GetObjectDefL( MdeConstants::Object::KBaseObject ) );
-	        }
+	    	}
 	    // set file size
 	mdeObject->AddUint32PropertyL( *iPropDefs->iSizePropertyDef, phData->FileSize() );
 	    // set creation date
 {
 mdeObject->AddTextPropertyL( *iPropDefs->iItemTypePropertyDef, mimeType );
 }
 else
 {
-mdeObject->AddTextPropertyL( *iPropDefs->iItemTypePropertyDef, KUndefined );
+mdeObject->AddTextPropertyL( *iPropDefs->iItemTypePropertyDef, KUndefinedMime );
 }
 if( hd->Origin() == MdeConstants::Object::ECamera )
 {
 TBool inDefaultFolder( ETrue );
 	        {
 	        mdeObject->AddTextPropertyL( *iPropDefs->iTitlePropertyDef, name );
 	        }
 	    else
 	        {
-	        mdeObject->AddTextPropertyL( *iPropDefs->iTitlePropertyDef, KUndefined );
+	        mdeObject->AddTextPropertyL( *iPropDefs->iTitlePropertyDef, KNullDesC );
 	        }
 	CPlaceholderData* ph = NULL;
 	if( hd->TakeSnapshot() )
 	    {
 	    CleanupStack::PopAndDestroy( phData );
 	    CleanupStack::Pop( mdeObject );
-	    if(iTempReadyPHArray.Append( hd ) != KErrNone)
+	    iTempReadyPHArray.Append( hd );
-	        {
-	        HarvestCompleted( hd->ClientId(), hd->Uri(), KErrNoMemory );
-delete hd;
-hd = NULL;
-	        }
 		iPHArray.Remove( i );
 i--;
 endindex--;
 		}
+	const TInt tempArrayCount( iTempReadyPHArray.Count() );
+	for( TInt i( 0 ); i < tempArrayCount; i++ )
+	    {
+	    CHarvesterData* hd = iTempReadyPHArray[i];
+	    iReadyPHArray.Append( hd );
+	    }
+	iTempReadyPHArray.Reset();
 	const TInt objectCount = mdeObjectArray.Count();
 if( objectCount > 0 )
 		{
 		// add object to mde
 		iMdEHarvesterSession->AutoLockL( mdeObjectArray );
-		TInt addError( KErrNone );
+		const TInt addError( iMdESession->AddObjectsL( mdeObjectArray ) );
-		TRAPD( addFailure, addError = iMdESession->AddObjectsL( mdeObjectArray ) );
-		if( addFailure == KErrDiskFull )
-		    {
-WRITELOG( "CHarvesterAO::HandlePlaceholdersL() - No disk space available!" );
-for( TInt y( iTempReadyPHArray.Count() -1 ); y >=0; y-- )
-{
-CHarvesterData* tempHd = iTempReadyPHArray[y];
-if(iPHArray.Insert( tempHd, 0 ) != KErrNone)
-{
-HarvestCompleted( tempHd->ClientId(), tempHd->Uri(), KErrNoMemory );
-iHarvesterEventManager->DecreaseItemCountL( EHEObserverTypeMMC, 1 );
-delete tempHd;
-tempHd = NULL;
-}
-}
-iTempReadyPHArray.Reset();
-CleanupStack::PopAndDestroy( &mdeObjectArray );
-User::Leave( KErrDiskFull );
-		    }
-		else if( addFailure != KErrNone )
-		    {
-		    User::Leave( addFailure );
-		    }
 		if( addError != KErrNone )
 		    {
 		    // If some error occures, retry
 		    iMdESession->AddObjectsL( mdeObjectArray );
 		    }
-	    const TInt tempArrayCount( iTempReadyPHArray.Count() );
-	    for( TInt i( 0 ); i < tempArrayCount; i++ )
-	        {
-	        CHarvesterData* tempHd = iTempReadyPHArray[i];
-if(iReadyPHArray.Append( tempHd ) != KErrNone)
-{
-HarvestCompleted( tempHd->ClientId(), tempHd->Uri(), KErrNoMemory );
-delete tempHd;
-tempHd = NULL;
-}
-	        }
-	    iTempReadyPHArray.Reset();
 	    iHarvesterEventManager->IncreaseItemCount( EHEObserverTypePlaceholder,
 		        objectCount );
 		iHarvesterEventManager->SendEventL( EHEObserverTypePlaceholder, EHEStateStarted,
 				iHarvesterEventManager->ItemCount( EHEObserverTypePlaceholder ) );
 TBool isError = EFalse;
 CMdEObject* mdeObject = &aHD->MdeObject();
 const TDesC& uri = aHD->Uri();
 TBool objectExisted = ETrue;
-if( !mdeObject )
+if( ! mdeObject )
 	{
 	objectExisted = EFalse;
 	WRITELOG1( "CHarvesterAO::CheckFileExtensionAndHarvestL() - no mdeobject. URI: %S", &uri );
 	    TBuf<KObjectDefStrSize> objDefStr;
-		iHarvesterPluginFactory->GetObjectDefL( aHD, objDefStr );
+		iHarvesterPluginFactory->GetObjectDefL( *aHD, objDefStr );
 // GetObjectDef can cause context switch, and if unmount happens when this execution is
 // interrupted, the ph data can be invalid. Thus, abort whole run, and start over to make sure
 // the data is valid.
-if( !aHD )
+if( iUnmountDetected )
 {
 return;
 }
 		if( objDefStr.Length() == 0 )
 if( objectExisted && aHD->EventType() == EHarvesterAdd )
 	{
 	iMdESession->RemoveObjectL( aHD->Uri() );
 	}
-// If context swich occures just right due to RemoveObjectL, check aHD for validity
-if( !aHD )
-{
-return;
-}
 	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 );
 	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
 // ---------------------------------------------------------------------------
 	        	if( locData )
 	        		{
 	        		WRITELOG( "CHarvesterAO::HarvestingCompleted() - Creating location object. " );
 	        		OstTrace0( TRACE_NORMAL, DUP6_CHARVESTERAO_HARVESTINGCOMPLETED, "CHarvesterAO::HarvestingCompleted - Creating location object." );
-	        		TInt loError( KErrNone );
+	        		RLocationObjectManipulator lo;
-	        		if( !iLocManipulatorConnected )
-	        		    {
+	        		const TInt loError = lo.Connect();
-	        		    loError = iLocManipulator.Connect();
-	        		    if( loError == KErrNone )
-	        		        {
-	        		        iLocManipulatorConnected = ETrue;
-	        		        }
-	        		    }
 	        		if (loError == KErrNone)
 	        			{
-	        			TInt err = iLocManipulator.CreateLocationObject( *locData, aHD->MdeObject().Id() );
+	        			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!!!" );
-	        				iLocManipulator.Close();
-	        				iLocManipulatorConnected = EFalse;
 	        				}
 	        			}
 	        		else
 	        			{
 	        			WRITELOG( "CHarvesterAO::HarvestingCompleted() - LocationObjectManipulator connect failed!!!" );
 	        			OstTrace0( TRACE_NORMAL, DUP8_CHARVESTERAO_HARVESTINGCOMPLETED, "CHarvesterAO::HarvestingCompleted - LocationObjectManipulator connect failed!!" );
 	        			}
+	        		lo.Close();
 	        		}
 	        	TRAP_IGNORE( iHarvesterEventManager->DecreaseItemCountL( EHEObserverTypeMMC, 1 ) );
 				delete aHD;
 WRITELOG( "==============================ERROR done =========================" );
 OstTrace0( TRACE_NORMAL, DUP12_CHARVESTERAO_HARVESTINGCOMPLETED, "==============================ERROR done =========================" );
 }
+SetNextRequest( ERequestHarvest );
 }
 // ---------------------------------------------------------------------------
 // HandleSessionOpened
 // ---------------------------------------------------------------------------
 TRAP_IGNORE( BootRomScanL() );
 }
 TRAP_IGNORE( BootPartialRestoreScanL() );
 #endif
-// Store the internal mass memory media ID to DB, and update data if necessary
+if( !iMassMemoryIdChecked )
-TInt drive( -1 );
+{
-TInt internalMassStorageError( DriveInfo::GetDefaultDrive( DriveInfo::EDefaultMassStorage, drive ) );
+TInt drive( -1 );
-if( internalMassStorageError == KErrNone )
+TInt massStorageError( DriveInfo::GetDefaultDrive( DriveInfo::EDefaultMassStorage, drive ) );
-{
+if( massStorageError == KErrNone )
-TVolumeInfo internalMassStorageVolumeInfo;
-internalMassStorageError = iFs.Volume( internalMassStorageVolumeInfo, drive );
-if( internalMassStorageError == KErrNone )
 {
-const TUint32 massStorageMediaId( internalMassStorageVolumeInfo.iUniqueID );
+TVolumeInfo massStorageVolumeInfo;
-if( massStorageMediaId != 0 )
+iFs.Volume( massStorageVolumeInfo, drive );
+const TUint32 massStorageMediaId( massStorageVolumeInfo.iUniqueID );
+massStorageError = DriveInfo::GetDefaultDrive( DriveInfo::EDefaultRemovableMassStorage, drive );
+if( massStorageError == KErrNone )
 {
-TUint32 mmcMediaId( 0 );
+iFs.Volume( massStorageVolumeInfo, drive );
-TInt mmcDrive( -1 );
+// Update mass storage media id if the mass storage is not memory card
-TInt mmcError( DriveInfo::GetDefaultDrive( DriveInfo::EDefaultRemovableMassStorage, mmcDrive ) );
+if( massStorageVolumeInfo.iUniqueID != massStorageMediaId && massStorageMediaId != 0 )
-if( mmcError == KErrNone )
-{
-if( drive != mmcDrive )
-{
-TVolumeInfo mmcVolumeInfo;
-mmcError = iFs.Volume( mmcVolumeInfo, mmcDrive );
-if( mmcError == KErrNone )
-{
-mmcMediaId = mmcVolumeInfo.iUniqueID;
-}
-}
-else
-{
-mmcMediaId = massStorageMediaId;
-}
-}
-// If removable storage is not found, assume internal mass storage was mounted
-if( mmcError )
-{
-iMdEHarvesterSession->CheckMassStorageMediaId( massStorageMediaId );
-}
-else if( massStorageMediaId != mmcMediaId )
 {
 iMdEHarvesterSession->CheckMassStorageMediaId( massStorageMediaId );
 }
 }
 }
 }
 }
 else
 {
 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;
 //
 void CHarvesterAO::ResumeHarvesterL()
 {
 WRITELOG( "CHarvesterAO::ResumeHarvesterL()" );
 OstTrace0( TRACE_NORMAL, CHARVESTERAO_RESUMEHARVESTERL, "CHarvesterAO::ResumeHarvesterL" );
-if( iRamFull || iDiskFull || iUnmountHandlingOngoing || iManualPauseEnabled )
-{
-return;
-}
 iHarvesterPluginFactory->PauseHarvester( EFalse );
 iServerPaused = EFalse;
-if( iNextRequest == ERequestIdle )
+if( !iManualPauseEnabled &&
+iNextRequest == ERequestIdle )
 {
 SetNextRequest( ERequestHarvest );
 }
+iManualPauseEnabled = EFalse;
 }
 // ---------------------------------------------------------------------------
 // RunL
 // ---------------------------------------------------------------------------
 iReadyPHArray.Compress();
 iContainerPHArray.Compress();
 iPHArray.Compress();
 iTempReadyPHArray.Compress();
-if( iLocManipulatorConnected )
-{
-iLocManipulator.Close();
-iLocManipulatorConnected = EFalse;
-}
 }
 break;
 // data added to harvester queue
 case ERequestHarvest:
 {
 WRITELOG( "CHarvesterAO::RunL - ERequestHarvest" );
 OstTrace0( TRACE_NORMAL, DUP2_CHARVESTERAO_RUNL, "CHarvesterAO::RunL - ERequestHarvest" );
-// harvest new items first
+// harvest new items first...
 if ( iQueue->ItemsInQueue() > 0 )
 {
 WRITELOG( "CHarvesterAO::RunL - Items in queue - calling ReadItemFromQueueL()" );
 ReadItemFromQueueL();
 				SetNextRequest( ERequestHarvest );
 // no more items to handle from main queue
 else
 {
 WRITELOG( "CHarvesterAO::RunL - No items in main queue" );
-// If interrupts occured, check the normal placeholder array for possible items to
-// be handled before moving on to container or ready placeholders
-if( iPHArray.Count() > 0 )
-{
-WRITELOG( "CHarvesterAO::RunL - Items found in placeholder array" );
-TRAPD( err, HandlePlaceholdersL( ETrue ) );
-// make sure that when HandlePlaceholdersL leaves unexpectedly, iPHArray is cleared
-if ( err != KErrNone )
-{
-if( err != KErrDiskFull )
-{
-iPHArray.ResetAndDestroy();
-iTempReadyPHArray.ResetAndDestroy();
-}
-User::Leave( err );
-}
-SetNextRequest( ERequestHarvest );
-break;
-}
 // All registered fast harvested items or placeholders handled at this point
 // if container files to harvest, handle those next
-else if( iContainerPHArray.Count() > 0 )
+if( iContainerPHArray.Count() > 0 )
 	{
 WRITELOG( "CHarvesterAO::RunL - Items in iContainterPHArray - requesting ERequestContainerPlaceholder handling" );
 iFastHarvestNeeded = EFalse;
 iHarvestingPlaceholders = EFalse;
 SetPriority( KHarvesterPriorityHarvestingPlugin );
 		{
 #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( KReadyPlaceholderQueueSize );
+		TInt endIndex( KPlaceholderQueueSize );
-		if( arrayCount < KReadyPlaceholderQueueSize )
+		if( arrayCount < KPlaceholderQueueSize )
 		    {
 		    endIndex = arrayCount;
 		    }
 		for( TInt i = 0; i < endIndex; i++ )
 			{
 	TInt count = iContainerPHArray.Count() > KContainerPlaceholderQueueSize ? KContainerPlaceholderQueueSize : iContainerPHArray.Count();
 	TInt i = 0;
 	while( i < count )
 		{
 		CHarvesterData* hd = iContainerPHArray[0];
-		if( iPHArray.Append( hd ) != KErrNone )
+		iPHArray.Append( hd );
-		    {
-		    delete hd;
-		    hd = NULL;
-		    }
 		iContainerPHArray.Remove( 0 );
 		i++;
 		}
 	TRAPD( err, HandlePlaceholdersL( EFalse ) );
-// make sure that when HandlePlaceholdersL leaves unexpectedly, iPHArray is cleared
+	    	// make sure that when HandlePlaceholdersL leaves, iPHArray is cleared
-if ( err != KErrNone )
+	    	if ( err != KErrNone )
-{
+	    		{
-if( err != KErrDiskFull )
+	    	    iContainerPHArray.ResetAndDestroy();
-{
+	    		iPHArray.ResetAndDestroy();
-iContainerPHArray.ResetAndDestroy();
+	    		iTempReadyPHArray.ResetAndDestroy();
-iPHArray.ResetAndDestroy();
+	    		User::Leave( err );
-iTempReadyPHArray.ResetAndDestroy();
+	    		}
-}
-User::Leave( err );
-}
 	    	SetNextRequest( ERequestHarvest );
 	}
 break;
 // pause request
 case ERequestPause:
 {
 WRITELOG( "CHarvesterAO::RunL - ERequestPause" );
 OstTrace0( TRACE_NORMAL, DUP6_CHARVESTERAO_RUNL, "CHarvesterAO::RunL - ERequestPause" );
 User::LeaveIfError( PauseHarvester() );
-iManualPauseEnabled = ETrue;
 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" );
-iManualPauseEnabled = EFalse;
-// If for some reason, mds session is not (yet) ready, only inform that
-// server state is no longer paused, but do not restart actual harvesting
-// yet.
-if( !iMdeSessionInitialized )
-{
-iHarvesterEventManager->SendEventL( EHEObserverTypeOverall, EHEStateResumed );
-if( iHarvesterStatusObserver )
-{
-iHarvesterStatusObserver->ResumeReady( KErrNone );
-}
-break;
-}
 ResumeHarvesterL();
 iHarvesterEventManager->SendEventL( EHEObserverTypeOverall, EHEStateResumed );
 if( iHarvesterStatusObserver )
 	{
 iHarvesterStatusObserver->ResumeReady( KErrNone );
 // RunError
 // ---------------------------------------------------------------------------
 //
 TInt CHarvesterAO::RunError( TInt aError )
 {
-WRITELOG1( "CHarvesterAO::RunError, error: %d", 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" );
-if( aError == KErrDiskFull || aError == KErrNoMemory )
-{
-SetNextRequest( ERequestIdle );
-}
-}
-break;
-case ERequestContainerPlaceholder:
-{
-WRITELOG( "CHarvesterAO::RunError - state ERequestContainerPlaceholder" );
-OstTrace0( TRACE_NORMAL, DUP5_CHARVESTERAO_RUNERROR, "CHarvesterAO::RunError - state ERequestContainerPlaceholder" );
-if( aError == KErrDiskFull || aError == KErrNoMemory )
-{
-SetNextRequest( ERequestIdle );
-}
 }
 break;
 case ERequestPause:
 {
 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 = EFalse;
-}
-else
-{
-WRITELOG("CHarvesterAO::HandleDiskSpaceNotificationL() - disk full");
-OstTrace0( TRACE_NORMAL, DUP1_CHARVESTERAO_HANDLEDISKSPACENOTIFICATIONL, "CHarvesterAO::HandleDiskSpaceNotificationL - disk full" );
 iDiskFull = ETrue;
 if( iServerPaused )
 {
 return;
 }
 {
 // cache monitored events
 PauseMonitoring();
 PauseHarvester();
 }
-else if( iServerPaused )
+else if( !iRamFull && !iManualPauseEnabled && iServerPaused )
 {
 // resume monitoring
 ResumeMonitoring();
 TRAP_IGNORE( ResumeHarvesterL() );
 }
 SetNextRequest( CHarvesterAO::ERequestHarvest );
 }
 }
 else
 {
+HarvestCompleted( hd->ClientId(), hd->Uri(), KErrUnknown );
 delete hd;
 hd = NULL;
 err = KErrUnknown;
 }
 if (!aMessage.IsNull())
 {
 aMessage.Complete( err );
-}
-else if( err != KErrNone )
-{
-HarvestCompleted( aMessage.Identity(), uri->Des(), err );
 }
 albumIds.Close();
 }
 		SetNextRequest( CHarvesterAO::ERequestHarvest );
 		}
 	}
 else
 {
+HarvestCompleted( hd->ClientId(), hd->Uri(), KErrUnknown );
 delete hd;
 hd = NULL;
 err = KErrUnknown;
 }
 if (!aMessage.IsNull())
 {
 aMessage.Complete( err );
-}
-else if( err != KErrNone )
-{
-HarvestCompleted( aMessage.Identity(), uri->Des(), err );
 }
 albumIds.Close();
 }
 	{
 	iHarvestFileMessages.Remove( i );
 	continue;
 	}
+//if (aMessage.Identity() == msg.Identity())
 if( &req.iSession == &aSession )
 	{
 	err = KErrNone;
 	            if (!req.iMessage.IsNull())
 	            	{
 		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;
+iFs.Volume( massStorageVolumeInfo, drive );
+const TUint32 massStorageMediaId( massStorageVolumeInfo.iUniqueID );
+massStorageError = DriveInfo::GetDefaultDrive( DriveInfo::EDefaultRemovableMassStorage, drive );
+if( massStorageError == KErrNone )
+{
+iFs.Volume( massStorageVolumeInfo, drive );
+// Update mass storage media id if the mass storage is not memory card
+if( massStorageVolumeInfo.iUniqueID != massStorageMediaId && massStorageMediaId != 0 )
+{
+iMdEHarvesterSession->CheckMassStorageMediaId( massStorageMediaId );
+}
+}
+}
 	TVolumeInfo volumeInfo;
 	iFs.Volume( volumeInfo, EDriveC );
 	iMdEHarvesterSession->SetFilesToNotPresent( volumeInfo.iUniqueID, ETrue );
 					if( !IsDescInArray( path, aIgnorePaths ) )
 						{
 						WRITELOG("CHarvesterAO::BootScanL() - scanFolders.AppendL");
 						OstTrace0( TRACE_NORMAL, DUP2_CHARVESTERAO_BOOTSCANL, "CHarvesterAO::BootScanL - scanFolders.AppendL" );
 						TScanItem* item = new (ELeave) TScanItem();
-						CleanupStack::PushL( item );
 						item->iPath = name->AllocL();
 						item->iPreinstalled = MdeConstants::MediaObject::ENotPreinstalled;
-						CleanupStack::Pop( item );
+						aScanItems.AppendL( item );
-						aScanItems.AppendL( item ); // ownership is transferred
 						}
 					}
 				else
 					{
 					TPtrC filename = *name;
 	                        hd->SetObjectType( EPlaceholder );
 	                        hd->SetOrigin( MdeConstants::Object::EOther );
 	                        hd->SetClientData( phData );
 	                        CleanupStack::Pop( phData );
+	                        hdArray.Append( hd );
-	                        if(hdArray.Append( hd ) != KErrNone )
-	                            {
-delete hd;
-hd = NULL;
-	                            }
 						    }
 						CleanupStack::PopAndDestroy( &results );
 						CleanupStack::PopAndDestroy( &fileInfos );
 						CleanupStack::PopAndDestroy( &uris );
 						}
 	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 )
 	// cache monitored events
 	PauseMonitoring();
 	PauseHarvester();
-iReadyPHArray.Compress();
+	iPHArray.Compress();
-iContainerPHArray.Compress();
+	iReadyPHArray.Compress();
-iPHArray.Compress();
+	iContainerPHArray.Compress();
-iTempReadyPHArray.Compress();
 	}
 void CHarvesterAO::MemoryGood()
 	{
 WRITELOG("CHarvesterAO::MemoryGood()");
 OstTrace0( TRACE_NORMAL, CHARVESTERAO_MEMORYGOOD, "CHarvesterAO::MemoryGood" );
 iRamFull = EFalse;
-if( iServerPaused )
+if( !iDiskFull && !iManualPauseEnabled && iServerPaused )
 {
 // resume monitoring
 ResumeMonitoring();
 TRAP_IGNORE( ResumeHarvesterL() );

branch	RCL_3
changeset 63	e538444823de
parent 53	29d87345eaeb