// Copyright (c) 2007-2010 Nokia Corporation and/or its subsidiary(-ies).

 // All rights reserved.

 // This component and the accompanying materials are made available

 // under the terms of "Eclipse Public License v1.0"

 // which accompanies this distribution, and is available

 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

 //

 // Initial Contributors:

 // Nokia Corporation - initial contribution.

 //

 // Contributors:

 //

 // Description:

 //

 // INCLUDE FILES

 #include <ecom/ecom.h>

 #include <e32uid.h>

 #include "featmgrconfiguration.h"

 #include "featmgrserver.h"

 #include "featmgrsession.h"

 #include "featmgrpluginhandler.h"

 #include "featmgrdebug.h"

 #include "featmgrsecuritypolicy.h"

 #include <f32file.h>

 #include <s32file.h>

 _LIT(KPanicCategory, "FeatMgrServer");

 // ============================ MEMBER FUNCTIONS ===============================

 // -----------------------------------------------------------------------------

 // CFeatMgrServer::CFeatMgrServer

 // C++ default constructor can NOT contain any code, that

 // might leave.

 // -----------------------------------------------------------------------------

 //

 CFeatMgrServer::CFeatMgrServer( const TInt aPriority, const TServerType aType  )

     :

     CPolicyServer( aPriority, KFeatMgrPlatSecPolicy, aType ), iBurState(this),

     iBURInProgress(EFalse),

     iPluginsReady(EFalse), 

     iPluginsDeleted( EFalse ),

     iPendingRequests( ETrue ),

     iFeaturesReady(EFalse)

     {

     // Nothing to do

     }

 // -----------------------------------------------------------------------------

 // CFeatMgrServer::ConstructL

 // Symbian 2nd phase constructor can leave.

 // -----------------------------------------------------------------------------

 //

 void CFeatMgrServer::ConstructL()

     {

     FUNC_LOG

 #ifndef EXTENDED_FEATURE_MANAGER_TEST

     // Set server process system critical

     User::SetProcessCritical(User::ESystemCritical);

 #else

     iShutdown.ConstructL();

     // ensure the server still exits even if the 1st client fails to connect

     if( !iShutdown.IsActive() )

         {

         iShutdown.Start();

         }

 #endif

     // Add server to active scheduler

     StartL( KServerProcessName );

     // Connect to file server.

     User::LeaveIfError( iFs.Connect() );

     // register BUR

     iBackupNotification = CBaBackupSessionWrapper::NewL();

     // register the file 

 	TFileName temp( iRegistry->GetFeaturesFilePathAndName() );

     iBackupNotification->RegisterFileL( temp, *this );

     // feature registry

     iRegistry = CFeatMgrFeatureRegistry::NewL( iFs, *this );

     TRAPD(err,iRegistry->ReadFeatureFilesL());

     switch (err)

     	{

     	case KErrNotFound:

     		ERROR_LOG( "CFeatMgrServer::ConstructL() - no feature files found in ROM - going to panic");

     		::FmgrFatalErrorL(err, KPanicCategory, EPanicNoFeatureFiles);

     		break;

     	case KErrCorrupt:

     	    ERROR_LOG( "CFeatMgrServer::ConstructL() - feature information in ROM is invalid - going to panic");

     	    ::FmgrFatalErrorL(err, KPanicCategory, EPanicInvalidFeatureInfo);

     	    break;

     	default:

     		User::LeaveIfError(err);

     		break;

     	}

     // List and load plugins and feature info.

     TBool found = LoadPluginsL();

     if( found )

         {

         // Timer for deleting plugins and for comparing feature lists.

         iTimer = CFeatMgrTimer::NewL( *this );

        }

     else

         {

         iRegistry->ReadRuntimeFeaturesL( iFeaturesReady );

         }

     }

 // -----------------------------------------------------------------------------

 // CFeatMgrServer::NewLC

 // Two-phased constructor.

 // -----------------------------------------------------------------------------

 //

 CFeatMgrServer* CFeatMgrServer::NewLC(const TInt aPriority)

     {

     FUNC_LOG

     CFeatMgrServer* self = new( ELeave ) CFeatMgrServer(aPriority, EUnsharableSessions);

     CleanupStack::PushL( self );

     self->ConstructL();

     return self;

     }

 #ifdef EXTENDED_FEATURE_MANAGER_TEST

 // -----------------------------------------------------------------------------

 // A new session is being created

 // Cancel the shutdown timer if it was running

 // -----------------------------------------------------------------------------

 //

 void CFeatMgrServer::AddSession()

     {

     FUNC_LOG

     ++iSessionCount;

     iShutdown.Cancel();

     }

 // -----------------------------------------------------------------------------

 // A session is being destroyed

 // Start the shutdown timer if it is the last session.

 // -----------------------------------------------------------------------------

 //

 void CFeatMgrServer::DropSession()

     {

     FUNC_LOG

     if (--iSessionCount==0)

         {

         if( !iShutdown.IsActive() )

             {

             iShutdown.Start();

             }

         }

     }

 // ---------------------------------------------------------------------------

 // CShutDown

 // ---------------------------------------------------------------------------

 inline CShutdown::CShutdown()

     :CTimer(-1)

     {

     CActiveScheduler::Add(this);

     }

 inline void CShutdown::ConstructL()

     {

     CTimer::ConstructL();

     }

 inline void CShutdown::Start()

     {

     FUNC_LOG

     After(KShutdownTimeout);

     }

 void CShutdown::RunL()

     {

     FUNC_LOG

     CActiveScheduler::Stop();

     }

 #endif // EXTENDED_FEATURE_MANAGER_TEST

 // -----------------------------------------------------------------------------

 // Destructor

 // -----------------------------------------------------------------------------

 //

 CFeatMgrServer::~CFeatMgrServer()

     {

     FUNC_LOG

     // Close all open sessions

 	CFeatMgrSession* session=NULL;

 	iSessionIter.SetToFirst();

 	while( (session = static_cast<CFeatMgrSession*>(iSessionIter++)) != NULL )

 	    {

 		delete session;

 	    }

     // Delete plugin handlers    

     if ( !iPluginsDeleted )

         {

         iPendingRequests = EFalse; // No need to serve pending requests

         iFeaturesReady = ETrue; // No need to read files anymore

         DeletePlugins();

         } 

     delete iTimer;

     iPluginList.Close();

     // De register Backup and Restore and cleanup memory

     if( iBackupNotification ) 

     	{

 		TFileName temp( iRegistry->GetFeaturesFilePathAndName() );

     	iBackupNotification->DeregisterFile( temp );

     	delete iBackupNotification;

     	iBackupNotification = NULL;

     	}

     delete iRegistry;

     iFs.Close();

     }

 // -----------------------------------------------------------------------------

 // CFeatMgrServer::NewSessionL

 // Creates a new CSession2

 // -----------------------------------------------------------------------------

 //

 CSession2* CFeatMgrServer::NewSessionL( const TVersion& aVersion,

                                      const RMessage2& /*aMessage*/ ) const

     {

     FUNC_LOG

     if ( !User::QueryVersionSupported( TVersion( KServerVersionMajor, 

                                                  KServerVersionMinor, 

                                                  KServerVersionBuild ), 

                                                  aVersion ) )

         {

         User::Leave( KErrNotSupported );

         }

     CSession2* session = CFeatMgrSession::NewL(*const_cast<CFeatMgrServer*>(this), *iRegistry );

     return( session );

     }

 // -----------------------------------------------------------------------------

 // CFeatMgrServer::TimerFired

 // Handles timer firing. 

 // -----------------------------------------------------------------------------

 //

 void CFeatMgrServer::TimerFired()

     {

     FUNC_LOG

     // Delete plugin handlers. Plugin handler deletes the plugin.    

     if ( !iPluginsDeleted )

         {

         DeletePlugins();

         } 

     }

 // -----------------------------------------------------------------------------

 // CFeatMgrServer::HandleFeatureChange()

 // -----------------------------------------------------------------------------

 //

 void CFeatMgrServer::HandleFeatureChange( TFeatureServerEntry& aFeature, TFeatureChangeType aType )

     {

     FUNC_LOG

     CFeatMgrSession* session=NULL;

 	TDblQueIter<CSession2> local_iSessionIter = iSessionIter;

 	local_iSessionIter.SetToFirst();

 	while( (session = static_cast<CFeatMgrSession*>(local_iSessionIter++)) != NULL )

 	    {

 		session->ServiceNotifications( aFeature, aType );

 	    }

     }

 // ---------------------------------------------------------------------------

 // CFeatMgrServer::ResetAndDestroyArray

 // ---------------------------------------------------------------------------

 // 

 static void ResetAndDestroyArray( TAny* aPtr )

     {

     RImplInfoPtrArray* array = static_cast< RImplInfoPtrArray* >( aPtr );

     array->ResetAndDestroy();

     array->Close();

     }

 // -----------------------------------------------------------------------------

 // CFeatMgrServer::LoadPluginsL()

 // -----------------------------------------------------------------------------

 //

 TBool CFeatMgrServer::LoadPluginsL()

     {

     FUNC_LOG

     RImplInfoPtrArray implInfoArray;

     TBool ret( EFalse );

     // Use ECom to read information about existing interface implementations

 #ifndef EXTENDED_FEATURE_MANAGER_TEST

     _LIT8( KResolverString, "" );

 #else

     _LIT8( KResolverString, "efmtestplugin" ); //In test server we only want test plugins.

 #endif

     TEComResolverParams resolverParams;

     resolverParams.SetDataType (KResolverString);

     resolverParams.SetWildcardMatch (ETrue);

     TCleanupItem cleanupItem( ResetAndDestroyArray, &implInfoArray );

     CleanupStack::PushL( cleanupItem );

     TIMESTAMP( "CFeatMgrServer::LoadPluginsL - ListImplementationsL start: " )

     REComSession::ListImplementationsL( KFeatureInfoPluginInterfaceUid,

                                         resolverParams,

 #ifndef EXTENDED_FEATURE_MANAGER_TEST                                         

                                         KRomOnlyResolverUid, 

 #endif                                        

                                         implInfoArray);

     TIMESTAMP( "CFeatMgrServer::LoadPluginsL - ListImplementationsL end: " )

     // Check if any plugin was found. 

     TInt count = implInfoArray.Count();

     if(count == 0)

         {

         iPluginsReady = ETrue; // Plugins not found.

         INFO_LOG1("CFeatMgrServer::LoadPluginsL - interfaceUid.iUid == 0x%x, return plugins not found", KFeatureInfoPluginInterfaceUid);

         ret = EFalse;

         }

     else

         {

         for(TInt i=0;i<count;++i)

             {

             CFeatMgrPluginHandler* pluginHandler = NULL;

             TRAPD(err, pluginHandler = CFeatMgrPluginHandler::NewL(implInfoArray[i]->ImplementationUid(), *this));

             if(err == KErrNone)

                 {

                 CleanupStack::PushL(pluginHandler);

                 TRAP(err, pluginHandler->SendCommandL(FeatureInfoCommand::ELoadFeatureInfoCmdId));

                 if(err == KErrNotSupported)

                     {

                     TRAP(err, pluginHandler->SendCommandL(FeatureInfoCommand::ELoadEnhancedFeatureInfoCmdId));

                     }

                 }

             if(err == KErrNoMemory)

                 {

                 User::Leave(err);

                 }

             else if(err != KErrNone)

                 {

                 ERROR_LOG2("CFeatMgrServer::LoadPluginsL() - implementationUid: 0x%x, error: %d - going to panic", implInfoArray[i]->ImplementationUid(), err);

                 ::FmgrFatalErrorL(err, KPanicCategory, EPanicLoadPluginError);                           

                 }

             // Add information of the plugin to the plugin list. Set all plugins as not ready initially.

             SFeatMgrPluginInfo plugin;

             plugin.iPluginHandler = pluginHandler;

             plugin.iPluginReady = EFalse;

             User::LeaveIfError(iPluginList.Append(plugin));

             CleanupStack::Pop(pluginHandler);

             }

         INFO_LOG1("CFeatMgrServer::LoadPluginsL - interfaceUid.iUid == 0x%x, return plugins found", KFeatureInfoPluginInterfaceUid);

         ret = ETrue;

         }

     CleanupStack::PopAndDestroy(&implInfoArray);

     return ret;

     }

 // -----------------------------------------------------------------------------

 // CFeatMgrServer::PluginsReady()

 // -----------------------------------------------------------------------------

 TBool CFeatMgrServer::PluginsReady() const

     {

     FUNC_LOG

     return(iPluginsReady);

    	}

 // -----------------------------------------------------------------------------

 // CFeatMgrServer::BackupIsInProgress()

 // -----------------------------------------------------------------------------

 TBool CFeatMgrServer::BURIsInProgress() const

     {

     FUNC_LOG

     return(iBURInProgress);

     }

 // -----------------------------------------------------------------------------

 // CFeatMgrServer::ServicePendingRequests()

 // -----------------------------------------------------------------------------

 void CFeatMgrServer::ServicePendingRequests()

     {

     FUNC_LOG

     CFeatMgrSession* session=NULL;

 	iSessionIter.SetToFirst();

 	while( (session = static_cast<CFeatMgrSession*>(iSessionIter++)) != NULL )

 	    {

 		TRAPD( err, session->ServicePendingRequestsL() );

         LOG_IF_ERROR1( err, "CFeatMgrServer::ServicePendingRequests - err %d", err );

 	    }

    	iPendingRequests = EFalse;

    	}

 // -----------------------------------------------------------------------------

 // CFeatMgrServer::DeletePlugins()

 // -----------------------------------------------------------------------------

 void CFeatMgrServer::DeletePlugins()

     {

     FUNC_LOG

     // Set iPluginsReady to ETrue because plugins will be deleted.

     iPluginsReady = ETrue;

     TInt err( KErrNone );

     // Load runtimefeatures.txt if not loaded yet.

     if ( !iFeaturesReady )

         { 

         TRAP( err, iRegistry->ReadRuntimeFeaturesL( iFeaturesReady ) );

         LOG_IF_ERROR1( err, "CFeatMgrServer::DeletePlugins() - ReadRuntimeFeaturesL err %d", err ); 

         }

     // Service pending requests before deleting plugins if not serviced yet.

     if ( iPendingRequests )

         {

         ServicePendingRequests();

         }

     // Delete plugin handlers

     TInt count = iPluginList.Count();

     for ( TInt i = 0 ; i < count; i++ )

         {

         delete iPluginList[i].iPluginHandler;

         iPluginList[i].iPluginHandler = NULL;

         }

     // Reset list of plugins

     iPluginList.Reset();

     // Signal final closure of ecom session

 	REComSession::FinalClose();

 	// All plugin handlers deleted

 	iPluginsDeleted = ETrue;

 	}

 // -----------------------------------------------------------------------------

 // CFeatMgrServer::FeatureInfoL()

 // -----------------------------------------------------------------------------

 void CFeatMgrServer::FeatureInfoL( RArray<FeatureInfoCommand::TFeature>& aFeatureList, 

         CFeatMgrPluginHandler* aPluginHandler )

     {

     FUNC_LOG

     // Save feature info received from the plugin

     TInt pluginCount = iPluginList.Count();

     for ( TInt i = 0; i < pluginCount; i ++ )

         {

         if ( iPluginList[i].iPluginHandler == aPluginHandler )

             {

             iRegistry->MergePluginFeaturesL( aFeatureList );

             // Send command to load enhanced feature info

             TRAPD( err, iPluginList[i].iPluginHandler->SendCommandL( 

                 FeatureInfoCommand::ELoadEnhancedFeatureInfoCmdId ) );

             // Panic if error sth else than not supported

             if ( err != KErrNone && err != KErrNotSupported )

                 {

                 ERROR_LOG1( "CFeatMgrServer::FeatureInfoL() - panicing due error %d", err );

                 ::FmgrFatalErrorL(err, KPanicCategory, EPanicLoadPluginError);

                 }

             // At this point we have simple feature supported by the plugin.

             // If no enhanced feature is supported, but a simple one is, then

             // the plugin is ready to be used. Otherwise continue to add the

             // enhanced features.

             else if( err == KErrNotSupported )

             	{

             	iPluginList[i].iPluginReady = ETrue;

                 }

             }

         else

             {

             INFO_LOG( "CFeatMgrServer::FeatureInfo - unknown plugin handler") ;

             }

         }   

     CheckPluginsReadyL();

     }

 // -----------------------------------------------------------------------------

 // CFeatMgrServer::FeatureInfoL()

 // -----------------------------------------------------------------------------

 void CFeatMgrServer::FeatureInfoL( RFeatureArray& aFeatureList, 

         CFeatMgrPluginHandler* aPluginHandler )

     {

     FUNC_LOG

     // Save feature info received from the plugin

     TInt pluginCount = iPluginList.Count();

     for ( TInt i = 0; i < pluginCount; i ++ )

         {

         if ( iPluginList[i].iPluginHandler == aPluginHandler )

             {

             iRegistry->MergePluginFeaturesL( aFeatureList );

             // Send another command if something left to process

             iPluginList[i].iPluginReady = ETrue;

             }

         else

             {

             INFO_LOG( "CFeatMgrServer::FeatureInfo - unknown plugin handler") ;

             }

         }   

     CheckPluginsReadyL();

     }

 // -----------------------------------------------------------------------------

 // CFeatMgrServer::CheckPluginsReadyL()

 // -----------------------------------------------------------------------------

 void CFeatMgrServer::CheckPluginsReadyL()

     {

     FUNC_LOG

     // If all plugins has responsed iPluginsReady is ETrue

     // else iPluginsReady is EFalse;

     TInt pluginCount = iPluginList.Count();

     for ( TInt i = 0; i < pluginCount; i ++ )

         {

         if ( iPluginList[i].iPluginReady )

             {

             iPluginsReady = ETrue;

             }

         else

             {   

             iPluginsReady = EFalse;

             break;

             }

         }

     // If plugins ready, read runtime features and call ServicePendingRequests of sessions.

     if ( iPluginsReady )

         {

         // Load runtimefeatures.txt

         if ( !iFeaturesReady )

             {

             iRegistry->ReadRuntimeFeaturesL( iFeaturesReady );

             }

         if ( iPendingRequests )

             {

             ServicePendingRequests();    

             }

         }      

     }

 /**

  * Implementation of the pure virtual function.

  */

 void CFeatMgrServer::HandleBackupOperationEventL( const TBackupOperationAttributes& /* aBackupOperationAttributes */ )

 	{

 	return;

 	}

 /**

  * There is a flag state variable being passed into Feature Manager as type MBackupObserver::TFileLockFlags.

  * Only certain combinations of these flags are valid for Feature Manager and if the combination is 

  * not valid, then because there is no way of returning an error it will just set the internal state 

  * machine into an "error" state.

  * Given our current state and our goto state (i.e. where we are at the moment and where we want to goto)

  * the state machine checks that this is a valid path in our state machine and then perform the correct 

  * operations to get us to the next valid state. It also calls the correct Feature manager functions to 

  * accomplish this operation.

  */

 void CFeatMgrServer::ChangeFileLockL( const TDesC& /* aFileName */, TFileLockFlags aFlags )

 	{

 	// There is only one file we are concerned with, so

 	// don't check the filename matches

 	// Default TOperationType type to ENone (we are ignoring this value)

 	TBackupOperationAttributes attribs( aFlags, ENone );

 	iBurState.BUROperationL( attribs );

 	return;

 	}

 /**

  * Generic return function, to return the state of the machine back to normal.

  * This can only occur from certain states.

  */

 BURStatus CFeatMgrServer::Goto_NormalState( BURStatus /* aCurrent */  )

 	{

 	return EFeatMgrBURState_None;   // all roads lead to normal state

 	}

 /**

  * This function handles error recovery from an invalid state. It will return the feature 

  * maneger back to normal, in both it's internal state machine state, and it's internal 

  * variables.

  */

 BURStatus CFeatMgrServer::Goto_ErrorState( BURStatus aCurrent  )

 	{

 	BURStatus aNewState = EFeatMgrBURState_None;   // fail safe: all roads lead to normal state

 	switch( aCurrent )

 		{

 		case( EFeatMgrBURState_BackupStarted ) :

 			iBURInProgress = EFalse;

 			ServicePendingRequests();

 			break;

 		case( EFeatMgrBURState_RestoreStarted ) :

 		    iPluginsReady    = EFalse;

 		    iPluginsDeleted  = EFalse;

 		    iPendingRequests = ETrue;

 		    iFeaturesReady   = EFalse;

 			// re-read the new features;

 			TRAP_IGNORE(ClearFeaturesL() );

 			TRAP_IGNORE(LoadFeaturesL() );

 			// Stop queuing

 			iPluginsReady = ETrue;

 			// commit the pending change requests

 			ServicePendingRequests();

 			break;

 		case( EFeatMgrBURState_BackupEnded ) :

 		case( EFeatMgrBURState_RestoreEnded ) :

 			break;

 		default :

 			break;

 		}

 	aNewState = EFeatMgrBURState_Error;  // state++

 	return aNewState;

 	}

 BURStatus CFeatMgrServer::Goto_StartBackupState( BURStatus /* aCurrent */ )

 	{

 	BURStatus aNewState = EFeatMgrBURState_BackupStarted;  // state++

 	iBURInProgress = ETrue;

 	return aNewState;

 	}

 BURStatus CFeatMgrServer::Goto_EndBackupState( BURStatus /* aCurrent */  )

 	{

 	BURStatus aNewState = EFeatMgrBURState_BackupEnded;   // state++

 	iBURInProgress = EFalse;

 	ServicePendingRequests();

 	// no error from ServicePendingRequests() is possible

 	return aNewState;

 	}

 BURStatus CFeatMgrServer::Goto_StartRestoreState( BURStatus /* aCurrent */  )

 	{

 	// remarkably like Goto_StartBackupState

 	BURStatus aNewState = EFeatMgrBURState_RestoreStarted;  // state++

 	iBURInProgress = ETrue;

 	return aNewState;

 	}

 BURStatus CFeatMgrServer::Goto_EndRestoreState( BURStatus /* aCurrent */  )

 	{

 	BURStatus aNewState = EFeatMgrBURState_Error;   // fail safe

 	TInt err( KErrNone );

 	iBURInProgress = EFalse;

 	iPluginsReady    = EFalse;

     iPluginsDeleted  = EFalse;

     iPendingRequests = ETrue;

     iFeaturesReady   = EFalse;

 	// re-read the new features

     // Only call the next function if the previous one was

     // successfully completed.

 	TRAP(err, ClearFeaturesL() );

 	if (err == KErrNone)

 		{

 		TRAP(err, LoadFeaturesL() );

 		}

 	if(err == KErrNone) 

 		{

 		TRAP(err, HandleRestoredNotificationsL() );

 		}

 	if(err == KErrNone)

 		{

 		// Stop queuing

 		iPluginsReady = ETrue;

 		// commit the pending change requests

 		ServicePendingRequests();

 		// Change state machine

 		aNewState = EFeatMgrBURState_RestoreEnded;

 		}

 	else

 		{

 		// error condition

 		aNewState = EFeatMgrBURState_Error;

 		}

 	return aNewState;

 	}

 /**

  * This function will load features from files and plugins 

  */

 void CFeatMgrServer::LoadFeaturesL( void )

 	{

     // Load ROM (Z)

 	TRAPD( err, iRegistry->ReadFeatureFilesL() );

 	if( KErrNotFound == err)

 		{

 		ERROR_LOG( "CFeatMgrServer::ConstructL() & CallReadFeatureFilesL() - no feature files found in ROM - going to panic");

 		::FmgrFatalErrorL(err, KPanicCategory, EPanicNoFeatureFiles);

 		}

 	else

 		{

 		User::LeaveIfError(err);

 		}

     // Load RAM (C)

 	// List and load plugins and feature info.

 	TBool found = LoadPluginsL();

 	if( found )

 	    {

 	    // Timer for deleting plugins and for comparing feature lists.

 	    iTimer = CFeatMgrTimer::NewL( *this );

 	    }

 	else

 	    {

 	    TRAPD( err, iRegistry->ReadRuntimeFeaturesL( iFeaturesReady ) );

 		if( KErrNotFound == err)

 			{

 			::FmgrFatalErrorL(err, KPanicCategory, EPanicNoFeatureFiles);

 			}

 		else

 			{

 			User::LeaveIfError(err);

 			}

 	    }

 	return;

 }

 /**

  * Discover which features have changes wrt the restore operation

  */

 void CFeatMgrServer::HandleRestoredNotificationsL( void )

 	{

 	iRegistry->HandleRestoredFeatureNotificationsL();

 	}

 /**

  * This function will clear features from RAM

  */

 void CFeatMgrServer::ClearFeaturesL( void )

 	{

 	// Delete plugin handlers    

     if ( !iPluginsDeleted )

         {

         // Delete plugin handlers

         TInt count = iPluginList.Count();

         for ( TInt i = 0 ; i < count; i++ )

             {

             delete iPluginList[i].iPluginHandler;

             iPluginList[i].iPluginHandler = NULL;

             }

         // Reset list of plugins

         iPluginList.Reset();

         iPluginList.Close();        

     	// All plugin handlers deleted

     	iPluginsDeleted = EFalse;

         } 

     if( NULL != iRegistry )

     	{

         iRegistry->ResetFeaturesL();

         }

     return;

 }

 //  End of File