harvester/server/src/harvesterao.cpp
branchRCL_3
changeset 21 85f623e1ef41
parent 20 f23c07ec56e2
child 22 29d87345eaeb
equal deleted inserted replaced
20:f23c07ec56e2 21:85f623e1ef41
    17 
    17 
    18 #include <e32svr.h>
    18 #include <e32svr.h>
    19 #include <caf/caf.h>
    19 #include <caf/caf.h>
    20 #include <driveinfo.h>
    20 #include <driveinfo.h>
    21 
    21 
       
    22 #include <rlocationobjectmanipulator.h>
    22 #include <placeholderdata.h>
    23 #include <placeholderdata.h>
    23 #include <harvesterclientdata.h>
    24 #include <harvesterclientdata.h>
    24 #include <pathinfo.h>
    25 #include <pathinfo.h>
    25 
    26 
    26 using namespace ContentAccess;
    27 using namespace ContentAccess;
    59 _LIT( KTAGDaemonExe, "thumbagdaemon.exe" );
    60 _LIT( KTAGDaemonExe, "thumbagdaemon.exe" );
    60 
    61 
    61 _LIT(KVideo, "Video");
    62 _LIT(KVideo, "Video");
    62 _LIT(KInUse, "InUse");
    63 _LIT(KInUse, "InUse");
    63 
    64 
    64 _LIT(KUndefined, " ");
    65 _LIT(KUndefinedMime, " ");
    65 
    66 
    66 _LIT( KExtensionMp4,   "mp4" );
    67 _LIT( KExtensionMp4,   "mp4" );
    67 _LIT( KExtensionMpg4,  "mpg4" );
    68 _LIT( KExtensionMpg4,  "mpg4" );
    68 _LIT( KExtensionMpeg4, "mpeg4" );
    69 _LIT( KExtensionMpeg4, "mpeg4" );
    69 _LIT( KExtension3gp,   "3gp" );
    70 _LIT( KExtension3gp,   "3gp" );
   153     iManualPauseEnabled = EFalse;
   154     iManualPauseEnabled = EFalse;
   154     iFastHarvestNeeded = EFalse;
   155     iFastHarvestNeeded = EFalse;
   155     iHarvestingPlaceholders = EFalse;
   156     iHarvestingPlaceholders = EFalse;
   156     
   157     
   157     iUnmountDetected = EFalse;
   158     iUnmountDetected = EFalse;
   158     iUnmountHandlingOngoing = EFalse;
       
   159     iPriorityInterruptDetected = EFalse;
   159     iPriorityInterruptDetected = EFalse;
   160     iLocManipulatorConnected = EFalse;
       
   161     }
   160     }
   162      
   161      
   163 // ---------------------------------------------------------------------------
   162 // ---------------------------------------------------------------------------
   164 // ~CHarvesterAO
   163 // ~CHarvesterAO
   165 // ---------------------------------------------------------------------------
   164 // ---------------------------------------------------------------------------
   170     OstTrace0( TRACE_NORMAL, DUP1_CHARVESTERAO_CHARVESTERAO, "CHarvesterAO::~CHarvesterAO" );
   169     OstTrace0( TRACE_NORMAL, DUP1_CHARVESTERAO_CHARVESTERAO, "CHarvesterAO::~CHarvesterAO" );
   171     
   170     
   172     Cancel();
   171     Cancel();
   173 
   172 
   174 	iFs.Close();
   173 	iFs.Close();
   175 	
       
   176 	iLocManipulator.Close();
       
   177 	
   174 	
   178 	if (iCtxEngine)
   175 	if (iCtxEngine)
   179 		{
   176 		{
   180 		iCtxEngine->ReleaseInstance();
   177 		iCtxEngine->ReleaseInstance();
   181 		}
   178 		}
   508 	{
   505 	{
   509     WRITELOG1( "CHarvesterAO::HandleUnmount(%d)", aMediaId );    
   506     WRITELOG1( "CHarvesterAO::HandleUnmount(%d)", aMediaId );    
   510 	OstTrace1( TRACE_NORMAL, CHARVESTERAO_HANDLEUNMOUNT, "CHarvesterAO::HandleUnmount;aMediaId=%d", aMediaId );
   507 	OstTrace1( TRACE_NORMAL, CHARVESTERAO_HANDLEUNMOUNT, "CHarvesterAO::HandleUnmount;aMediaId=%d", aMediaId );
   511     
   508     
   512     iUnmountDetected = ETrue;
   509     iUnmountDetected = ETrue;
   513     iUnmountHandlingOngoing = ETrue;
       
   514     
   510     
   515     if( !iServerPaused )
   511     if( !iServerPaused )
   516         {
   512         {
   517         // Stop harvesting for unmount
   513         // Stop harvesting for unmount
   518         PauseMonitoring();
   514         PauseMonitoring();
   733 		}
   729 		}
   734 	
   730 	
   735     iMediaIdUtil->RemoveMediaId( aMediaId );
   731     iMediaIdUtil->RemoveMediaId( aMediaId );
   736 	
   732 	
   737 	// resume harvesting from last state
   733 	// resume harvesting from last state
   738     iUnmountHandlingOngoing = EFalse;
   734     if( !iRamFull && !iDiskFull )
   739     // resume monitoring
   735         {
   740     ResumeMonitoring();
   736         // resume monitoring
   741     TRAP_IGNORE( ResumeHarvesterL() );    
   737         ResumeMonitoring();
       
   738         TRAP_IGNORE( ResumeHarvesterL() );    
       
   739         }
   742 	}
   740 	}
   743 
   741 
   744 // ---------------------------------------------------------------------------
   742 // ---------------------------------------------------------------------------
   745 // StartComposersL
   743 // StartComposersL
   746 // ---------------------------------------------------------------------------
   744 // ---------------------------------------------------------------------------
   847         iHarvestingPlaceholders = ETrue;
   845         iHarvestingPlaceholders = ETrue;
   848         if( !iFastHarvestNeeded )
   846         if( !iFastHarvestNeeded )
   849             {
   847             {
   850             SetPriority( KHarvesterCustomImportantPriority );
   848             SetPriority( KHarvesterCustomImportantPriority );
   851             }
   849             }
   852     	while( hd &&
   850     	while( hd != NULL &&
   853 			   iPHArray.Count() < KPlaceholderQueueSize &&
   851 				iPHArray.Count() < KPlaceholderQueueSize &&
   854 			   hd->ObjectType() == EPlaceholder )
   852 				hd->ObjectType() == EPlaceholder )
   855     		{
   853     		{
   856         	if(iPHArray.Append( hd ) != KErrNone)
   854         	if(iPHArray.Append( hd ) != KErrNone)
   857         	    {
   855         	    {
   858         	    HarvestCompleted( hd->ClientId(), hd->Uri(), KErrNoMemory );
   856         	    HarvestCompleted( hd->ClientId(), hd->Uri(), KErrNoMemory );
   859         	    iHarvesterEventManager->DecreaseItemCountL( EHEObserverTypeMMC, 1 );
   857         	    iHarvesterEventManager->DecreaseItemCountL( EHEObserverTypeMMC, 1 );
   985 	TInt endindex( iPHArray.Count() );
   983 	TInt endindex( iPHArray.Count() );
   986 	for( TInt i = 0; i < endindex; i++ )
   984 	for( TInt i = 0; i < endindex; i++ )
   987 		{
   985 		{
   988 		CHarvesterData* hd = iPHArray[i];
   986 		CHarvesterData* hd = iPHArray[i];
   989 		
   987 		
   990 		if( aCheck && 
   988 		if( aCheck && iHarvesterPluginFactory->IsContainerFileL( hd->Uri() ) )
   991 		    hd->Origin() != MdeConstants::Object::ECamera &&
       
   992 		    iHarvesterPluginFactory->IsContainerFileL( hd->Uri() ) )
       
   993 			{
   989 			{
   994 			if( iContainerPHArray.Append( hd ) != KErrNone )
   990 			if( iContainerPHArray.Append( hd ) != KErrNone )
   995 			    {
   991 			    {
   996 			    HarvestCompleted( hd->ClientId(), hd->Uri(), KErrNoMemory );
   992 			    HarvestCompleted( hd->ClientId(), hd->Uri(), KErrNoMemory );
   997 			    iHarvesterEventManager->DecreaseItemCountL( EHEObserverTypeMMC, 1 );
   993 			    iHarvesterEventManager->DecreaseItemCountL( EHEObserverTypeMMC, 1 );
  1080 		    }
  1076 		    }
  1081 		
  1077 		
  1082 		if( objDefStr.Length() == 0 ||
  1078 		if( objDefStr.Length() == 0 ||
  1083 		    ( objDefStr == KInUse ) )
  1079 		    ( objDefStr == KInUse ) )
  1084 			{
  1080 			{
  1085 #ifdef _DEBUG
  1081 		    WRITELOG( "CHarvesterAO::HandlePlaceholdersL() - no objectDef or in use, failing harvesting" );
  1086 		    if( objDefStr.Length() == 0 )
       
  1087 		        {
       
  1088 		        WRITELOG( "CHarvesterAO::HandlePlaceholdersL() - no objectDef failing harvesting" );
       
  1089 		        }
       
  1090 		    else
       
  1091 		        {
       
  1092 		        WRITELOG( "CHarvesterAO::HandlePlaceholdersL() - in use, failing harvesting" );
       
  1093 		        }
       
  1094 		    WRITELOG1( "CHarvesterAO::HandlePlaceholdersL() - harvesting failed, uri: %S", &(hd->Uri()) );
       
  1095 #endif
       
  1096 		    // If object has not been created in the device so that monitors would have
       
  1097 		    // picked up creation event, and the file is in use, subclose event will
       
  1098 		    // not trigger the file to be harvester when closed, thus it needs to be moved 
       
  1099 		    // to reharvesting queue
       
  1100 		    if( objDefStr == KInUse &&
       
  1101 		        !hd->TakeSnapshot() )
       
  1102 		        {
       
  1103 		        iPHArray.Remove( i );
       
  1104 		        i--;
       
  1105 		        endindex--;
       
  1106 		        iReHarvester->AddItem( hd );
       
  1107 		        continue;
       
  1108 		        }
       
  1109 			const TInt error( KErrUnknown );
  1082 			const TInt error( KErrUnknown );
  1110             // notify observer, notification is needed even if file is not supported
  1083             // notify observer, notification is needed even if file is not supported
  1111             HarvestCompleted( hd->ClientId(), hd->Uri(), error );
  1084             HarvestCompleted( hd->ClientId(), hd->Uri(), error );
  1112 			delete hd;
  1085 			delete hd;
  1113 			hd = NULL;
  1086 			hd = NULL;
  1216             {
  1189             {
  1217             mdeObject->AddTextPropertyL( *iPropDefs->iItemTypePropertyDef, mimeType );
  1190             mdeObject->AddTextPropertyL( *iPropDefs->iItemTypePropertyDef, mimeType );
  1218             }
  1191             }
  1219         else
  1192         else
  1220             {
  1193             {
  1221             mdeObject->AddTextPropertyL( *iPropDefs->iItemTypePropertyDef, KUndefined );
  1194             mdeObject->AddTextPropertyL( *iPropDefs->iItemTypePropertyDef, KUndefinedMime );
  1222             }
  1195             }
  1223 		
  1196 		
  1224         if( hd->Origin() == MdeConstants::Object::ECamera )
  1197         if( hd->Origin() == MdeConstants::Object::ECamera )
  1225             {
  1198             {
  1226             TBool inDefaultFolder( ETrue );
  1199             TBool inDefaultFolder( ETrue );
  1238 	        {
  1211 	        {
  1239 	        mdeObject->AddTextPropertyL( *iPropDefs->iTitlePropertyDef, name );
  1212 	        mdeObject->AddTextPropertyL( *iPropDefs->iTitlePropertyDef, name );
  1240 	        }
  1213 	        }
  1241 	    else
  1214 	    else
  1242 	        {
  1215 	        {
  1243 	        mdeObject->AddTextPropertyL( *iPropDefs->iTitlePropertyDef, KUndefined );
  1216 	        mdeObject->AddTextPropertyL( *iPropDefs->iTitlePropertyDef, KNullDesC );
  1244 	        }
  1217 	        }
  1245 	    
  1218 	    
  1246     	CPlaceholderData* ph = NULL;
  1219     	CPlaceholderData* ph = NULL;
  1247     	if( hd->TakeSnapshot() )
  1220     	if( hd->TakeSnapshot() )
  1248     	    {
  1221     	    {
  1591 	        	if( locData )
  1564 	        	if( locData )
  1592 	        		{
  1565 	        		{
  1593 	        		WRITELOG( "CHarvesterAO::HarvestingCompleted() - Creating location object. " );
  1566 	        		WRITELOG( "CHarvesterAO::HarvestingCompleted() - Creating location object. " );
  1594 	        		OstTrace0( TRACE_NORMAL, DUP6_CHARVESTERAO_HARVESTINGCOMPLETED, "CHarvesterAO::HarvestingCompleted - Creating location object." );
  1567 	        		OstTrace0( TRACE_NORMAL, DUP6_CHARVESTERAO_HARVESTINGCOMPLETED, "CHarvesterAO::HarvestingCompleted - Creating location object." );
  1595 	        		
  1568 	        		
  1596 	        		TInt loError( KErrNone ); 
  1569 	        		RLocationObjectManipulator lo;
  1597 	        		if( !iLocManipulatorConnected )
  1570 	        		
  1598 	        		    {
  1571 	        		const TInt loError = lo.Connect();     		
  1599 	        		    loError = iLocManipulator.Connect();
       
  1600 	        		    if( loError == KErrNone )
       
  1601 	        		        {
       
  1602 	        		        iLocManipulatorConnected = ETrue;
       
  1603 	        		        }
       
  1604 	        		    }    		
       
  1605 	        		
  1572 	        		
  1606 	        		if (loError == KErrNone)
  1573 	        		if (loError == KErrNone)
  1607 	        			{
  1574 	        			{
  1608 	        			TInt err = iLocManipulator.CreateLocationObject( *locData, aHD->MdeObject().Id() );
  1575 	        			TInt err = lo.CreateLocationObject( *locData, aHD->MdeObject().Id() );
  1609 	        			if( err != KErrNone )
  1576 	        			if( err != KErrNone )
  1610 	        				{
  1577 	        				{
  1611 	        				WRITELOG( "CHarvesterAO::HarvestingCompleted() - Location object creation failed!!!" );
  1578 	        				WRITELOG( "CHarvesterAO::HarvestingCompleted() - Location object creation failed!!!" );
  1612 	        				OstTrace0( TRACE_NORMAL, DUP7_CHARVESTERAO_HARVESTINGCOMPLETED, "CHarvesterAO::HarvestingCompleted - Location object creation failed!!!" );
  1579 	        				OstTrace0( TRACE_NORMAL, DUP7_CHARVESTERAO_HARVESTINGCOMPLETED, "CHarvesterAO::HarvestingCompleted - Location object creation failed!!!" );
  1613 	        				iLocManipulator.Close();
  1580 	        				
  1614 	        				iLocManipulatorConnected = EFalse;
       
  1615 	        				}
  1581 	        				}
  1616 	        			}
  1582 	        			}
  1617 	        		else
  1583 	        		else
  1618 	        			{
  1584 	        			{
  1619 	        			WRITELOG( "CHarvesterAO::HarvestingCompleted() - LocationObjectManipulator connect failed!!!" );
  1585 	        			WRITELOG( "CHarvesterAO::HarvestingCompleted() - LocationObjectManipulator connect failed!!!" );
  1620 	        			OstTrace0( TRACE_NORMAL, DUP8_CHARVESTERAO_HARVESTINGCOMPLETED, "CHarvesterAO::HarvestingCompleted - LocationObjectManipulator connect failed!!" );	        			
  1586 	        			OstTrace0( TRACE_NORMAL, DUP8_CHARVESTERAO_HARVESTINGCOMPLETED, "CHarvesterAO::HarvestingCompleted - LocationObjectManipulator connect failed!!" );	        			
  1621 	        			}
  1587 	        			}
       
  1588 	        		
       
  1589 	        		lo.Close();
  1622 	        		}
  1590 	        		}
  1623 	        	
  1591 	        	
  1624 	        	TRAP_IGNORE( iHarvesterEventManager->DecreaseItemCountL( EHEObserverTypeMMC, 1 ) );
  1592 	        	TRAP_IGNORE( iHarvesterEventManager->DecreaseItemCountL( EHEObserverTypeMMC, 1 ) );
  1625 	        	
  1593 	        	
  1626 				delete aHD;
  1594 				delete aHD;
  1823             TVolumeInfo internalMassStorageVolumeInfo;
  1791             TVolumeInfo internalMassStorageVolumeInfo;
  1824             internalMassStorageError = iFs.Volume( internalMassStorageVolumeInfo, drive );
  1792             internalMassStorageError = iFs.Volume( internalMassStorageVolumeInfo, drive );
  1825             if( internalMassStorageError == KErrNone )
  1793             if( internalMassStorageError == KErrNone )
  1826                 {
  1794                 {
  1827                 const TUint32 massStorageMediaId( internalMassStorageVolumeInfo.iUniqueID );
  1795                 const TUint32 massStorageMediaId( internalMassStorageVolumeInfo.iUniqueID );
  1828                 if( massStorageMediaId != 0 )
  1796                 TUint32 mmcMediaId( 0 );
       
  1797                 TInt mmcError( DriveInfo::GetDefaultDrive( DriveInfo::EDefaultRemovableMassStorage, drive ) );
       
  1798                 if( mmcError == KErrNone )
  1829                     {
  1799                     {
  1830                     TUint32 mmcMediaId( 0 );
  1800                     TVolumeInfo mmcVolumeInfo;
  1831                     TInt mmcDrive( -1 );
  1801                     mmcError = iFs.Volume( mmcVolumeInfo, drive );
  1832                     TInt mmcError( DriveInfo::GetDefaultDrive( DriveInfo::EDefaultRemovableMassStorage, mmcDrive ) );
       
  1833                     if( mmcError == KErrNone )
  1802                     if( mmcError == KErrNone )
  1834                         {
  1803                         {
  1835                         if( drive != mmcDrive )
  1804                         mmcMediaId = mmcVolumeInfo.iUniqueID;
  1836                             {
       
  1837                             TVolumeInfo mmcVolumeInfo;
       
  1838                             mmcError = iFs.Volume( mmcVolumeInfo, mmcDrive );
       
  1839                             if( mmcError == KErrNone )
       
  1840                                 {
       
  1841                                 mmcMediaId = mmcVolumeInfo.iUniqueID;
       
  1842                                 }                        
       
  1843                             }
       
  1844                         else
       
  1845                             {
       
  1846                             mmcMediaId = massStorageMediaId;
       
  1847                             }
       
  1848                         }
  1805                         }
       
  1806                     }
  1849                 
  1807                 
  1850                     // If removable storage is not found, assume internal mass storage was mounted
  1808                 // If removable storage is not found, assume internal mass storage was mounted
  1851                     if( mmcError )
  1809                 if( mmcError )
  1852                         {
  1810                     {
  1853                         iMdEHarvesterSession->CheckMassStorageMediaId( massStorageMediaId );                  
  1811                     if( massStorageMediaId != 0 )
  1854                         }
       
  1855                     else if( massStorageMediaId != mmcMediaId )
       
  1856                         {
  1812                         {
  1857                         iMdEHarvesterSession->CheckMassStorageMediaId( massStorageMediaId );
  1813                         iMdEHarvesterSession->CheckMassStorageMediaId( massStorageMediaId );
  1858                         }          
  1814                         }                    
  1859                     }                    
  1815                     }
       
  1816                 else if( massStorageMediaId != mmcMediaId && 
       
  1817                             massStorageMediaId != 0 )
       
  1818                     {
       
  1819                     iMdEHarvesterSession->CheckMassStorageMediaId( massStorageMediaId );
       
  1820                     }          
  1860                 }
  1821                 }
  1861             }
  1822             }
  1862         }
  1823         }
  1863     else
  1824     else
  1864         {
  1825         {
  1919     OstTrace0( TRACE_NORMAL, CHARVESTERAO_PAUSEHARVESTER, "CHarvesterAO::PauseHarvester" );
  1880     OstTrace0( TRACE_NORMAL, CHARVESTERAO_PAUSEHARVESTER, "CHarvesterAO::PauseHarvester" );
  1920     
  1881     
  1921     iHarvesterPluginFactory->PauseHarvester( ETrue );
  1882     iHarvesterPluginFactory->PauseHarvester( ETrue );
  1922     iServerPaused = ETrue;
  1883     iServerPaused = ETrue;
  1923     
  1884     
       
  1885     if( !iRamFull && !iDiskFull && !iUnmountDetected )
       
  1886         {
       
  1887         iManualPauseEnabled = ETrue;
       
  1888         }
       
  1889     
  1924     // Everything is paused
  1890     // Everything is paused
  1925     WRITELOG( "CHarvesterAO::PauseHarvester() - Moving paused state paused" );
  1891     WRITELOG( "CHarvesterAO::PauseHarvester() - Moving paused state paused" );
  1926     OstTrace0( TRACE_NORMAL, DUP1_CHARVESTERAO_PAUSEHARVESTER, "CHarvesterAO::PauseHarvester - Moving paused state paused" );
  1892     OstTrace0( TRACE_NORMAL, DUP1_CHARVESTERAO_PAUSEHARVESTER, "CHarvesterAO::PauseHarvester - Moving paused state paused" );
  1927         
  1893         
  1928     return KErrNone;
  1894     return KErrNone;
  1934 //
  1900 //
  1935 void CHarvesterAO::ResumeHarvesterL()
  1901 void CHarvesterAO::ResumeHarvesterL()
  1936     {
  1902     {
  1937     WRITELOG( "CHarvesterAO::ResumeHarvesterL()" );
  1903     WRITELOG( "CHarvesterAO::ResumeHarvesterL()" );
  1938     OstTrace0( TRACE_NORMAL, CHARVESTERAO_RESUMEHARVESTERL, "CHarvesterAO::ResumeHarvesterL" );
  1904     OstTrace0( TRACE_NORMAL, CHARVESTERAO_RESUMEHARVESTERL, "CHarvesterAO::ResumeHarvesterL" );
  1939 
       
  1940     if( iRamFull || iDiskFull || iUnmountHandlingOngoing || iManualPauseEnabled )
       
  1941         {
       
  1942         return;
       
  1943         }
       
  1944     
  1905     
  1945     iHarvesterPluginFactory->PauseHarvester( EFalse );
  1906     iHarvesterPluginFactory->PauseHarvester( EFalse );
  1946     iServerPaused = EFalse;
  1907     iServerPaused = EFalse;
  1947     
  1908     
  1948     if( iNextRequest == ERequestIdle )
  1909     if( !iManualPauseEnabled &&
       
  1910         iNextRequest == ERequestIdle )
  1949         {
  1911         {
  1950         SetNextRequest( ERequestHarvest );
  1912         SetNextRequest( ERequestHarvest );
  1951         }  
  1913         }
       
  1914     
       
  1915     iManualPauseEnabled = EFalse;
  1952     }
  1916     }
  1953 
  1917 
  1954 // ---------------------------------------------------------------------------
  1918 // ---------------------------------------------------------------------------
  1955 // RunL
  1919 // RunL
  1956 // ---------------------------------------------------------------------------
  1920 // ---------------------------------------------------------------------------
  1982             
  1946             
  1983             iReadyPHArray.Compress();
  1947             iReadyPHArray.Compress();
  1984             iContainerPHArray.Compress();
  1948             iContainerPHArray.Compress();
  1985             iPHArray.Compress();
  1949             iPHArray.Compress();
  1986             iTempReadyPHArray.Compress();
  1950             iTempReadyPHArray.Compress();
  1987             
       
  1988             if( iLocManipulatorConnected )
       
  1989                 {
       
  1990                 iLocManipulator.Close();
       
  1991                 iLocManipulatorConnected = EFalse;            
       
  1992                 }
       
  1993             }
  1951             }
  1994         break;
  1952         break;
  1995 
  1953 
  1996         // data added to harvester queue
  1954         // data added to harvester queue
  1997         case ERequestHarvest:
  1955         case ERequestHarvest:
  2106         	TInt count = iContainerPHArray.Count() > KContainerPlaceholderQueueSize ? KContainerPlaceholderQueueSize : iContainerPHArray.Count();
  2064         	TInt count = iContainerPHArray.Count() > KContainerPlaceholderQueueSize ? KContainerPlaceholderQueueSize : iContainerPHArray.Count();
  2107         	TInt i = 0;
  2065         	TInt i = 0;
  2108         	while( i < count )
  2066         	while( i < count )
  2109         		{
  2067         		{
  2110         		CHarvesterData* hd = iContainerPHArray[0];
  2068         		CHarvesterData* hd = iContainerPHArray[0];
  2111         		if( iPHArray.Append( hd ) != KErrNone )
  2069         		iPHArray.Append( hd );
  2112         		    {
       
  2113         		    delete hd;
       
  2114         		    hd = NULL;
       
  2115         		    }
       
  2116         		iContainerPHArray.Remove( 0 );
  2070         		iContainerPHArray.Remove( 0 );
  2117         		i++;
  2071         		i++;
  2118         		}
  2072         		}
  2119         	TRAPD( err, HandlePlaceholdersL( EFalse ) );
  2073         	TRAPD( err, HandlePlaceholdersL( EFalse ) );
  2120 
  2074 
  2137         case ERequestPause:
  2091         case ERequestPause:
  2138             {
  2092             {
  2139             WRITELOG( "CHarvesterAO::RunL - ERequestPause" );
  2093             WRITELOG( "CHarvesterAO::RunL - ERequestPause" );
  2140             OstTrace0( TRACE_NORMAL, DUP6_CHARVESTERAO_RUNL, "CHarvesterAO::RunL - ERequestPause" );
  2094             OstTrace0( TRACE_NORMAL, DUP6_CHARVESTERAO_RUNL, "CHarvesterAO::RunL - ERequestPause" );
  2141             User::LeaveIfError( PauseHarvester() );
  2095             User::LeaveIfError( PauseHarvester() );
  2142             iManualPauseEnabled = ETrue;
       
  2143             iHarvesterEventManager->SendEventL( EHEObserverTypeOverall, EHEStatePaused );
  2096             iHarvesterEventManager->SendEventL( EHEObserverTypeOverall, EHEStatePaused );
  2144             if( iHarvesterStatusObserver )
  2097             if( iHarvesterStatusObserver )
  2145             	{
  2098             	{
  2146             	iHarvesterStatusObserver->PauseReady( KErrNone );
  2099             	iHarvesterStatusObserver->PauseReady( KErrNone );
  2147             	}
  2100             	}
  2151         // resume request
  2104         // resume request
  2152         case ERequestResume:
  2105         case ERequestResume:
  2153             {
  2106             {
  2154             WRITELOG( "CHarvesterAO::RunL - ERequestResume" );
  2107             WRITELOG( "CHarvesterAO::RunL - ERequestResume" );
  2155             OstTrace0( TRACE_NORMAL, DUP7_CHARVESTERAO_RUNL, "CHarvesterAO::RunL - ERequestResume" );
  2108             OstTrace0( TRACE_NORMAL, DUP7_CHARVESTERAO_RUNL, "CHarvesterAO::RunL - ERequestResume" );
  2156             iManualPauseEnabled = EFalse;
       
  2157             // If for some reason, mds session is not (yet) ready, only inform that
       
  2158             // server state is no longer paused, but do not restart actual harvesting
       
  2159             // yet.
       
  2160             if( !iMdeSessionInitialized )
       
  2161                 {
       
  2162                 iHarvesterEventManager->SendEventL( EHEObserverTypeOverall, EHEStateResumed );
       
  2163                 if( iHarvesterStatusObserver )
       
  2164                     {
       
  2165                     iHarvesterStatusObserver->ResumeReady( KErrNone );
       
  2166                     }
       
  2167                 break;
       
  2168                 }
       
  2169             ResumeHarvesterL();
  2109             ResumeHarvesterL();
  2170             iHarvesterEventManager->SendEventL( EHEObserverTypeOverall, EHEStateResumed );
  2110             iHarvesterEventManager->SendEventL( EHEObserverTypeOverall, EHEStateResumed );
  2171             if( iHarvesterStatusObserver )
  2111             if( iHarvesterStatusObserver )
  2172             	{
  2112             	{
  2173                 iHarvesterStatusObserver->ResumeReady( KErrNone );
  2113                 iHarvesterStatusObserver->ResumeReady( KErrNone );
  2361         {
  2301         {
  2362         // cache monitored events
  2302         // cache monitored events
  2363         PauseMonitoring();   
  2303         PauseMonitoring();   
  2364         PauseHarvester();    
  2304         PauseHarvester();    
  2365         }
  2305         }
  2366     else if( iServerPaused )
  2306     else if( !iRamFull && !iManualPauseEnabled && iServerPaused )
  2367         {
  2307         {
  2368         // resume monitoring
  2308         // resume monitoring
  2369         ResumeMonitoring();
  2309         ResumeMonitoring();
  2370         TRAP_IGNORE( ResumeHarvesterL() );    
  2310         TRAP_IGNORE( ResumeHarvesterL() );    
  2371         }
  2311         }
  2932             	{
  2872             	{
  2933             	iHarvestFileMessages.Remove( i );
  2873             	iHarvestFileMessages.Remove( i );
  2934             	continue;
  2874             	continue;
  2935             	}
  2875             	}
  2936             
  2876             
       
  2877             //if (aMessage.Identity() == msg.Identity())
  2937             if( &req.iSession == &aSession )
  2878             if( &req.iSession == &aSession )
  2938             	{
  2879             	{
  2939             	err = KErrNone;
  2880             	err = KErrNone;
  2940 	            if (!req.iMessage.IsNull())
  2881 	            if (!req.iMessage.IsNull())
  2941 	            	{
  2882 	            	{
  3452 
  3393 
  3453 	// cache monitored events
  3394 	// cache monitored events
  3454 	PauseMonitoring();
  3395 	PauseMonitoring();
  3455 	PauseHarvester();
  3396 	PauseHarvester();
  3456 	
  3397 	
  3457     iReadyPHArray.Compress();
  3398 	iPHArray.Compress();
  3458     iContainerPHArray.Compress();
  3399 	iReadyPHArray.Compress();
  3459     iPHArray.Compress();
  3400 	iContainerPHArray.Compress();
  3460     iTempReadyPHArray.Compress();
       
  3461 	}
  3401 	}
  3462 
  3402 
  3463 void CHarvesterAO::MemoryGood()
  3403 void CHarvesterAO::MemoryGood()
  3464 	{
  3404 	{
  3465     WRITELOG("CHarvesterAO::MemoryGood()");    
  3405     WRITELOG("CHarvesterAO::MemoryGood()");    
  3466     OstTrace0( TRACE_NORMAL, CHARVESTERAO_MEMORYGOOD, "CHarvesterAO::MemoryGood" );
  3406     OstTrace0( TRACE_NORMAL, CHARVESTERAO_MEMORYGOOD, "CHarvesterAO::MemoryGood" );
  3467     
  3407     
  3468     iRamFull = EFalse;
  3408     iRamFull = EFalse;
  3469     
  3409     
  3470     if( iServerPaused )
  3410     if( !iDiskFull && !iManualPauseEnabled && iServerPaused )
  3471         {
  3411         {
  3472         // resume monitoring
  3412         // resume monitoring
  3473         ResumeMonitoring();
  3413         ResumeMonitoring();
  3474     
  3414     
  3475         TRAP_IGNORE( ResumeHarvesterL() );    
  3415         TRAP_IGNORE( ResumeHarvesterL() );