harvester/harvesterserver/src/cindexingmanager.cpp
changeset 1 6f2c1c46032b
parent 0 671dee74050a
child 2 6c1a2771f4b7
equal deleted inserted replaced
0:671dee74050a 1:6f2c1c46032b
    18 #include <f32file.h>
    18 #include <f32file.h>
    19 #include <s32file.h>
    19 #include <s32file.h>
    20 #include "CIndexingManager.h"
    20 #include "CIndexingManager.h"
    21 #include "HarvesterServerLogger.h"
    21 #include "HarvesterServerLogger.h"
    22 #include "CBlacklistMgr.h"
    22 #include "CBlacklistMgr.h"
       
    23 #include "contentinfomgr.h"
       
    24 #include "ccontentinfo.h"
       
    25 #include "OstTraceDefinitions.h"
       
    26 #ifdef OST_TRACE_COMPILER_IN_USE
       
    27 #include "cindexingmanagerTraces.h"
       
    28 #endif
       
    29 
    23 
    30 
    24 _LIT(KManagerFileName, "CPixConfig.bin");
    31 _LIT(KManagerFileName, "CPixConfig.bin");
    25 const TInt KManagerFileVersion = 1;
    32 const TInt KManagerFileVersion = 1;
    26 
    33 
    27 // How often harvester states are checked (in minutes)
    34 // How often harvester states are checked (in minutes)
    36 
    43 
    37 // If time difference between RunL calls is more than this value (i.e system time
    44 // If time difference between RunL calls is more than this value (i.e system time
    38 // changed to future) update harvesters start and complete times. This value is
    45 // changed to future) update harvesters start and complete times. This value is
    39 // default difference in RunL calls with additional buffer.
    46 // default difference in RunL calls with additional buffer.
    40 const TInt KMaxTimeDifference = 1 + KDefaultWaitTimeInMinutes;
    47 const TInt KMaxTimeDifference = 1 + KDefaultWaitTimeInMinutes;
    41 
    48 //constants for enable and disable status
    42 
    49 const TInt KEnable = 1;
       
    50 const TInt KDisable = 0;
    43 // -----------------------------------------------------------------------------
    51 // -----------------------------------------------------------------------------
    44 // CHarvesterServer::NewL()
    52 // CHarvesterServer::NewL()
    45 // -----------------------------------------------------------------------------
    53 // -----------------------------------------------------------------------------
    46 //
    54 //
    47 CIndexingManager* CIndexingManager::NewL()
    55 CIndexingManager* CIndexingManager::NewL()
    89 	
    97 	
    90 	// Close file system connection
    98 	// Close file system connection
    91 	iFs.Close();
    99 	iFs.Close();
    92 	
   100 	
    93 	delete iBlacklistMgr;
   101 	delete iBlacklistMgr;
       
   102 	
       
   103 	delete iContentInfoMgr;
    94 	}
   104 	}
    95 
   105 
    96 // -----------------------------------------------------------------------------
   106 // -----------------------------------------------------------------------------
    97 // CIndexingManager::ConstructL()
   107 // CIndexingManager::ConstructL()
    98 // -----------------------------------------------------------------------------
   108 // -----------------------------------------------------------------------------
   120 	// This server must be connected before passing to harvester plugins
   130 	// This server must be connected before passing to harvester plugins
   121 	User::LeaveIfError(iSearchSession.Connect());
   131 	User::LeaveIfError(iSearchSession.Connect());
   122 	
   132 	
   123 	//instantiate blacklist database
   133 	//instantiate blacklist database
   124 	iBlacklistMgr = CBlacklistMgr::NewL();
   134 	iBlacklistMgr = CBlacklistMgr::NewL();
       
   135 	//Instantiate Contentinfo manager
       
   136 	iContentInfoMgr = CContentInfoMgr::NewL();
   125 
   137 
   126 	// Load plugins
   138 	// Load plugins
   127 	LoadPluginsL();
   139 	LoadPluginsL();
   128 	
   140 	
   129 	//release the Blacklist manager as the blacklist functionality is done
   141 	//release the Blacklist manager as the blacklist functionality is done
   130 	delete iBlacklistMgr;
   142 	delete iBlacklistMgr;
       
   143 	//release the content info manager as all the content details of all plugins are stored
       
   144 	delete iContentInfoMgr;
   131 
   145 
   132 	StartPlugins();
   146 	StartPlugins();
   133 	
   147 	
   134 	// Wait before running RunL
   148 	// Wait before running RunL
   135 	iState = EStateRunning;
   149 	iState = EStateRunning;
   157 //
   171 //
   158 void CIndexingManager::RunL()
   172 void CIndexingManager::RunL()
   159 	{
   173 	{
   160 
   174 
   161 	// Take next harvester from the list to be run
   175 	// Take next harvester from the list to be run
       
   176     OstTrace0( TRACE_NORMAL, CINDEXINGMANAGER_RUNL, "CIndexingManager::RunL" );
   162     CPIXLOGSTRING("CIndexingManager::RunL() ");
   177     CPIXLOGSTRING("CIndexingManager::RunL() ");
   163 
   178 
   164     // If system time is changed update harvester last complete and start time accordingly.
   179     // If system time is changed update harvester last complete and start time accordingly.
   165     // This ensures that no extra reharvesting is done if system time is changed.
   180     // This ensures that no extra reharvesting is done if system time is changed.
   166     TTime timenow;
   181     TTime timenow;
   170     TInt err = timenow.MinutesFrom(iPreviousRun, timeDifference);
   185     TInt err = timenow.MinutesFrom(iPreviousRun, timeDifference);
   171 
   186 
   172     if ( err == KErrNone && iPreviousRun.Int64() != 0 &&
   187     if ( err == KErrNone && iPreviousRun.Int64() != 0 &&
   173          ( timeDifference.Int() < KMinTimeDifference || timeDifference.Int() > KMaxTimeDifference ) )
   188          ( timeDifference.Int() < KMinTimeDifference || timeDifference.Int() > KMaxTimeDifference ) )
   174         {
   189         {
       
   190         OstTrace0( TRACE_NORMAL, DUP1_CINDEXINGMANAGER_RUNL, "CIndexingManager::RunL() time changed. Update harvester completion and start times" );
   175         CPIXLOGSTRING("CIndexingManager::RunL() time changed. Update harvester completion and start times");
   191         CPIXLOGSTRING("CIndexingManager::RunL() time changed. Update harvester completion and start times");
   176         for (TInt i=0; i<iHarvesterArray.Count(); i++)
   192         for (TInt i=0; i<iHarvesterArray.Count(); i++)
   177             {
   193             {
   178             iHarvesterArray[i].iLastComplete += timeDifference;
   194             iHarvesterArray[i].iLastComplete += timeDifference;
   179             iHarvesterArray[i].iLastStart += timeDifference;
   195             iHarvesterArray[i].iLastStart += timeDifference;
   184 
   200 
   185     
   201     
   186     // Do nothing if already harvesting
   202     // Do nothing if already harvesting
   187     if (iState != EStateRunning)
   203     if (iState != EStateRunning)
   188     	{
   204     	{
       
   205         OstTrace0( TRACE_NORMAL, DUP2_CINDEXINGMANAGER_RUNL, "CIndexingManager::RunL() the indexing manager is not running anymore" );
   189         CPIXLOGSTRING("CIndexingManager::RunL() the indexing manager is not running anymore ");
   206         CPIXLOGSTRING("CIndexingManager::RunL() the indexing manager is not running anymore ");
   190     	return;
   207     	return;
   191     	}
   208     	}
   192 
   209 
   193 	// Check if harvesters running
   210 	// Check if harvesters running
   195 	for (TInt i=0; i<iHarvesterArray.Count(); i++)
   212 	for (TInt i=0; i<iHarvesterArray.Count(); i++)
   196 		{
   213 		{
   197 		switch (iHarvesterArray[i].iStatus)
   214 		switch (iHarvesterArray[i].iStatus)
   198 			{
   215 			{
   199 			case EHarvesterStatusWaiting:
   216 			case EHarvesterStatusWaiting:
       
   217 		        OstTraceExt1( TRACE_NORMAL, DUP3_CINDEXINGMANAGER_RUNL, "CIndexingManager::RunL;<%S>, waiting for scheduling..", iHarvesterArray[i].iQualifiedBaseAppClass );
   200 		        CPIXLOGSTRING2("CIndexingManager::RunL(): <%S>, waiting for scheduling...", &iHarvesterArray[i].iQualifiedBaseAppClass);
   218 		        CPIXLOGSTRING2("CIndexingManager::RunL(): <%S>, waiting for scheduling...", &iHarvesterArray[i].iQualifiedBaseAppClass);
   201 				break;
   219 				break;
   202 			case EHarvesterStatusHibernate:
   220 			case EHarvesterStatusHibernate:
       
   221 			    OstTraceExt1( TRACE_NORMAL, DUP4_CINDEXINGMANAGER_RUNL, "CIndexingManager::RunL;<%S>, hibernating..", iHarvesterArray[i].iQualifiedBaseAppClass );
   203 		        CPIXLOGSTRING2("CIndexingManager::RunL(): <%S>, hibernating.", &iHarvesterArray[i].iQualifiedBaseAppClass);
   222 		        CPIXLOGSTRING2("CIndexingManager::RunL(): <%S>, hibernating.", &iHarvesterArray[i].iQualifiedBaseAppClass);
   204 				break;
   223 				break;
   205 			case EHarvesterStatusRunning:
   224 			case EHarvesterStatusRunning:
       
   225 			    OstTraceExt1( TRACE_NORMAL, DUP5_CINDEXINGMANAGER_RUNL, "CIndexingManager::RunL;<%S>, running...", iHarvesterArray[i].iQualifiedBaseAppClass );
   206 		        CPIXLOGSTRING2("CIndexingManager::RunL(): <%S>, running...", &iHarvesterArray[i].iQualifiedBaseAppClass);
   226 		        CPIXLOGSTRING2("CIndexingManager::RunL(): <%S>, running...", &iHarvesterArray[i].iQualifiedBaseAppClass);
   207 		        break;
   227 		        break;
   208 			}
   228 			}
   209 		TTimeIntervalMinutes mins_last_complete;
   229 		TTimeIntervalMinutes mins_last_complete;
   210 		TTimeIntervalMinutes mins_last_start;
   230 		TTimeIntervalMinutes mins_last_start;
   211 		timenow.MinutesFrom(iHarvesterArray[i].iLastComplete, mins_last_complete);
   231 		timenow.MinutesFrom(iHarvesterArray[i].iLastComplete, mins_last_complete);
   212 		timenow.MinutesFrom(iHarvesterArray[i].iLastStart, mins_last_start);
   232 		timenow.MinutesFrom(iHarvesterArray[i].iLastStart, mins_last_start);
       
   233         OstTraceExt2( TRACE_NORMAL, DUP6_CINDEXINGMANAGER_RUNL, "CIndexingManager::RunL;^^^Previous start %d min ago;Previous complete %d min ago", mins_last_start.Int(), mins_last_complete.Int() );
   213         CPIXLOGSTRING3("CIndexingManager::RunL():  ^^^ previous start %d mins ago, previous complete %d mins ago.", mins_last_start.Int(), mins_last_complete.Int());
   234         CPIXLOGSTRING3("CIndexingManager::RunL():  ^^^ previous start %d mins ago, previous complete %d mins ago.", mins_last_start.Int(), mins_last_complete.Int());
   214 
   235 
   215         if (iHarvesterArray[i].iStatus == EHarvesterStatusRunning)
   236         if (iHarvesterArray[i].iStatus == EHarvesterStatusRunning)
   216 			harvesterRunning = ETrue;
   237 			harvesterRunning = ETrue;
   217 		}
   238 		}
   235 
   256 
   236 				// TODO Why are we trapping StartHarvestingL()? 
   257 				// TODO Why are we trapping StartHarvestingL()? 
   237 				// Consider handling the leave in ::RunError instead. 
   258 				// Consider handling the leave in ::RunError instead. 
   238 
   259 
   239 				// Run the harvester
   260 				// Run the harvester
       
   261 			    OstTraceExt1( TRACE_NORMAL, DUP7_CINDEXINGMANAGER_RUNL, "CIndexingManager::RunL;Starting harvesting <%S>.", iHarvesterArray[i].iQualifiedBaseAppClass );
   240 			    CPIXLOGSTRING2("CIndexingManager::RunL(): Starting harvesting <%S>.", &iHarvesterArray[i].iQualifiedBaseAppClass);
   262 			    CPIXLOGSTRING2("CIndexingManager::RunL(): Starting harvesting <%S>.", &iHarvesterArray[i].iQualifiedBaseAppClass);
   241 				TRAPD(err, iHarvesterArray[i].iPlugin->StartHarvestingL(iHarvesterArray[i].iQualifiedBaseAppClass));
   263 				TRAPD(err, iHarvesterArray[i].iPlugin->StartHarvestingL(iHarvesterArray[i].iQualifiedBaseAppClass));
   242 
   264 
   243 				// No need to continue, if something was already started 
   265 				// No need to continue, if something was already started 
   244 				if (err == KErrNone)
   266 				if (err == KErrNone)
   245 					{
   267 					{
       
   268 				    OstTrace0( TRACE_NORMAL, DUP8_CINDEXINGMANAGER_RUNL, "CIndexingManager::RunL(): Successfully started harvesting." );
   246 				    CPIXLOGSTRING("CIndexingManager::RunL(): Successfully started harvesting. ");
   269 				    CPIXLOGSTRING("CIndexingManager::RunL(): Successfully started harvesting. ");
   247 					break;
   270 					break;
   248 					}
   271 					}
   249 				
   272 				
   250 				// Set the error status
   273 				// Set the error status
   251 				iHarvesterArray[i].iLastComplete.UniversalTime();
   274 				iHarvesterArray[i].iLastComplete.UniversalTime();
   252 				iHarvesterArray[i].iError = err;
   275 				iHarvesterArray[i].iError = err;
   253 				// Do not run it again, unless CIndexingMgr informed to do so
   276 				// Do not run it again, unless CIndexingMgr informed to do so
   254 				iHarvesterArray[i].iStatus = EHarvesterStatusHibernate;
   277 				iHarvesterArray[i].iStatus = EHarvesterStatusHibernate;
       
   278 			    OstTrace1( TRACE_NORMAL, DUP9_CINDEXINGMANAGER_RUNL, "CIndexingManager::RunL;Error %d in starting harvesting", err );
   255 			    CPIXLOGSTRING2("CIndexingManager::RunL(): Error %d in starting harvesting. ", err);
   279 			    CPIXLOGSTRING2("CIndexingManager::RunL(): Error %d in starting harvesting. ", err);
   256 				}
   280 				}
   257 			}
   281 			}
   258 		}
   282 		}
   259 	
   283 	
   284     TInt count( 0 );
   308     TInt count( 0 );
   285     count = infoArray.Count();
   309     count = infoArray.Count();
   286     
   310     
   287     //FFLOGSTRING2( "CFastFindHarvesterPluginControl:: PLUGINS COUNT %d", count );
   311     //FFLOGSTRING2( "CFastFindHarvesterPluginControl:: PLUGINS COUNT %d", count );
   288     CIndexingPlugin* plugin = NULL;
   312     CIndexingPlugin* plugin = NULL;
       
   313     
       
   314     TInt contentcount(iContentInfoMgr->GetContentCountL() );
       
   315     // If the content count in the content info DB is not equal to the plugin count, reset the content info DB
       
   316     if ( contentcount != count)
       
   317         iContentInfoMgr->ResetL();
   289     
   318     
   290     for ( TInt i = 0; i < count; i++ )
   319     for ( TInt i = 0; i < count; i++ )
   291         {
   320         {
   292         TUid uid = infoArray[i]->ImplementationUid();    // Create the plug-ins
   321         TUid uid = infoArray[i]->ImplementationUid();    // Create the plug-ins
   293         TInt version = infoArray[i]->Version();
   322         TInt version = infoArray[i]->Version();
   294         //FFLOGSTRING2( "CFastFindHarvesterPluginControl:: PLUGINS UID %x", uid );
   323         //FFLOGSTRING2( "CFastFindHarvesterPluginControl:: PLUGINS UID %x", uid );
   295         plugin = NULL;
   324         plugin = NULL;
   296         TBool pluginblacklisted = EFalse;
   325         TBool pluginblacklisted = EFalse;
   297         
   326         
   298         pluginblacklisted = iBlacklistMgr->FindL( uid , version );        
   327         pluginblacklisted = iBlacklistMgr->FindL( uid , version );
       
   328         
       
   329         TBool iscontentfound = iContentInfoMgr->FindL( infoArray[i]->DisplayName() );
       
   330         
       
   331         if( !iscontentfound )
       
   332             {
       
   333             //Add the content details to database
       
   334             CContentInfo* contentinfo = CContentInfo::NewL();
       
   335             contentinfo->SetNameL( infoArray[i]->DisplayName() );
       
   336             contentinfo->SetBlacklistStatus( KEnable );
       
   337             contentinfo->SetIndexStatus( KEnable );
       
   338             iContentInfoMgr->AddL( contentinfo );
       
   339             delete contentinfo;
       
   340             }
       
   341         else
       
   342             {
       
   343             iContentInfoMgr->UpdateBlacklistStatusL( infoArray[i]->DisplayName() , KEnable );
       
   344             }
   299         
   345         
   300         if ( !pluginblacklisted )
   346         if ( !pluginblacklisted )
   301             {
   347             {
   302             // Plugin is not black listed. Add it to database and try to load the plugin
   348             // Plugin is not black listed. Add it to database and try to load the plugin
   303             iBlacklistMgr->AddL( uid , version );
   349             iBlacklistMgr->AddL( uid , version );
       
   350             OstTrace1( TRACE_NORMAL, CINDEXINGMANAGER_LOADPLUGINSL, "CIndexingManager::LoadPluginsL;Plugin with uid=%x is added to DB", uid.iUid );
   304             CPIXLOGSTRING2("CIndexingManager::LoadPluginsL(): Plugin with uid = %x is added to database", uid.iUid);
   351             CPIXLOGSTRING2("CIndexingManager::LoadPluginsL(): Plugin with uid = %x is added to database", uid.iUid);
   305             TRAPD( err, plugin = CIndexingPlugin::NewL( uid ) );
   352             TRAPD( err, plugin = CIndexingPlugin::NewL( uid ) );
   306             //FFLOGSTRING2( "CFastFindHarvesterPluginControl:: ERROR %d", err );
   353             //FFLOGSTRING2( "CFastFindHarvesterPluginControl:: ERROR %d", err );
   307             if ( err == KErrNone )
   354             if ( err == KErrNone )
   308                 {
   355                 {
   309                 // Plugin loaded succesfully. Remove it from the database
   356                 // Plugin loaded succesfully. Remove it from the database
   310                 iBlacklistMgr->Remove(uid);
   357                 iBlacklistMgr->Remove(uid);
       
   358                 OstTrace1( TRACE_NORMAL, DUP1_CINDEXINGMANAGER_LOADPLUGINSL, "CIndexingManager::LoadPluginsL;Plugin with uid=%x is removed from DB", uid.iUid );
   311                 CPIXLOGSTRING2("CIndexingManager::LoadPluginsL(): Plugin with uid = %x is removed from database", uid.iUid);
   359                 CPIXLOGSTRING2("CIndexingManager::LoadPluginsL(): Plugin with uid = %x is removed from database", uid.iUid);
       
   360                 iContentInfoMgr->UpdateBlacklistStatusL( infoArray[i]->DisplayName() , KDisable );
   312                 CleanupStack::PushL( plugin );
   361                 CleanupStack::PushL( plugin );
   313                 plugin->SetObserver( *this );
   362                 plugin->SetObserver( *this );
   314                 plugin->SetSearchSession( iSearchSession );
   363                 plugin->SetSearchSession( iSearchSession );
   315                 iPluginArray.AppendL( plugin ); // and add them to array
   364                 iPluginArray.AppendL( plugin ); // and add them to array
   316                 CleanupStack::Pop( plugin );
   365                 CleanupStack::Pop( plugin );
       
   366                 OstTrace1( TRACE_NORMAL, DUP2_CINDEXINGMANAGER_LOADPLUGINSL, "CIndexingManager::LoadPluginsL;Plugin with uid=%x is loaded successfully", uid.iUid );
   317                 CPIXLOGSTRING2("CIndexingManager::LoadPluginsL(): Plugin with uid = %x is loaded succesfully", uid.iUid);
   367                 CPIXLOGSTRING2("CIndexingManager::LoadPluginsL(): Plugin with uid = %x is loaded succesfully", uid.iUid);
   318                 }
   368                 }
   319             }
   369             }
   320         }    
   370         }    
   321     CleanupStack::PopAndDestroy( &infoArray ); // infoArray, results in a call to CleanupEComArray
   371     CleanupStack::PopAndDestroy( &infoArray ); // infoArray, results in a call to CleanupEComArray
   345 //
   395 //
   346 void CIndexingManager::AddHarvestingQueue(CIndexingPlugin* aPlugin,
   396 void CIndexingManager::AddHarvestingQueue(CIndexingPlugin* aPlugin,
   347 										  const TDesC& aQualifiedBaseAppClass,
   397 										  const TDesC& aQualifiedBaseAppClass,
   348 										  TBool aForceReharvest)
   398 										  TBool aForceReharvest)
   349 	{
   399 	{
       
   400     OstTraceExt1( TRACE_NORMAL, CINDEXINGMANAGER_ADDHARVESTINGQUEUE, "CIndexingManager::AddHarvestingQueue;Queuing requested for <%S>", aQualifiedBaseAppClass );
   350     CPIXLOGSTRING2("CIndexingManager::AddHarvestingQueue(): Queuing requested for <%S>.", &aQualifiedBaseAppClass);	
   401     CPIXLOGSTRING2("CIndexingManager::AddHarvestingQueue(): Queuing requested for <%S>.", &aQualifiedBaseAppClass);	
   351 	
   402 	
   352 	// Find if this harvesting task already exists
   403 	// Find if this harvesting task already exists
   353 	for (TInt i=0; i<iHarvesterArray.Count(); i++)
   404 	for (TInt i=0; i<iHarvesterArray.Count(); i++)
   354 		{
   405 		{
   361 				// No need to set iHarvesterArrayChanged when changing the status only (which is not saved)
   412 				// No need to set iHarvesterArrayChanged when changing the status only (which is not saved)
   362 				iHarvesterArray[i].iPlugin = aPlugin;
   413 				iHarvesterArray[i].iPlugin = aPlugin;
   363 				iHarvesterArray[i].iStatus = EHarvesterStatusWaiting;
   414 				iHarvesterArray[i].iStatus = EHarvesterStatusWaiting;
   364 				if (aForceReharvest)
   415 				if (aForceReharvest)
   365 					{
   416 					{
       
   417 					OstTrace0( TRACE_NORMAL, DUP1_CINDEXINGMANAGER_ADDHARVESTINGQUEUE, "CIndexingManager::AddHarvestingQueue(): Needs Reharvesting." );
   366 					CPIXLOGSTRING("CIndexingManager::AddHarvestingQueue(): Needs Reharvesting.");
   418 					CPIXLOGSTRING("CIndexingManager::AddHarvestingQueue(): Needs Reharvesting.");
   367 					// iLastCompete Time is reset so that will be reharvested as soon
   419 					// iLastCompete Time is reset so that will be reharvested as soon
   368 					// as possible
   420 					// as possible
   369 					iHarvesterArray[i].iLastComplete = TTime(0);
   421 					iHarvesterArray[i].iLastComplete = TTime(0);
   370 					// No need to reset iLastStart or iError
   422 					// No need to reset iLastStart or iError
   371 					iHarvesterArrayChanged = ETrue;
   423 					iHarvesterArrayChanged = ETrue;
   372 					}
   424 					}
   373 				}
   425 				}
       
   426 		    OstTrace0( TRACE_NORMAL, DUP2_CINDEXINGMANAGER_ADDHARVESTINGQUEUE, "CIndexingManager::AddHarvestingQueue(): Harvester already in the queue." );
   374 		    CPIXLOGSTRING("CIndexingManager::AddHarvestingQueue(): Harvester already in the queue.");	
   427 		    CPIXLOGSTRING("CIndexingManager::AddHarvestingQueue(): Harvester already in the queue.");	
   375 			return;
   428 			return;
   376 			}
   429 			}
   377 		}	
   430 		}	
   378 	
   431 	
   382 
   435 
   383 	// Cancel current wait to launch RunL immediately
   436 	// Cancel current wait to launch RunL immediately
   384 	if (iState == EStateRunning)
   437 	if (iState == EStateRunning)
   385 		iTimer.Cancel();
   438 		iTimer.Cancel();
   386 
   439 
       
   440     OstTrace0( TRACE_NORMAL, DUP3_CINDEXINGMANAGER_ADDHARVESTINGQUEUE, "CIndexingManager::AddHarvestingQueue(): Harvester added successfully to the queue." );
   387     CPIXLOGSTRING("CIndexingManager::AddHarvestingQueue(): Harvester added successfully to the queue.");	
   441     CPIXLOGSTRING("CIndexingManager::AddHarvestingQueue(): Harvester added successfully to the queue.");	
   388 	}
   442 	}
   389 
   443 
   390 // -----------------------------------------------------------------------------
   444 // -----------------------------------------------------------------------------
   391 // CIndexingManager::RemoveHarvestingQueue()
   445 // CIndexingManager::RemoveHarvestingQueue()
   392 // -----------------------------------------------------------------------------
   446 // -----------------------------------------------------------------------------
   393 //
   447 //
   394 void CIndexingManager::RemoveHarvestingQueue(CIndexingPlugin* aPlugin, const TDesC& aQualifiedBaseAppClass)
   448 void CIndexingManager::RemoveHarvestingQueue(CIndexingPlugin* aPlugin, const TDesC& aQualifiedBaseAppClass)
   395 	{
   449 	{
       
   450     OstTraceExt1( TRACE_NORMAL, CINDEXINGMANAGER_REMOVEHARVESTINGQUEUE, "CIndexingManager::RemoveHarvestingQueue;De-Queuing requested for <%S>", aQualifiedBaseAppClass );
   396     CPIXLOGSTRING2("CIndexingManager::RemoveHarvestingQueue(): De-queuing requested for <%S>.", &aQualifiedBaseAppClass);	
   451     CPIXLOGSTRING2("CIndexingManager::RemoveHarvestingQueue(): De-queuing requested for <%S>.", &aQualifiedBaseAppClass);	
   397 
   452 
   398     // Find if this harvesting task exists
   453     // Find if this harvesting task exists
   399 	for (TInt i=0; i<iHarvesterArray.Count(); i++)
   454 	for (TInt i=0; i<iHarvesterArray.Count(); i++)
   400 		{
   455 		{
   405 			if (iHarvesterArray[i].iStatus == EHarvesterStatusWaiting)
   460 			if (iHarvesterArray[i].iStatus == EHarvesterStatusWaiting)
   406 				{
   461 				{
   407 				// No need to set iHarvesterArrayChanged when changing the status only (which is not saved)
   462 				// No need to set iHarvesterArrayChanged when changing the status only (which is not saved)
   408 				iHarvesterArray[i].iStatus = EHarvesterStatusHibernate;
   463 				iHarvesterArray[i].iStatus = EHarvesterStatusHibernate;
   409 				}
   464 				}
       
   465 			OstTrace0( TRACE_NORMAL, DUP1_CINDEXINGMANAGER_REMOVEHARVESTINGQUEUE, "CIndexingManager::RemoveHarvestingQueue(): Harvester de-queued successfully." );
   410 			CPIXLOGSTRING("CIndexingManager::RemoveHarvestingQueue(): Harvester de-queued successfully.");	
   466 			CPIXLOGSTRING("CIndexingManager::RemoveHarvestingQueue(): Harvester de-queued successfully.");	
   411 			return;
   467 			return;
   412 			}
   468 			}
   413 		}
   469 		}
   414 
   470 
       
   471 	OstTrace0( TRACE_NORMAL, DUP2_CINDEXINGMANAGER_REMOVEHARVESTINGQUEUE, "CIndexingManager::RemoveHarvestingQueue(): Harvester in the queue." );
   415 	CPIXLOGSTRING("CIndexingManager::RemoveHarvestingQueue(): Harvester in the queue.");	
   472 	CPIXLOGSTRING("CIndexingManager::RemoveHarvestingQueue(): Harvester in the queue.");	
   416 	}
   473 	}
   417 
   474 
   418 // -----------------------------------------------------------------------------
   475 // -----------------------------------------------------------------------------
   419 // CIndexingManager::HarvestingCompleted()
   476 // CIndexingManager::HarvestingCompleted()
   420 // -----------------------------------------------------------------------------
   477 // -----------------------------------------------------------------------------
   421 //
   478 //
   422 void CIndexingManager::HarvestingCompleted(CIndexingPlugin* aPlugin, const TDesC& aQualifiedBaseAppClass, TInt aError)
   479 void CIndexingManager::HarvestingCompleted(CIndexingPlugin* aPlugin, const TDesC& aQualifiedBaseAppClass, TInt aError)
   423 	{
   480 	{
       
   481     OstTraceExt1( TRACE_NORMAL, CINDEXINGMANAGER_HARVESTINGCOMPLETED, "CIndexingManager::HarvestingCompleted;Harvesting completed for <%S>", aQualifiedBaseAppClass  );
   424     CPIXLOGSTRING2("CIndexingManager::HarvestingCompleted(): Harvesting completed reported for <%S>.", &aQualifiedBaseAppClass);	
   482     CPIXLOGSTRING2("CIndexingManager::HarvestingCompleted(): Harvesting completed reported for <%S>.", &aQualifiedBaseAppClass);	
   425 
   483 
   426     // Find this task 
   484     // Find this task 
   427 	for (TInt i=0; i<iHarvesterArray.Count(); i++)
   485 	for (TInt i=0; i<iHarvesterArray.Count(); i++)
   428 		{
   486 		{
   437 			
   495 			
   438 			// Cancel current wait to launch RunL immediately
   496 			// Cancel current wait to launch RunL immediately
   439 			if (iState == EStateRunning)
   497 			if (iState == EStateRunning)
   440 				iTimer.Cancel();
   498 				iTimer.Cancel();
   441 
   499 
       
   500 			OstTrace0( TRACE_NORMAL, DUP1_CINDEXINGMANAGER_HARVESTINGCOMPLETED, "CIndexingManager::HarvestingCompleted(): Harvesting status changed successfully." );
   442 			CPIXLOGSTRING("CIndexingManager::HarvestingCompleted(): Harvesting status changed successfully.");
   501 			CPIXLOGSTRING("CIndexingManager::HarvestingCompleted(): Harvesting status changed successfully.");
   443 			return;			
   502 			return;			
   444 			}
   503 			}
   445 		}
   504 		}
       
   505 	OstTrace0( TRACE_NORMAL, DUP2_CINDEXINGMANAGER_HARVESTINGCOMPLETED, "CIndexingManager::HarvestingCompleted(): Harvester not in the queue." );
   446 	CPIXLOGSTRING("CIndexingManager::HarvestingCompleted(): Harvester not in the queue.");
   506 	CPIXLOGSTRING("CIndexingManager::HarvestingCompleted(): Harvester not in the queue.");
   447 	}
   507 	}
   448 
   508 
   449 // -----------------------------------------------------------------------------
   509 // -----------------------------------------------------------------------------
   450 // CIndexingManager::Internalize()
   510 // CIndexingManager::Internalize()