/*

 * 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:

 *

 */

 #ifndef FEATMGRFEATUREREGISTRY_H

 #define FEATMGRFEATUREREGISTRY_H

 //  INCLUDES

 #include <e32svr.h>

 #include <s32file.h>

 #include <featmgr/featurecmn.h>

 #include <featmgr/featureinfoplugin.h>

 #include "featmgrfeatureentry.h"

 #include "swilistener.h"

 // FORWARD DECLARATIONS

 // CLASS DECLARATION

 class MFeatMgrRegistryObserver

     {

     public:

         virtual void HandleFeatureChange( TFeatureServerEntry& aFeature, 

             TFeatureChangeType aType ) = 0;

     };

 // CLASS DECLARATION

 NONSHARABLE_CLASS(CFeatMgrFeatureRegistry) : public CBase, MSWICallBack

     {

     private:

     	/* 

     	* Status for SWI which must be kept in memory in order for calls made to the new

     	* API functions SWIStart and SWIEnd can be related to actual installation/uninstallation.

     	* 

     	* ESWIOutOfMemory will inform FeatMgr that an out-of-memory condition has occurred during

     	* caching and/or memory pre-allocation for the new features to be added.

     	*/

     	enum TSWIStatus

 	    	{

 	    	ESWIComplete=0,

 	    	ESWIInstalling,

 	    	ESWIAborted,

 	    	ESWIOutOfMemory 

 	    	};

 	    /*

 	    * Enumerations to identify the category of the operation to apply on the cached 

 	    * features after SWI completes.

 	    */

 		enum TSWIOperationCat

 			{ 

 			ESWIAddFeat,

 			ESWIDeleteFeat,

 			ESWISetFeatAndData,

 			ESWISetFeatData,

 			ESWISetFeat

 			};

 		/*

 		* The operation tuple to be cached

 		*/

 		struct TSWICachedOperation

 			{

 			TSWIOperationCat iCat;

 			TFeatureServerEntry iFeatEntry;

 			};

     public:

         /**

         * Two-phased constructor.

         */

         static CFeatMgrFeatureRegistry* NewL( RFs& aFs, MFeatMgrRegistryObserver& aObserver );

         /**

         * Destructor.

         */

         virtual ~CFeatMgrFeatureRegistry();

     public:

         /**

         * Reads feature files.

         */

         void ReadFeatureFilesL();

         /**

         * Reads runtime feature file.

         */

         void ReadRuntimeFeaturesL( TBool &aFeaturesReady );

         /**

         * Merges features to common feature array from plugin.

         */

         void MergePluginFeaturesL( RArray<FeatureInfoCommand::TFeature>& aList );

         /**

         * Merges features to common feature array from plugin.

         */

         void MergePluginFeaturesL( RFeatureArray& aList );

         /**

         * Returns feature support status.

         */

         TInt IsFeatureSupported( TFeatureServerEntry& aFeature );

         /**

         * Adds feature.

         * @param aFeature A reference to a client owned TFeatureEntry object

         * @param aProcessId The id of the process calling this function. This is needed to identify 

         * 					the executable launched by Software Installer (SWI) and cache its to-be

         * 					added features. The default value for aProcessId enables other clients to 

         * 					add features directly to the list (allowing backward compatibility).

         * When set to ETrue the function 

         */

         TInt AddFeature( TFeatureServerEntry& aFeature, TUint aProcessId = 0 );

         /**

         * Deletes feature.

         */

         TInt DeleteFeature( TUid aFeature, TUint = 0 );

         /**

         * Sets feature support status and optionally data.

         */

         TInt SetFeature( TUid aFeature, TInt aEnable, const TUint32 *aData = NULL, TUint = 0 );

         /**

         * Lists supported features to array.

         */

         void SupportedFeaturesL( RFeatureUidArray& aSupportedFeatures );

         /**

         * Returns number of supported features.

         */

         TInt NumberOfSupportedFeatures();

         /**

          * Make a backup of the feature list into member iFeatureListBackup, then reset 

          * the feature list iFeatureList.

 		 *

 		 * Leaves if there is an error during back up, with KErrNoMemory or any of the 

 		 * other system-wide error codes.

          */ 

         void ResetFeaturesL();

         /**

 		 * This function will handle the required notifications for new, deleted and changed features

 		 * after a restore operation has taken place.

          */ 

         void HandleRestoredFeatureNotificationsL();

         /**

 		 * Returns the fully qualified path and filename for the runtime feature data file.

          */ 

         TFileName GetFeaturesFilePathAndName( void );

         /**

         * Indicates that SWI started. It takes the Id of the process calling it as a parameter.

         */

         TInt SWIStart(TUint);

         /**

         * Indicates that SWI ended. It takes the Id of the process calling it as a parameter.

         */

         TInt SWIEnd(TUint);

         /**

          * Add a new command to the cache.

          * 

          * @return error KErrArgument if the maximum number of cached features is reached.

          * 				 KErrNoMemory if there is no memory to create a new command to cached,

          * 							  or if an out-of-memory condition has occured during caching.

          */

          TInt SWICacheCommand(TSWIOperationCat aOptCat, TFeatureServerEntry aFeature);

         /**

         * Commit changes for the cached features into feature manager.

         */

         void CommitSWIFeatChanges();

         /**

         * Reset and clean up SWI-related states and member variables.

         */

         void SWIReset();

         /*

         * Handle the case when SWI aborts.

         */

         void SWIAborted();

         /*

         * Virtual function from MSWICallBack.

         * It is fired when the timer runs out to indicate that SWI finished before a call to 

         * SWIEnd or the launched executable crashed or hanged. It will deal with rolling-back 

         * all cached changes. It is called after 15 seconds.

         */

         void SWITimedOut();

         /*

         * Return the status of the caching mechanism (started or not).

         */

         TBool SWICacheStarted();

         /*

         * Returns the status of the caching mechanism (successful, aborted, out-of-memory).

         */

         TBool SWICacheStatusOOM();

     private:

         CFeatMgrFeatureRegistry( RFs& aFs, MFeatMgrRegistryObserver& aObserver );

         void ConstructL();

         TInt ReadFiles( const TDesC& aFilePath, CDir* aDir );

         void ReadFileL( const TDesC& aFilePath );

         void CompareFeatureListsL();

         void ReadFilesFromDirL( const TDesC& aDirName );

         void UpdateRuntimeFeaturesFileL( TFeatureServerEntry& aFeature, TFeatureChangeType aType );

         TInt HandleChange( TFeatureServerEntry& aFeature, TFeatureChangeType aType );

         TInt ValidateFeature( TUid aFeature, TInt &aIndex );

         TInt SearchFeature( TUid aFeature );

         TInt EnableFeature( TUid aFeature );

         TInt DisableFeature( TUid aFeature );

         TBool IsFlagSet( TInt aIndex, TFeatureFlags aFlag );

         static TInt FindByUid( const TUid *aFeature, const TFeatureServerEntry& aItem );

         static TInt FindByUid( const TFeatureServerEntry& aFeature, 

         const TFeatureServerEntry& aItem );

         void ValidateHeaderL( RFileReadStream& stream, TUint32& count, TUint32& countDSRs );

         void WriteHeaderAndEntriesL( RFileWriteStream &aStream, RFeatureServerArray& aArray );

         void ValidateFeatureFlagL(TBitFlags32 aFlags);

         void ValidateRuntimeFeatureFlagL(TBitFlags32 aFlags);

      private:

         // Observer of feature changes

         MFeatMgrRegistryObserver& iObserver;

         // Array of features

         RArray<TFeatureServerEntry> iFeatureList;

         // Struct to contain information of default supported ranges

         class TDefaultRange

 	        {

 	        public:

     	        TUid iLowUid;

     	        TUid iHighUid;

 	        };

         // Array of supported ranges

         RArray<TDefaultRange> iRangeList;

         // File server session

         RFs& iFs;

         // Array of features (backup up for BUR)

         RArray<TFeatureServerEntry> iFeatureListBackup;

         // Flag to tell feature manager to cache newly modified features during SWI.

         TBool iSWICacheFeature;

         // Tracks the SWI status to check if an installation/uninstallation is in progress before 

         // starting caching.

         TSWIStatus iSWIStatus;

         // Array that holds the operations to apply on cached features when SWI ends.

         RArray<TSWICachedOperation> iSWICachedOperations;

         // Id of the process launched by SWI whose commands to feature manager are to be cached.

         TUint iSWIProcessId;

         // Listens to the SWI P&S property KSAUidSoftwareInstallKeyValue 

         CSWIListener* iSWIListener;

         // Timer to handle the situation when the launched exe by SWI manipulates features and then 

         // hangs/crashes, or a call to SWIEnd was not made.

         CSWITimer* iSWITimer;

         // Traces if an "out-of-memory" condition has occurred during caching. If so, FeatMgr will

         // not commit the cache when the installation is successful. It will be disregarded.

         TBool iOomOccured;

         // Counts the number of features allowed to be cached during SWI install/uninstall. 

         // The maximum is set to 50 (MAXSWIOPS)

         TInt iSWIOperations;

         // Counts how many AddFeature commands are cached during SWI

         TInt iAddFeatCount;

     };

 #endif      // FEATMGRFEATUREREGISTRY_H 

 // End of File