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

equal deleted inserted replaced

-:aa5a574040a4
+:a3cc46f37772
 #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(KUndefinedMime, " ");
+_LIT(KUndefined, " ");
 _LIT( KExtensionMp4,   "mp4" );
 _LIT( KExtensionMpg4,  "mpg4" );
 _LIT( KExtensionMpeg4, "mpeg4" );
 _LIT( KExtension3gp,   "3gp" );
 	{
 	}
 void CHarvesterAoPropertyDefs::ConstructL(CMdEObjectDef& aObjectDef)
 	{
-	CMdENamespaceDef& nsDef = aObjectDef.NamespaceDef();
+SetByObjectDefL( aObjectDef );
-	// 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(CMdEObjectDef& aObjectDef)
+CHarvesterAoPropertyDefs* CHarvesterAoPropertyDefs::NewL()
-	{
+{
-	CHarvesterAoPropertyDefs* self =
+CHarvesterAoPropertyDefs* self =
-		new (ELeave) CHarvesterAoPropertyDefs();
+new (ELeave) CHarvesterAoPropertyDefs();
-	CleanupStack::PushL( self );
+return self;
-	self->ConstructL( aObjectDef );
+}
-	CleanupStack::Pop( self );
-	return self;
+void CHarvesterAoPropertyDefs::SetByObjectDefL(CMdEObjectDef& 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 );
+}
 // ---------------------------------------------------------------------------
 // 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 );
-TInt count( 0 );
+const TInt count( infoArray.Count() );
-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" );
-const TInt count( iMonitorPluginArray.Count() );
+for( TInt i = iMonitorPluginArray.Count() - 1; i >=0; i-- )
-for ( TInt i = 0; i < count; i++ )
 {
 iMonitorPluginArray[i]->StopMonitoring();
 }
 }
 void CHarvesterAO::PauseMonitoring()
 {
 WRITELOG( "CHarvesterAO::PauseMonitoring()" );
 OstTrace0( TRACE_NORMAL, CHARVESTERAO_PAUSEMONITORING, "CHarvesterAO::PauseMonitoring" );
-const TInt count( iMonitorPluginArray.Count() );
+for( TInt i = iMonitorPluginArray.Count() - 1; i >=0; i-- )
-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();
 if( err == KErrNone && mediaId == aMediaId )
 {
 WRITELOG1( "CHarvesterAO::HandleUnmount() remove iReadyPHArray %d", i);
 OstTrace1( TRACE_NORMAL, DUP2_CHARVESTERAO_HANDLEUNMOUNT, "CHarvesterAO::HandleUnmount remove iReadyPHArray %d", i );
+HarvestCompleted( hd->ClientId(), hd->Uri(), KErrCancel );
 delete hd;
 hd = NULL;
 iReadyPHArray.Remove( i );
 removed++;
 arrayCount--;
 if( err == KErrNone && mediaId == aMediaId )
 {
 WRITELOG1( "CHarvesterAO::HandleUnmount() remove iPHArray %d", i);
 OstTrace1( TRACE_NORMAL, DUP5_CHARVESTERAO_HANDLEUNMOUNT, "CHarvesterAO::HandleUnmount remove iPHArray %d", i );
+HarvestCompleted( hd->ClientId(), hd->Uri(), KErrCancel );
 delete hd;
 				hd = NULL;
 iPHArray.Remove( i );
 removed++;
 arrayCount--;
 if( err == KErrNone && mediaId == aMediaId )
 {
 WRITELOG1( "CHarvesterAO::HandleUnmount() remove iContainerPHArray %d", i);
 OstTrace1( TRACE_NORMAL, DUP8_CHARVESTERAO_HANDLEUNMOUNT, "CHarvesterAO::HandleUnmount remove iContainerPHArray %d", i );
+HarvestCompleted( hd->ClientId(), hd->Uri(), KErrCancel );
 delete hd;
 				hd = NULL;
 iContainerPHArray.Remove( i );
 removed++;
 arrayCount--;
 err = iMediaIdUtil->GetMediaId( hd->Uri(), mediaId );
 if( err == KErrNone && mediaId == aMediaId )
 {
 WRITELOG1( "CHarvesterAO::HandleUnmount() remove iTempReadyPHArray %d", i);
+HarvestCompleted( hd->ClientId(), hd->Uri(), KErrCancel );
 delete hd;
 hd = NULL;
 iTempReadyPHArray.Remove( i );
 removed++;
 arrayCount--;
 hpi->iQueue.Remove(j);
 					removed++;
 					TRAP_IGNORE( iMdESession->CancelObjectL( mdeobj ) );
+					HarvestCompleted( hd->ClientId(), hd->Uri(), KErrCancel );
 					delete hd;
 					hd = NULL;
 					}
 				}
 		}
 iMediaIdUtil->RemoveMediaId( aMediaId );
 	// resume harvesting from last state
-if( !iRamFull && !iDiskFull )
+iUnmountHandlingOngoing = EFalse;
-{
+// resume monitoring
-// resume monitoring
+ResumeMonitoring();
-ResumeMonitoring();
+TRAP_IGNORE( ResumeHarvesterL() );
-TRAP_IGNORE( ResumeHarvesterL() );
-}
 	}
 // ---------------------------------------------------------------------------
 // StartComposersL
 // ---------------------------------------------------------------------------
 iHarvestingPlaceholders = ETrue;
 if( !iFastHarvestNeeded )
 {
 SetPriority( KHarvesterCustomImportantPriority );
 }
-	while( hd != NULL &&
+	while( hd &&
-				iPHArray.Count() < KPlaceholderQueueSize &&
+			   iPHArray.Count() < KPlaceholderQueueSize &&
-				hd->ObjectType() == EPlaceholder )
+			   hd->ObjectType() == EPlaceholder )
 		{
-	iPHArray.Append( hd );
+	if(iPHArray.Append( hd ) != KErrNone)
-	if( hd->Origin() == MdeConstants::Object::ECamera ||
-	    hd->ObjectType() == EFastHarvest  )
 	    {
-	    if( !iFastHarvestNeeded )
+	    HarvestCompleted( hd->ClientId(), hd->Uri(), KErrNoMemory );
-	        {
+	    iHarvesterEventManager->DecreaseItemCountL( EHEObserverTypeMMC, 1 );
-iFastHarvestNeeded = ETrue;
+delete hd;
-// Fast harvest event must be handled even if MMC handling would be ongoing
+hd = NULL;
-SetPriority( KHarvesterPriorityMonitorPlugin );
-	        }
-	    break;
 	    }
-	else if( iFastHarvestNeeded )
+	else
 	    {
-	    iFastHarvestNeeded = EFalse;
+if( hd->Origin() == MdeConstants::Object::ECamera ||
-	    SetPriority( KHarvesterCustomImportantPriority );
+hd->ObjectType() == EFastHarvest  )
+{
+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, iPHArray is cleared
+// make sure that when HandlePlaceholdersL leaves unexpectedly, iPHArray is cleared
 if ( err != KErrNone )
 {
-iPHArray.ResetAndDestroy();
+if( err != KErrDiskFull )
-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 )
 	    		{
-	        	iPHArray.Append( hd );
+	        	if( iPHArray.Append( hd ) != KErrNone )
+	        	    {
+	        	    HarvestCompleted( hd->ClientId(), hd->Uri(), KErrNoMemory );
+	        	    iHarvesterEventManager->DecreaseItemCountL( EHEObserverTypeMMC, 1 );
+delete hd;
+hd = NULL;
+	        	    }
 	    		}
 	    	else
 	    		{
-	    		CheckFileExtensionAndHarvestL( hd );
+if( iReadyPHArray.Append( hd ) != KErrNone)
-	    		if( iUnmountDetected )
+{
-	    		    {
+delete hd;
-	    		    iQueue->Append( hd );
+hd = NULL;
-	    		    return;
+}
-	    		    }
 	    		}
 		}
 	if( iPHArray.Count() > 0 )
 		{
 	    	TRAPD( err, HandlePlaceholdersL( ETrue ) );
-	    	// make sure that when HandlePlaceholdersL leaves, iPHArray is cleared
+	    	// make sure that when HandlePlaceholdersL leaves unexpectedly, iPHArray is cleared
 	    	if ( err != KErrNone )
 	    		{
-	    		iPHArray.ResetAndDestroy();
+	    	    if( err != KErrDiskFull )
-	    		iTempReadyPHArray.ResetAndDestroy();
+	    	        {
+	    	        iPHArray.ResetAndDestroy();
+	    	        iTempReadyPHArray.ResetAndDestroy();
+	    	        }
 	    		User::Leave( err );
 	    		}
 		}
 	}
 else
 {
 SetPriority( KHarvesterPriorityHarvestingPlugin );
 }
 iHarvestingPlaceholders = EFalse;
 CheckFileExtensionAndHarvestL( hd );
-if( iUnmountDetected )
+if( iUnmountDetected && hd )
 {
 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 && iHarvesterPluginFactory->IsContainerFileL( hd->Uri() ) )
+		if( aCheck &&
+		    hd->Origin() != MdeConstants::Object::ECamera &&
+		    iHarvesterPluginFactory->IsContainerFileL( hd->Uri() ) )
 			{
-			iContainerPHArray.Append( hd );
+			if( iContainerPHArray.Append( hd ) != KErrNone )
+			    {
+			    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* hd = iTempReadyPHArray[y];
+		        CHarvesterData* tempHd = 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* hd = iTempReadyPHArray[y];
+CHarvesterData* tempHd = iTempReadyPHArray[y];
-if( currentPHArrayCount )
+if(iPHArray.Insert( tempHd, 0 ) != KErrNone)
 {
-// Leave the first item in the array as it is the priority item
+HarvestCompleted( tempHd->ClientId(), tempHd->Uri(), KErrNoMemory );
-iPHArray.Insert( hd, 1 );
+iHarvesterEventManager->DecreaseItemCountL( EHEObserverTypeMMC, 1 );
-}
+delete tempHd;
-else
+tempHd = NULL;
-{
-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 ) )
 			{
-		    WRITELOG( "CHarvesterAO::HandlePlaceholdersL() - no objectDef or in use, failing harvesting" );
+#ifdef _DEBUG
+		    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 );
-		CMdEObject* mdeObject = iMdESession->NewObjectL( mdeObjectDef, hd->Uri() );
+		HBufC* hdUri = hd->Uri().AllocL();
+		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 )
+	    if( !iPropDefs->iCreationDatePropertyDef )
-	    	{
+	        {
-	    	iPropDefs = CHarvesterAoPropertyDefs::NewL( defNS.GetObjectDefL( MdeConstants::Object::KBaseObject ) );
+iPropDefs->SetByObjectDefL( 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, KUndefinedMime );
+mdeObject->AddTextPropertyL( *iPropDefs->iItemTypePropertyDef, KUndefined );
 }
 if( hd->Origin() == MdeConstants::Object::ECamera )
 {
 TBool inDefaultFolder( ETrue );
 	        {
 	        mdeObject->AddTextPropertyL( *iPropDefs->iTitlePropertyDef, name );
 	        }
 	    else
 	        {
-	        mdeObject->AddTextPropertyL( *iPropDefs->iTitlePropertyDef, KNullDesC );
+	        mdeObject->AddTextPropertyL( *iPropDefs->iTitlePropertyDef, KUndefined );
 	        }
 	CPlaceholderData* ph = NULL;
 	if( hd->TakeSnapshot() )
 	    {
 	    CleanupStack::PopAndDestroy( phData );
 	    CleanupStack::Pop( mdeObject );
-	    iTempReadyPHArray.Append( hd );
+	    if(iTempReadyPHArray.Append( hd ) != KErrNone)
+	        {
+	        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 );
-		const TInt addError( iMdESession->AddObjectsL( mdeObjectArray ) );
+		TInt addError( KErrNone );
+		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( iUnmountDetected )
+if( !aHD )
 {
 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." );
-	        		RLocationObjectManipulator lo;
+	        		TInt loError( KErrNone );
+	        		if( !iLocManipulatorConnected )
-	        		const TInt loError = lo.Connect();
+	        		    {
+	        		    loError = iLocManipulator.Connect();
+	        		    if( loError == KErrNone )
+	        		        {
+	        		        iLocManipulatorConnected = ETrue;
+	        		        }
+	        		    }
 	        		if (loError == KErrNone)
 	        			{
-	        			TInt err = lo.CreateLocationObject( *locData, aHD->MdeObject().Id() );
+	        			TInt err = iLocManipulator.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
-if( !iMassMemoryIdChecked )
+// Store the internal mass memory media ID to DB, and update data if necessary
-{
+TInt drive( -1 );
-TInt drive( -1 );
+TInt internalMassStorageError( DriveInfo::GetDefaultDrive( DriveInfo::EDefaultMassStorage, drive ) );
-TInt massStorageError( DriveInfo::GetDefaultDrive( DriveInfo::EDefaultMassStorage, drive ) );
+if( internalMassStorageError == KErrNone )
-if( massStorageError == KErrNone )
+{
+TVolumeInfo internalMassStorageVolumeInfo;
+internalMassStorageError = iFs.Volume( internalMassStorageVolumeInfo, drive );
+if( internalMassStorageError == KErrNone )
 {
-TVolumeInfo massStorageVolumeInfo;
+const TUint32 massStorageMediaId( internalMassStorageVolumeInfo.iUniqueID );
-iFs.Volume( massStorageVolumeInfo, drive );
+if( massStorageMediaId != 0 )
-const TUint32 massStorageMediaId( massStorageVolumeInfo.iUniqueID );
-massStorageError = DriveInfo::GetDefaultDrive( DriveInfo::EDefaultRemovableMassStorage, drive );
-if( massStorageError == KErrNone )
 {
-iFs.Volume( massStorageVolumeInfo, drive );
+TUint32 mmcMediaId( 0 );
-// Update mass storage media id if the mass storage is not memory card
+TInt mmcDrive( -1 );
-if( massStorageVolumeInfo.iUniqueID != massStorageMediaId && massStorageMediaId != 0 )
+TInt mmcError( DriveInfo::GetDefaultDrive( DriveInfo::EDefaultRemovableMassStorage, mmcDrive ) );
+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( !iManualPauseEnabled &&
+if( iNextRequest == ERequestIdle )
-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
-if( iContainerPHArray.Count() > 0 )
+else 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( KPlaceholderQueueSize );
+		TInt endIndex( KReadyPlaceholderQueueSize );
-		if( arrayCount < KPlaceholderQueueSize )
+		if( arrayCount < KReadyPlaceholderQueueSize )
 		    {
 		    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];
-		iPHArray.Append( hd );
+		if( iPHArray.Append( hd ) != KErrNone )
+		    {
+		    delete hd;
+		    hd = NULL;
+		    }
 		iContainerPHArray.Remove( 0 );
 		i++;
 		}
 	TRAPD( err, HandlePlaceholdersL( EFalse ) );
-	    	// make sure that when HandlePlaceholdersL leaves, iPHArray is cleared
+// make sure that when HandlePlaceholdersL leaves unexpectedly, iPHArray is cleared
-	    	if ( err != KErrNone )
+if ( err != KErrNone )
-	    		{
+{
-	    	    iContainerPHArray.ResetAndDestroy();
+if( err != KErrDiskFull )
-	    		iPHArray.ResetAndDestroy();
+{
-	    		iTempReadyPHArray.ResetAndDestroy();
+iContainerPHArray.ResetAndDestroy();
-	    		User::Leave( err );
+iPHArray.ResetAndDestroy();
-	    		}
+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 )
 {
-WRITELOG( "CHarvesterAO::RunError" );
+WRITELOG1( "CHarvesterAO::RunError, error: %d", aError );
 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 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 = EFalse;
-}
-else
-{
-WRITELOG("CHarvesterAO::HandleDiskSpaceNotificationL() - disk space available");
-OstTrace0( TRACE_NORMAL, DUP2_CHARVESTERAO_HANDLEDISKSPACENOTIFICATIONL, "CHarvesterAO::HandleDiskSpaceNotificationL - disk space available" );
 iDiskFull = ETrue;
 if( iServerPaused )
 {
 return;
 }
 {
 // cache monitored events
 PauseMonitoring();
 PauseHarvester();
 }
-else if( !iRamFull && !iManualPauseEnabled && iServerPaused )
+else if( iServerPaused )
 {
 // resume monitoring
 ResumeMonitoring();
 TRAP_IGNORE( ResumeHarvesterL() );
 }
 }
 }
 else
 {
 delete hd;
+hd = NULL;
 err = KErrUnknown;
 }
 if (!aMessage.IsNull())
 {
 aMessage.Complete( err );
+}
+else if( err != KErrNone )
+{
+HarvestCompleted( aMessage.Identity(), uri->Des(), err );
 }
 albumIds.Close();
 }
 		}
 	}
 else
 {
 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;
-						aScanItems.AppendL( item );
+						CleanupStack::Pop( 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();
-	iPHArray.Compress();
+iReadyPHArray.Compress();
-	iReadyPHArray.Compress();
+iContainerPHArray.Compress();
-	iContainerPHArray.Compress();
+iPHArray.Compress();
+iTempReadyPHArray.Compress();
 	}
 void CHarvesterAO::MemoryGood()
 	{
 WRITELOG("CHarvesterAO::MemoryGood()");
 OstTrace0( TRACE_NORMAL, CHARVESTERAO_MEMORYGOOD, "CHarvesterAO::MemoryGood" );
 iRamFull = EFalse;
-if( !iDiskFull && !iManualPauseEnabled && iServerPaused )
+if( iServerPaused )
 {
 // resume monitoring
 ResumeMonitoring();
 TRAP_IGNORE( ResumeHarvesterL() );

changeset 54	a3cc46f37772
parent 36	aa5a574040a4