sl@0: // Copyright (c) 2007-2010 Nokia Corporation and/or its subsidiary(-ies).
sl@0: // All rights reserved.
sl@0: // This component and the accompanying materials are made available
sl@0: // under the terms of "Eclipse Public License v1.0"
sl@0: // which accompanies this distribution, and is available
sl@0: // at the URL "http://www.eclipse.org/legal/epl-v10.html".
sl@0: //
sl@0: // Initial Contributors:
sl@0: // Nokia Corporation - initial contribution.
sl@0: //
sl@0: // Contributors:
sl@0: //
sl@0: // Description:
sl@0: //
sl@0: 
sl@0: 
sl@0: 
sl@0: 
sl@0: // INCLUDE FILES
sl@0: #include <ecom/ecom.h>
sl@0: #include <e32uid.h>
sl@0: #include <f32file.h>
sl@0: #include <e32property.h>
sl@0: #include <sacls.h>
sl@0: #include "featmgrconfiguration.h"
sl@0: #include "featmgrfeatureregistry.h"
sl@0: #include "featmgrserver.h"
sl@0: #include "featmgrdebug.h"
sl@0: 
sl@0: #define MAXSWIOPS 50
sl@0: #define SWITIMEOUT 15000000
sl@0: 
sl@0: // CONSTANTS
sl@0: _LIT( KZFeaturesFileNameMatch, "feature*" );
sl@0: _LIT( KCRuntimeFeaturesFileName, "features.dat" );
sl@0: #ifdef EXTENDED_FEATURE_MANAGER_TEST
sl@0: _LIT( KZFeaturesDir, "C:\\Private\\102836E5\\" );
sl@0: _LIT( KCFeatMgrPrivatePath, "?:\\Private\\102836E5\\runtime\\" );
sl@0: #else
sl@0: _LIT( KZFeaturesDir, "Z:\\Private\\10205054\\" );
sl@0: _LIT( KCFeatMgrPrivatePath, "?:\\Private\\10205054\\" );
sl@0: #endif // EXTENDED_FEATURE_MANAGER_TEST
sl@0: 
sl@0: const TUint32 KDefaultData( 0x00000000 );
sl@0: // Feature file header constants. 
sl@0: // First 4 bytes of config file: ASCII f-e-a-t followed by file version and flags.
sl@0: const TUint32 KFileType( 0x74616566 );
sl@0: const TUint16 KFileVersion( 1 );
sl@0: const TUint16 KFileFlags( 0 );
sl@0: 
sl@0: 
sl@0: // ============================= LOCAL FUNCTIONS ===============================
sl@0: 
sl@0: // ============================ MEMBER FUNCTIONS ===============================
sl@0: 
sl@0: // -----------------------------------------------------------------------------
sl@0: // CFeatMgrFeatureRegistry::CFeatMgrFeatureRegistry
sl@0: // -----------------------------------------------------------------------------
sl@0: //
sl@0: CFeatMgrFeatureRegistry::CFeatMgrFeatureRegistry( RFs& aFs,
sl@0:     MFeatMgrRegistryObserver& aObserver  )
sl@0:     :
sl@0:     iObserver( aObserver ),
sl@0:     iFs( aFs ),
sl@0:     iSWICacheFeature( EFalse ),
sl@0:     iSWIStatus( ESWIComplete ),
sl@0:     iSWIProcessId( 1 ),
sl@0:     iOomOccured(EFalse)
sl@0:     {
sl@0:     }
sl@0: 
sl@0: // -----------------------------------------------------------------------------
sl@0: // CFeatMgrFeatureRegistry::ConstructL
sl@0: // Symbian 2nd phase constructor can leave.
sl@0: // -----------------------------------------------------------------------------
sl@0: //
sl@0: void CFeatMgrFeatureRegistry::ConstructL()
sl@0:     {
sl@0:     }
sl@0: 
sl@0: // -----------------------------------------------------------------------------
sl@0: // CFeatMgrFeatureRegistry::NewL
sl@0: // Two-phased constructor.
sl@0: // -----------------------------------------------------------------------------
sl@0: //
sl@0: CFeatMgrFeatureRegistry* CFeatMgrFeatureRegistry::NewL( RFs& aFs, 
sl@0:     MFeatMgrRegistryObserver& aObserver )
sl@0:     {
sl@0:     CFeatMgrFeatureRegistry* self = 
sl@0:         new( ELeave ) CFeatMgrFeatureRegistry( aFs, aObserver );
sl@0:     
sl@0:     CleanupStack::PushL( self );
sl@0:     self->ConstructL();
sl@0:     CleanupStack::Pop( self );
sl@0: 
sl@0:     return self;
sl@0:     }
sl@0: 
sl@0: // -----------------------------------------------------------------------------
sl@0: // Destructor
sl@0: // -----------------------------------------------------------------------------
sl@0: //
sl@0: CFeatMgrFeatureRegistry::~CFeatMgrFeatureRegistry()
sl@0:     {
sl@0:     FUNC_LOG
sl@0:     
sl@0:     iFeatureList.Close();
sl@0:     iRangeList.Close();
sl@0:     iFeatureListBackup.Close();    
sl@0:     iSWICachedOperations.Close();
sl@0:     if( iSWIListener )
sl@0:     	{
sl@0:         delete iSWIListener;    	
sl@0:     	}
sl@0:     if( iSWITimer )
sl@0:     	{
sl@0:     	delete iSWITimer;
sl@0:     	}
sl@0:     }
sl@0: 
sl@0: 
sl@0: // -----------------------------------------------------------------------------
sl@0: // CFeatMgrFeatureRegistry::IsFeatureSupported
sl@0: // -----------------------------------------------------------------------------
sl@0: //  
sl@0: TInt CFeatMgrFeatureRegistry::IsFeatureSupported( TFeatureServerEntry& aFeature )
sl@0:     {
sl@0:     TInt err( KErrNotFound );
sl@0:     const TInt index = SearchFeature( aFeature.FeatureUid() );
sl@0:     
sl@0:     if ( index == KErrNotFound )
sl@0:         {
sl@0:         // Check whether feature in supported ranges
sl@0:         TInt count( iRangeList.Count() );
sl@0:         TUid uid( aFeature.FeatureUid() );
sl@0:         for( TInt i = 0; i < count; i++ )
sl@0:             {
sl@0:             if( (uid.iUid >= iRangeList[i].iLowUid.iUid) && 
sl@0:                 (uid.iUid <= iRangeList[i].iHighUid.iUid) )
sl@0:                 {
sl@0:                 TBitFlags32 flags( 0 );
sl@0:                 flags.Assign( EFeatureSupported, KFeatureSupported );
sl@0:                 TFeatureServerEntry entry( aFeature.FeatureUid(), flags, KDefaultData );
sl@0:                 aFeature = entry;
sl@0:                 err = KFeatureSupported;
sl@0:                 break;
sl@0:                 }
sl@0:             }
sl@0:         }
sl@0:     else if( IsFlagSet( index, EFeatureUninitialized ) )
sl@0:         {
sl@0:         // Supported status bit is not taken into account if feature not yet initialized
sl@0:         err = KErrNotReady;
sl@0:         }
sl@0:     else if ( (index < iFeatureList.Count()) && IsFlagSet( index, EFeatureSupported ) )
sl@0:         {
sl@0:         TBitFlags32 flags = iFeatureList[index].FeatureFlags();
sl@0:         flags.Assign( EFeatureSupported, KFeatureSupported );
sl@0:         TUint32 data = iFeatureList[index].FeatureData();
sl@0:         TFeatureServerEntry entry( aFeature.FeatureUid(), flags, data );
sl@0:         aFeature = entry;
sl@0:         err = KFeatureSupported;
sl@0:         }
sl@0:     else
sl@0:         {
sl@0:         TBitFlags32 flags = iFeatureList[index].FeatureFlags();
sl@0:         flags.Assign( EFeatureSupported, KFeatureUnsupported );
sl@0:         TUint32 data = iFeatureList[index].FeatureData();
sl@0:         TFeatureServerEntry entry( aFeature.FeatureUid(), flags, data );
sl@0:         aFeature = entry;
sl@0:         err = KFeatureUnsupported;
sl@0:         }
sl@0: 
sl@0:     return err;
sl@0:     }
sl@0: 
sl@0: // -----------------------------------------------------------------------------
sl@0: // CFeatMgrFeatureRegistry::AddFeature
sl@0: // -----------------------------------------------------------------------------
sl@0: //
sl@0: TInt CFeatMgrFeatureRegistry::AddFeature( TFeatureServerEntry& aFeature, TUint aPrcId )
sl@0:     {
sl@0:     TInt err( KErrAccessDenied );
sl@0:     
sl@0:     if( iSWIProcessId == aPrcId && iSWICacheFeature )
sl@0: 		{
sl@0: 		err = SWICacheCommand(ESWIAddFeat, aFeature);
sl@0: 		}
sl@0:     else
sl@0:     	{
sl@0:         const TInt index = SearchFeature( aFeature.FeatureUid() );
sl@0: 	
sl@0: 	    if ( index == KErrNotFound )
sl@0: 	        {
sl@0: 	        TBitFlags32 flags( aFeature.FeatureFlags() );
sl@0: 	        flags.Set( EFeatureRuntime );
sl@0: 	
sl@0: 	        //Check the feature falg is valid
sl@0: 	        TRAP(err,ValidateRuntimeFeatureFlagL(flags));
sl@0: 	        if (err != KErrNone)
sl@0: 	            return err;
sl@0: 	
sl@0: 	        TFeatureServerEntry entry( aFeature.FeatureUid(), flags, aFeature.FeatureData() );	       
sl@0: 			err = iFeatureList.InsertInOrder( entry, FindByUid );
sl@0: 	        if ( err == KErrNone )
sl@0: 	            {
sl@0: 	            TFeatureChangeType changeType( EFeatureFeatureCreated );
sl@0: 	            err = HandleChange( entry, changeType );
sl@0: 	            }
sl@0: 	        }
sl@0: 	    else
sl@0: 	        {
sl@0: 	        err = KErrAlreadyExists;
sl@0: 	        }
sl@0: 	    
sl@0: 	    INFO_LOG("CFeatMgrFeatureRegistry::AddFeature - Features directly stored in registry");
sl@0:     	}
sl@0:     
sl@0:     LOG_IF_ERROR1( err, "CFeatMgrFeatureRegistry::AddFeature - result %d", err );
sl@0: 
sl@0:     return err;
sl@0:     }
sl@0: 
sl@0: // -----------------------------------------------------------------------------
sl@0: // CFeatMgrFeatureRegistry::DeleteFeature
sl@0: // -----------------------------------------------------------------------------
sl@0: //
sl@0: TInt CFeatMgrFeatureRegistry::DeleteFeature( TUid aFeature, TUint aPrcId  )
sl@0:     {
sl@0:     TInt err( KErrAccessDenied );
sl@0: 	
sl@0:     if( iSWIProcessId == aPrcId && iSWICacheFeature )
sl@0:     	{
sl@0:     	err = SWICacheCommand(ESWIDeleteFeat, aFeature);
sl@0:     	}
sl@0:     else
sl@0:     	{
sl@0: 	    // Check if the feature is runtime
sl@0: 	    TInt index = SearchFeature( aFeature );
sl@0: 	    if ( index == KErrNotFound )
sl@0: 	        {
sl@0: 	        return KErrNotFound;
sl@0: 	        }
sl@0: 	    if ( !iFeatureList[index].FeatureFlags().IsSet(EFeatureRuntime) )
sl@0: 	        {
sl@0: 	        return KErrAccessDenied;
sl@0: 	        }
sl@0: 	
sl@0: 	    TFeatureServerEntry entry = iFeatureList[index];
sl@0: 	    
sl@0:     	iFeatureList.Remove( index );
sl@0:         TFeatureChangeType changeType( EFeatureFeatureDeleted );
sl@0:         err = HandleChange( entry, changeType );
sl@0:         
sl@0:         INFO_LOG("CFeatMgrFeatureRegistry::DeleteFeature - Features deleted directly from registry");
sl@0:         }
sl@0:     
sl@0:     LOG_IF_ERROR1( err, "CFeatMgrFeatureRegistry::DeleteFeature - result %d", err );
sl@0:     
sl@0:     return err;
sl@0:     }
sl@0: 
sl@0: // -----------------------------------------------------------------------------
sl@0: // CFeatMgrFeatureRegistry::SetFeature
sl@0: //This method cannot set feature flag range in DSR unless it is added to before
sl@0: //using CFeatMgrFeatureRegistry::AddFeature()
sl@0: // -----------------------------------------------------------------------------
sl@0: //	
sl@0: TInt CFeatMgrFeatureRegistry::SetFeature( TUid aFeature, TInt aEnable, const TUint32 *aData, TUint aPrcId  )
sl@0:     {
sl@0:     FUNC_LOG
sl@0: 
sl@0:     TInt err( KErrNone );
sl@0:     
sl@0:     if( iSWIProcessId == aPrcId && iSWICacheFeature )
sl@0:     	{
sl@0:         TBitFlags32 flags(0);
sl@0:         flags.Assign( EFeatureSupported, aEnable );
sl@0:         TUint32 data = 0;
sl@0:         if( aData )
sl@0:             {
sl@0:             data = *aData;
sl@0:             }
sl@0: 
sl@0:         TFeatureServerEntry entry( aFeature, flags, data );
sl@0: 
sl@0:         // If aData is not null, we want to change the user data too
sl@0:         //  otherwise only change the feature status.
sl@0:         if( aData )
sl@0:             {
sl@0:             err = SWICacheCommand(ESWISetFeatAndData, entry);
sl@0:             }
sl@0:         else
sl@0:             {
sl@0:             err = SWICacheCommand(ESWISetFeat, entry);
sl@0:             }
sl@0:     	}
sl@0:     else 
sl@0:     	{
sl@0: 	    TInt index;
sl@0: 	
sl@0: 	    // Validate feature exists and is modifiable
sl@0: 	    err = ValidateFeature( aFeature, index );
sl@0: 	
sl@0: 	    if ( err != KErrNone )
sl@0: 	        {
sl@0: 			return err;
sl@0: 	        }
sl@0: 	
sl@0: 	    if ( (index >= 0 && index < iFeatureList.Count()) )
sl@0: 	        {
sl@0:         	TBitFlags32 flags = iFeatureList[index].FeatureFlags();
sl@0: 	        TUint32 data = iFeatureList[index].FeatureData();
sl@0: 	        TFeatureChangeType changeType( EFeatureStatusUpdated );
sl@0: 
sl@0: 	        // Update "supported" info according to request
sl@0: 	        if( (aEnable == EFeatureSupportEnable) || (aEnable == EFeatureSupportDisable) )
sl@0: 	            {
sl@0: 	            INFO_LOG1( "CFeatMgrFeatureRegistry::SetFeature() - aEnable %d", aEnable );
sl@0: 	            flags.Assign( EFeatureSupported, aEnable );
sl@0: 	            }
sl@0: 	        // When setting feature, always unset "uninitialized" bit
sl@0: 	        flags.Assign( EFeatureUninitialized, 0 );
sl@0: 
sl@0: 	        // Update data whenever applied
sl@0: 	        if( aData )
sl@0: 	            {
sl@0: 	            INFO_LOG1( "CFeatMgrFeatureRegistry::SetFeature() - aData %d", aData );
sl@0: 	            data = *aData;
sl@0: 
sl@0: 	            if( aEnable == EFeatureSupportUntouch )
sl@0: 	                {
sl@0: 	                changeType = EFeatureDataUpdated;
sl@0: 	                }
sl@0: 	            else
sl@0: 	                {
sl@0: 	                changeType = EFeatureStatusDataUpdated;
sl@0: 	                }
sl@0: 	            }
sl@0: 
sl@0: 	        TFeatureServerEntry entry( aFeature, flags, data );
sl@0: 	        //Check if the feature will actually change
sl@0: 	        if(iFeatureList[index].FeatureFlags() == flags && iFeatureList[index].FeatureData() == data )
sl@0: 	        	{
sl@0: 	        	//No change were made, set change type to EFeatureNoChange
sl@0: 	        	changeType = EFeatureNoChange;
sl@0: 	        	}
sl@0: 	        else
sl@0: 	        	{
sl@0: 	        	// Set the feature entry in list with updated information
sl@0: 	        	iFeatureList[index].Set(entry);
sl@0: 	        	}
sl@0: 
sl@0: 	        err = HandleChange( entry, changeType );
sl@0: 	        }
sl@0:     	}
sl@0:     
sl@0:     LOG_IF_ERROR1( err, "CFeatMgrFeatureRegistry::SetFeature - result %d", err );
sl@0: 
sl@0:     return err;
sl@0:     }
sl@0: 
sl@0: // -----------------------------------------------------------------------------
sl@0: // CFeatMgrFeatureRegistry::HandleChange
sl@0: // -----------------------------------------------------------------------------
sl@0: //  
sl@0: TInt CFeatMgrFeatureRegistry::HandleChange( TFeatureServerEntry& aFeature, 
sl@0:     TFeatureChangeType aType )
sl@0:     {
sl@0:     FUNC_LOG
sl@0:     
sl@0:     TInt err( KErrNone );
sl@0:     
sl@0:     // Update feature file, when feature is specified as persisted.
sl@0:     if ( aFeature.FeatureFlags().IsSet( EFeaturePersisted ) )
sl@0:         {
sl@0:         TRAP( err, UpdateRuntimeFeaturesFileL( aFeature, aType ) );
sl@0:         LOG_IF_ERROR1( err, "CFeatMgrFeatureRegistry::HandleChange - update error %d", err );
sl@0:     
sl@0:         // It is questionnable whether we should remove the feature from iFeatureList.
sl@0:         // However, feature is usable until device is powered down and features reloaded.
sl@0:         // if ( err == KErrNone )
sl@0:         }
sl@0:     
sl@0:     // It is also questionnable whether we should suppress notification in case file 
sl@0:     // update failed.
sl@0:     // if ( err == KErrNone )
sl@0:     iObserver.HandleFeatureChange( aFeature, aType );
sl@0:     
sl@0:     return err;
sl@0:     }
sl@0:     
sl@0: // -----------------------------------------------------------------------------
sl@0: // CFeatMgrFeatureRegistry::ValidateFeature
sl@0: // -----------------------------------------------------------------------------
sl@0: //  
sl@0: TInt CFeatMgrFeatureRegistry::ValidateFeature( TUid aFeature, TInt &aIndex )
sl@0:     {
sl@0:     TInt err( KErrNone );
sl@0:     
sl@0:     aIndex = SearchFeature( aFeature );
sl@0:      
sl@0:     if ( aIndex == KErrNotFound )
sl@0:         {
sl@0:         err = KErrNotFound;
sl@0:         }
sl@0:     else if ( !IsFlagSet( aIndex, EFeatureModifiable ) )
sl@0:         {
sl@0:         err = KErrAccessDenied;
sl@0:         }
sl@0:     
sl@0:     return err;
sl@0:     }
sl@0:     
sl@0: // -----------------------------------------------------------------------------
sl@0: // CFeatMgrFeatureRegistry::FindByUid
sl@0: // Returns Zero if UIDs do match.
sl@0: // -----------------------------------------------------------------------------
sl@0: //  
sl@0: TInt CFeatMgrFeatureRegistry::FindByUid( const TUid *aFeature, 
sl@0:     const TFeatureServerEntry& aItem )
sl@0:     {
sl@0:     if ( aFeature->iUid < aItem.FeatureUid().iUid )
sl@0:         {
sl@0:         return -1;
sl@0:         }
sl@0:     else if ( aFeature->iUid > aItem.FeatureUid().iUid )
sl@0:         {
sl@0:         return 1;
sl@0:         }
sl@0: 
sl@0:     return 0;
sl@0:     }
sl@0: 
sl@0: // -----------------------------------------------------------------------------
sl@0: // CFeatMgrFeatureRegistry::FindByUid
sl@0: // Returns Zero if UIDs do match.
sl@0: // -----------------------------------------------------------------------------
sl@0: //  
sl@0: TInt CFeatMgrFeatureRegistry::FindByUid( const TFeatureServerEntry& aFeature, 
sl@0:     const TFeatureServerEntry& aItem )
sl@0:     {
sl@0:     if ( aFeature.FeatureUid().iUid < aItem.FeatureUid().iUid )
sl@0:         {
sl@0:         return -1;
sl@0:         }
sl@0:     else if ( aFeature.FeatureUid().iUid > aItem.FeatureUid().iUid )
sl@0:         {
sl@0:         return 1;
sl@0:         }
sl@0: 
sl@0:     return 0;
sl@0:     }
sl@0: 
sl@0: // -----------------------------------------------------------------------------
sl@0: // CFeatMgrFeatureRegistry::SearchFeature
sl@0: // -----------------------------------------------------------------------------
sl@0: //  
sl@0: TInt CFeatMgrFeatureRegistry::SearchFeature( TUid aFeature )
sl@0:     {
sl@0:     const TUid& uid( aFeature );
sl@0:     return iFeatureList.FindInOrder( uid, FindByUid );
sl@0:     }
sl@0:     
sl@0: // -----------------------------------------------------------------------------
sl@0: // CFeatMgrFeatureRegistry::IsFlagSet
sl@0: // -----------------------------------------------------------------------------
sl@0: //  
sl@0: TBool CFeatMgrFeatureRegistry::IsFlagSet( TInt aIndex, TFeatureFlags aFlag )
sl@0:     {
sl@0:     TBool isSet( EFalse );
sl@0:     if( aIndex < iFeatureList.Count() )
sl@0:         {
sl@0:         isSet = iFeatureList[aIndex].FeatureFlags().IsSet(aFlag);
sl@0:         }
sl@0:         
sl@0:     return isSet;
sl@0:     }
sl@0: 
sl@0: // -----------------------------------------------------------------------------
sl@0: // CFeatMgrFeatureRegistry::SupportedFeatures
sl@0: // -----------------------------------------------------------------------------
sl@0: //  
sl@0: void CFeatMgrFeatureRegistry::SupportedFeaturesL( RFeatureUidArray& aSupportedFeatures )
sl@0:     {
sl@0:     FUNC_LOG
sl@0:     
sl@0:     TInt count = iFeatureList.Count();
sl@0:     
sl@0:     for ( TInt i = 0; i < count; i++ )
sl@0:         {
sl@0:         if( IsFlagSet( i, EFeatureSupported) )
sl@0:             {
sl@0:             aSupportedFeatures.AppendL( iFeatureList[i].FeatureUid() );
sl@0:             }
sl@0:         }
sl@0:     }
sl@0: 
sl@0: // -----------------------------------------------------------------------------
sl@0: // CFeatMgrFeatureRegistry::NumberOfSupportedFeatures
sl@0: // -----------------------------------------------------------------------------
sl@0: //  
sl@0: TInt CFeatMgrFeatureRegistry::NumberOfSupportedFeatures()
sl@0:     {
sl@0:     FUNC_LOG
sl@0:     
sl@0:     TInt count = iFeatureList.Count();
sl@0:     TInt countSupported(0);
sl@0:     
sl@0:     for ( TInt i = 0; i < count; i++ )
sl@0:         {
sl@0:         if( IsFlagSet( i, EFeatureSupported) )
sl@0:             {
sl@0:             countSupported++;
sl@0:             }
sl@0:         }
sl@0:     
sl@0:     return countSupported;
sl@0:     }
sl@0: 
sl@0: // -----------------------------------------------------------------------------
sl@0: 
sl@0: void CFeatMgrFeatureRegistry::ResetFeaturesL()
sl@0:     {
sl@0:     FUNC_LOG
sl@0:     
sl@0:     // backup the feature list before it is destroyed
sl@0:     iFeatureListBackup.Reset();
sl@0:     const TInt KCount = iFeatureList.Count();
sl@0:    	iFeatureListBackup.ReserveL(KCount);
sl@0: 	for(TInt i(0); i < KCount; i++)
sl@0: 		{
sl@0: 		// The main error here would be KErrNoMemory which should not happen as
sl@0: 		// we have already reserved the space. However, we should still check.
sl@0: 		iFeatureListBackup.AppendL(iFeatureList[i]);
sl@0: 		}
sl@0: 	    
sl@0:     // destroy the feature list
sl@0:     iFeatureList.Reset();
sl@0:     iFeatureList.Close();
sl@0:     
sl@0:     iRangeList.Reset();
sl@0:     iRangeList.Close();
sl@0:     }
sl@0: 
sl@0: /**
sl@0:  * Get the fully qualified path and filename to the features.dat
sl@0:  * data file.
sl@0:  */ 
sl@0: TFileName CFeatMgrFeatureRegistry::GetFeaturesFilePathAndName( void )
sl@0: 	{
sl@0:     TFileName path( KCFeatMgrPrivatePath );
sl@0: 
sl@0:     path[0] = iFs.GetSystemDriveChar();
sl@0:     path.Append( KCRuntimeFeaturesFileName );
sl@0: 
sl@0:     return path;
sl@0: 	}
sl@0: 
sl@0: // CFeatMgrFeatureRegistry::ReadFeatureFilesL
sl@0: // Reads platform and product feature files. 
sl@0: // -----------------------------------------------------------------------------
sl@0: //  
sl@0: void CFeatMgrFeatureRegistry::ReadFeatureFilesL()
sl@0:     {
sl@0:     FUNC_LOG    
sl@0:     
sl@0:     // Read feature files from Z
sl@0:     ReadFilesFromDirL( KZFeaturesDir );
sl@0: 
sl@0:     //check that there is at least one DSR 
sl@0:     if (!iRangeList.Count()) 
sl@0:     	{
sl@0:     	_LIT(KPanicCategory, "FeatMgrServer");
sl@0:     	ERROR_LOG( "CFeatMgrFeatureRegistry::ReadFilesFromDirL() - no DSR found in ROM; this indicates a system integration error  - going to panic" );
sl@0:     	::FmgrFatalErrorL(KErrNotFound, KPanicCategory, EPanicNoDSR);    
sl@0:     	}
sl@0:     }
sl@0: 
sl@0: // -----------------------------------------------------------------------------
sl@0: // CFeatMgrFeatureRegistry::ReadFilesFromDirL
sl@0: // -----------------------------------------------------------------------------
sl@0: //
sl@0: void CFeatMgrFeatureRegistry::ReadFilesFromDirL( const TDesC& aDirName )
sl@0:     {
sl@0:     _LIT(KPanicCategory, "FEATMGR-READFILE");
sl@0: 
sl@0:     CDir* dir = NULL; 
sl@0:     TInt err( KErrNone );
sl@0: 
sl@0:     err = iFs.GetDir( aDirName, KEntryAttNormal, ESortByName, dir );
sl@0:     CleanupStack::PushL( dir );
sl@0: 
sl@0:     if( err == KErrNone )
sl@0:         {
sl@0:         err = ReadFiles( aDirName, dir );
sl@0:         if ( err != KErrNone )
sl@0:             {            
sl@0:             ERROR_LOG1( "CFeatMgrFeatureRegistry::ReadFilesFromDirL() - err %d ", err );
sl@0:             User::Leave( err );    
sl@0:             }
sl@0:         }  
sl@0:     else if( err == KErrPathNotFound )
sl@0:     	{
sl@0:     	::FmgrFatalErrorL(err, KPanicCategory, EPanicNoFeatureFiles);
sl@0:     	}
sl@0: 	else
sl@0:         {            
sl@0:         ERROR_LOG1( "CFeatMgrFeatureRegistry::ReadFilesFromDirL() - err %d ", err );
sl@0:         User::Leave( err );    
sl@0:         }
sl@0:     
sl@0:     CleanupStack::PopAndDestroy( dir );
sl@0:     }
sl@0: 
sl@0: // -----------------------------------------------------------------------------
sl@0: // CFeatMgrFeatureRegistry::ReadRuntimeFeaturesL
sl@0: // -----------------------------------------------------------------------------
sl@0: //
sl@0: void CFeatMgrFeatureRegistry::ReadRuntimeFeaturesL( TBool &aFeaturesReady )
sl@0:     {
sl@0:     TFileName path( KCFeatMgrPrivatePath );
sl@0:     path[0] = iFs.GetSystemDriveChar();
sl@0:     path.Append( KCRuntimeFeaturesFileName );
sl@0: 
sl@0:     TInt err( KErrNone );
sl@0:     TRAP( err, ReadFileL( path ) );
sl@0: 
sl@0:     if ((err == KErrCorrupt) || (err == KErrArgument))
sl@0:     	{
sl@0:     	User::LeaveIfError(iFs.Delete(path));
sl@0:     	aFeaturesReady = ETrue;
sl@0:     	}
sl@0:     else if ( err != KErrNone && err != KErrNotFound && err != KErrPathNotFound )
sl@0:         {  
sl@0:         ERROR_LOG1( "CFeatMgrFeatureRegistry::ReadRuntimeFeatures - ReadFileL returned err %d", err );
sl@0:         User::Leave( err );
sl@0:         }
sl@0:     else
sl@0:         {
sl@0:         aFeaturesReady = ETrue;
sl@0:         }
sl@0:     }
sl@0: 
sl@0: // -----------------------------------------------------------------------------
sl@0: // CFeatMgrFeatureRegistry::ReadFiles
sl@0: // -----------------------------------------------------------------------------
sl@0: //  
sl@0: TInt CFeatMgrFeatureRegistry::ReadFiles( const TDesC& aPath, CDir* aDir )
sl@0:     {
sl@0:     TInt fileCount = aDir->Count();
sl@0:     TFileName fileName;
sl@0:     TInt err( KErrNotFound );
sl@0:     
sl@0:     for ( TInt file = 0; file < fileCount; file++ )
sl@0:         {
sl@0:         TInt match = (*aDir)[file].iName.MatchC( KZFeaturesFileNameMatch );
sl@0:         if( match != KErrNotFound )
sl@0:             {
sl@0:             fileName.Copy(aPath);
sl@0:             fileName.Append((*aDir)[file].iName);
sl@0: 
sl@0:             INFO_LOG1( "CFeatMgrFeatureRegistry::ReadFiles - file: %S", &fileName );
sl@0:             TRAP( err, ReadFileL( fileName ) );
sl@0:             LOG_IF_ERROR2( err, "CFeatMgrFeatureRegistry::ReadFiles - file: %S, err %d", 
sl@0:                 &fileName, err );
sl@0:             
sl@0:             // Return error if reading of any feature file fails.
sl@0:             if( err != KErrNone )
sl@0:                 {
sl@0:                 break;
sl@0:                 }
sl@0:             }
sl@0:         }
sl@0: 
sl@0:     return( err );
sl@0:     }
sl@0: 
sl@0: // -----------------------------------------------------------------------------
sl@0: // CFeatMgrFeatureRegistry::ReadFileL
sl@0: // -----------------------------------------------------------------------------
sl@0: //  
sl@0: void CFeatMgrFeatureRegistry::ReadFileL( const TDesC& aFullPath )
sl@0:     {
sl@0:     FUNC_LOG
sl@0:    
sl@0:     TUint32 count;
sl@0:  	RFileReadStream readStream;
sl@0: 
sl@0:  	// Open the file and attach to stream 
sl@0:     User::LeaveIfError( readStream.Open( iFs, aFullPath, EFileRead ) );
sl@0:     CleanupClosePushL( readStream );
sl@0:     TUint32 countDSRs;
sl@0:     
sl@0:     //Validate the header
sl@0:     ValidateHeaderL( readStream, count, countDSRs );
sl@0: 
sl@0:     RArray<TFeatureServerEntry> tempFeatureArray;
sl@0:     CleanupClosePushL( tempFeatureArray );
sl@0:     
sl@0:     //Find the directory that the feature file is contained in. 
sl@0:     TFileName dirName(aFullPath);
sl@0:     TChar toFind = '\\';
sl@0:     dirName.Delete((dirName.LocateReverse(toFind)+1), dirName.Length() );
sl@0:     TBool runtimeFile = EFalse;
sl@0:     if (dirName.Compare(KZFeaturesDir) != 0) //Location of the feature file.
sl@0:     	{
sl@0:     	runtimeFile = ETrue;
sl@0:     	}
sl@0:     
sl@0:     tempFeatureArray.ReserveL(count);
sl@0:     
sl@0: 	for(TInt i = 0; i < count; i++)
sl@0:         {
sl@0:         TFeatureServerEntry entry;
sl@0:         entry.InternalizeL( readStream );
sl@0:         
sl@0:         //Check for feature flag errors
sl@0:         TBitFlags32 flags =  entry.FeatureFlags();
sl@0:         TInt err = KErrNone;
sl@0:         
sl@0:         //Validate the flags
sl@0:         // This validation is done in this read function because the validation functions used
sl@0:         // are called in other places were this validation is not appropriate. 
sl@0:         if (runtimeFile)
sl@0:         	{
sl@0:         	if (!flags.IsSet(EFeatureRuntime)) //Check to see if the Runtime flag is set if it is not then the feature should have been read in from the rom. 
sl@0:         		{
sl@0:         		if (SearchFeature( entry.FeatureUid() ) == KErrNotFound )// Check to see if the feature has been read in previously from the rom.
sl@0:         			{
sl@0:         			User::Leave(KErrCorrupt); 
sl@0:         			}
sl@0:         		else //The feature has not been read in previously from the rom file and is therefore invalid. The file is deemed to be corrupt
sl@0:         			{
sl@0:         			ValidateRuntimeFeatureFlagL(flags);   
sl@0:             		}
sl@0:         		}
sl@0:         	else //Flag set the feature is runtime this is then validated as normal
sl@0:         		{
sl@0:         		ValidateRuntimeFeatureFlagL(flags);    	
sl@0:         		}
sl@0: 
sl@0:         	}
sl@0:         else //File is not as runtime file.
sl@0:         	{
sl@0:         	ValidateFeatureFlagL(flags);
sl@0:         	}
sl@0:         
sl@0:         //If a feature flag defined in system drive (c:) is invalid, it will not be added to Feature Manager 
sl@0:         if ( (err != KErrNone) && flags.IsSet(EFeatureRuntime) )
sl@0:         	{
sl@0:         	continue;
sl@0:        		}
sl@0:         
sl@0: 		tempFeatureArray.InsertL( entry, i);
sl@0:         }
sl@0: 
sl@0:     // Reserve memory if list still empty
sl@0:     if( !iFeatureList.Count() )
sl@0:         {
sl@0:         iFeatureList.ReserveL( tempFeatureArray.Count() );
sl@0:         }
sl@0: 
sl@0:     // Read features from temp array
sl@0:     for(TInt i = 0; i < tempFeatureArray.Count(); i++)
sl@0:         {
sl@0:         TFeatureServerEntry entry = tempFeatureArray[i];
sl@0:  
sl@0:         TInt index = SearchFeature( entry.FeatureUid() );
sl@0:         
sl@0:         if( index == KErrNotFound)
sl@0:             {
sl@0:             iFeatureList.InsertInOrderL( entry, FindByUid );
sl@0:             }
sl@0:         else
sl@0:             {
sl@0:             INFO_LOG1( "CFeatMgrFeatureRegistry::ReadFileL - replacing uid 0x%08x",
sl@0:                 iFeatureList[index].FeatureUid().iUid );
sl@0:             // Set the feature if it is not previously blacklisted
sl@0:             if ( !IsFlagSet( index, EFeatureBlackListed ) )
sl@0:                 {
sl@0:                 iFeatureList[index].Set(entry);
sl@0:                 }
sl@0:             }
sl@0:         }
sl@0:     
sl@0:     // Reserve memory if DSR list still empty
sl@0:     if( !iRangeList.Count() )
sl@0:         {
sl@0:         iRangeList.ReserveL( countDSRs );
sl@0:         }
sl@0:     
sl@0:     // Read default supported ranges from file
sl@0:     for(TInt i = 0; i < countDSRs; i++)
sl@0:         {
sl@0:         TDefaultRange range;
sl@0:         range.iLowUid = TUid::Uid( readStream.ReadUint32L() );
sl@0:         range.iHighUid = TUid::Uid( readStream.ReadUint32L() );
sl@0:         iRangeList.AppendL( range );
sl@0:         if( iRangeList[i].iLowUid.iUid > iRangeList[i].iHighUid.iUid )
sl@0:             {
sl@0:             ERROR_LOG( "CFeatMgrFeatureRegistry::ReadFileL - invalid supported range" );
sl@0:             iRangeList.Remove( i );
sl@0:             User::Leave( KErrCorrupt );
sl@0:             }
sl@0:         }
sl@0: 
sl@0: #if defined(FEATMGR_INFO_LOG_ENABLED)
sl@0:     count = iFeatureList.Count();
sl@0:     INFO_LOG1( "CFeatMgrFeatureRegistry::ReadFileL - feature entries: %d", count );
sl@0:     for(TInt i = 0; i < count; i++)
sl@0:         {
sl@0:         INFO_LOG3( "CFeatMgrFeatureRegistry::ReadFileL - uid 0x%08x, flags %d, data %d",
sl@0:             iFeatureList[i].FeatureUid().iUid, iFeatureList[i].FeatureFlags().iFlags, 
sl@0:             iFeatureList[i].FeatureData() );
sl@0:         }
sl@0: 
sl@0:     count = iRangeList.Count();
sl@0:     INFO_LOG1( "CFeatMgrFeatureRegistry::ReadFileL - supported ranges: %d", count );
sl@0:     for(TInt i = 0; i < count; i++)
sl@0:         {
sl@0:         INFO_LOG2( "CFeatMgrFeatureRegistry::ReadFileL - low 0x%08x, high 0x%08x",
sl@0:             iRangeList[i].iLowUid, iRangeList[i].iHighUid );
sl@0:         }
sl@0: #endif
sl@0: 
sl@0:     CleanupStack::PopAndDestroy( &tempFeatureArray);
sl@0:     CleanupStack::PopAndDestroy( &readStream );
sl@0: 
sl@0:     }
sl@0: 
sl@0: // -----------------------------------------------------------------------------
sl@0: // CFeatMgrFeatureRegistry::ValidateHeaderL
sl@0: // -----------------------------------------------------------------------------
sl@0: //  
sl@0: void CFeatMgrFeatureRegistry::ValidateHeaderL( RFileReadStream &aStream, 
sl@0:     TUint32& aCount, TUint32& aCountDSRs )
sl@0:     {
sl@0:     FUNC_LOG
sl@0: 
sl@0:     TUint32 identifier = aStream.ReadUint32L();
sl@0:     TUint16 fileVersion = aStream.ReadUint16L();
sl@0:     TUint16 fileFlags = aStream.ReadUint16L();
sl@0:     aCount = aStream.ReadUint32L();
sl@0:     aCountDSRs = aStream.ReadUint32L();
sl@0:         
sl@0:     // Carry out simple verification of file content
sl@0:     if((identifier != KFileType) || fileVersion != KFileVersion || 
sl@0:         fileFlags != KFileFlags )
sl@0:         {
sl@0:         User::Leave( KErrCorrupt );
sl@0:         }
sl@0:     }
sl@0: 
sl@0: // -----------------------------------------------------------------------------
sl@0: // CFeatMgrFeatureRegistry::UpdateRuntimeFeaturesFileL
sl@0: // -----------------------------------------------------------------------------
sl@0: //  
sl@0: void CFeatMgrFeatureRegistry::UpdateRuntimeFeaturesFileL( TFeatureServerEntry& aFeature,
sl@0: 		TFeatureChangeType aType )
sl@0:     {
sl@0:     FUNC_LOG
sl@0: 
sl@0:     // Opens a file containing a stream and prepares the stream for writing.
sl@0:     TInt err( KErrNone );
sl@0:     RFileWriteStream writeStream;
sl@0:     TFileName path( KCFeatMgrPrivatePath );
sl@0:     path[0] = iFs.GetSystemDriveChar();
sl@0:     path.Append( KCRuntimeFeaturesFileName );
sl@0: 
sl@0:     err = writeStream.Open( iFs, path, EFileWrite  ); 
sl@0:     CleanupClosePushL( writeStream );
sl@0:     
sl@0:     if( err == KErrPathNotFound || err == KErrNotFound )
sl@0:     	{
sl@0:         // Create folder and file.
sl@0:     	if ( err == KErrPathNotFound )
sl@0:     		{
sl@0:     		path = KCFeatMgrPrivatePath;
sl@0:     		path[0] = iFs.GetSystemDriveChar();
sl@0: 		    User::LeaveIfError( iFs.MkDirAll( path ) );
sl@0:             path.Append( KCRuntimeFeaturesFileName );
sl@0:     		}
sl@0:         User::LeaveIfError( writeStream.Create( iFs, path, EFileWrite ) );
sl@0:         
sl@0:         // Write header and entry
sl@0:         RFeatureServerArray temp(1);
sl@0:         CleanupClosePushL( temp );
sl@0:         temp.AppendL( aFeature );
sl@0:         WriteHeaderAndEntriesL( writeStream, temp );
sl@0:         CleanupStack::PopAndDestroy( &temp );
sl@0:         CleanupStack::PopAndDestroy( &writeStream );
sl@0:         }
sl@0:     else if( err == KErrNone )
sl@0: 	    {
sl@0: 	    // Close write- and open readstream
sl@0: 	    CleanupStack::PopAndDestroy( &writeStream );
sl@0:         RFileReadStream readStream;
sl@0:         User::LeaveIfError( readStream.Open( iFs, path, EFileRead ) );
sl@0:         CleanupClosePushL( readStream );
sl@0: 
sl@0:         // Read entries from file to temporary array
sl@0:         TUint32 count;
sl@0:         TUint32 countDSRs;
sl@0:         ValidateHeaderL( readStream, count, countDSRs );
sl@0:         TUint32 granularity = 8;
sl@0:         if (count>granularity) 
sl@0:         	{
sl@0:         	granularity=count;
sl@0:         	}
sl@0:         RFeatureServerArray temp(granularity);
sl@0:         CleanupClosePushL( temp );
sl@0:         for(TInt i = 0; i < count; i++)
sl@0:             {
sl@0:             TFeatureServerEntry entry;
sl@0:             entry.InternalizeL( readStream );
sl@0:             temp.AppendL( entry );
sl@0:             }
sl@0:         // Close read-stream and handle temp array in cleanup stack
sl@0:         CleanupStack::Pop( &temp );
sl@0:         CleanupStack::PopAndDestroy( &readStream );
sl@0:         CleanupClosePushL( temp );
sl@0: 
sl@0:         // Set or insert a new entry in to the array
sl@0:         const TUid& uid( aFeature.FeatureUid() );
sl@0:         TInt index = temp.FindInOrder( uid, FindByUid );
sl@0:         if( index != KErrNotFound )
sl@0:             {         
sl@0:             if ( aType != EFeatureFeatureDeleted )
sl@0:             	{
sl@0:             	temp[index].Set( aFeature);
sl@0:             	}
sl@0:             else
sl@0:             	{
sl@0:             	temp.Remove( index );
sl@0:             	}
sl@0:             }
sl@0:         else
sl@0:             {
sl@0:             User::LeaveIfError( temp.InsertInOrder( aFeature, FindByUid ) );
sl@0:             }
sl@0: 		
sl@0: 		//Create a Temporary File
sl@0: 		RFileWriteStream writeStreamTemp;
sl@0: 		const TPtrC KTestFile=_L("TFEATURES.DAT");
sl@0:         TFileName tempPath( KCFeatMgrPrivatePath );
sl@0: 	    tempPath[0] = iFs.GetSystemDriveChar();
sl@0:     	tempPath.Append( KTestFile );
sl@0:     	User::LeaveIfError(writeStreamTemp.Replace( iFs,  tempPath, EFileWrite ));
sl@0:     	CleanupClosePushL( writeStreamTemp);
sl@0:     	WriteHeaderAndEntriesL( writeStreamTemp, temp );
sl@0:     	writeStreamTemp.CommitL();
sl@0:     	CleanupStack::PopAndDestroy(&writeStreamTemp);
sl@0:         CleanupStack::PopAndDestroy( &temp );
sl@0:         User::LeaveIfError(iFs.Replace(tempPath,path));		
sl@0:        
sl@0: 	    }
sl@0:     else
sl@0:         {
sl@0:         ERROR_LOG1( "CFeatMgrFeatureRegistry::UpdateRuntimeFeatures - err %d", err );
sl@0:         User::Leave( err );
sl@0:         }
sl@0:     }
sl@0: 
sl@0: // -----------------------------------------------------------------------------
sl@0: // CFeatMgrFeatureRegistry::WriteHeaderAndEntriesL
sl@0: // -----------------------------------------------------------------------------
sl@0: //  
sl@0: void CFeatMgrFeatureRegistry::WriteHeaderAndEntriesL( RFileWriteStream &aStream, 
sl@0:     RFeatureServerArray& aArray )
sl@0:     {
sl@0:     FUNC_LOG
sl@0: 
sl@0:     TInt count( aArray.Count() );
sl@0:     aStream.WriteUint32L( KFileType );
sl@0:     aStream.WriteUint16L( KFileVersion );
sl@0:     aStream.WriteUint16L( KFileFlags );
sl@0:     aStream.WriteUint32L( count );
sl@0:     aStream.WriteUint32L( 0 );
sl@0:     for(TInt i = 0; i < count; i++)
sl@0:         {
sl@0:         aArray[i].ExternalizeL( aStream );
sl@0:         }
sl@0:     aStream.CommitL();
sl@0:     }
sl@0: 
sl@0: // -----------------------------------------------------------------------------
sl@0: // CFeatMgrFeatureRegistry::MergePluginFeatures
sl@0: // -----------------------------------------------------------------------------
sl@0: //  
sl@0: void CFeatMgrFeatureRegistry::MergePluginFeaturesL( 
sl@0:         RArray<FeatureInfoCommand::TFeature>& aList )
sl@0:     {
sl@0:     FUNC_LOG
sl@0:     
sl@0:     TInt count = aList.Count();
sl@0: 
sl@0:     for ( TInt i = 0; i < count; i++ )
sl@0:         {
sl@0:         const TUid uid( TUid::Uid( aList[i].iFeatureID ) );
sl@0:         TInt index = SearchFeature( uid );
sl@0:         
sl@0:         if(index != KErrNotFound)
sl@0:             {
sl@0:             if ( !IsFlagSet( index, EFeatureBlackListed ) )
sl@0:                 {
sl@0:                 // Update support-status bit
sl@0:                 TBitFlags32 flags( iFeatureList[index].FeatureFlags() );
sl@0:                 flags.Assign( EFeatureSupported, aList[i].iValue);
sl@0:                 
sl@0:                 // Set existing entry in array
sl@0:                 TFeatureServerEntry entry( uid, flags, iFeatureList[index].FeatureData());
sl@0:                 iFeatureList[index].Set(entry);
sl@0:                 }
sl@0:             else
sl@0:                 {
sl@0:                 INFO_LOG1( "CFeatMgrFeatureRegistry::MergePluginFeatures - 0x%08x blacklisted",
sl@0:                     iFeatureList[i].FeatureUid().iUid );
sl@0:                 }
sl@0:             }
sl@0:         else
sl@0:             {
sl@0:             TBitFlags32 flags;
sl@0:             flags.Assign( EFeatureSupported, aList[i].iValue);
sl@0:             // Insert new entry in array
sl@0:             TFeatureServerEntry newFeature( uid, flags, KDefaultData );
sl@0:             TInt err = iFeatureList.InsertInOrder( newFeature, FindByUid );
sl@0:             INFO_LOG2( "CFeatMgrFeatureRegistry::MergePluginFeatures - 0x%08x insert result %d",
sl@0:                 newFeature.FeatureUid().iUid, err );
sl@0:             User::LeaveIfError(err);
sl@0:             }
sl@0:         }
sl@0:     }
sl@0:     
sl@0: // -----------------------------------------------------------------------------
sl@0: // CFeatMgrFeatureRegistry::MergePluginFeatures
sl@0: // -----------------------------------------------------------------------------
sl@0: //  
sl@0: void CFeatMgrFeatureRegistry::MergePluginFeaturesL( RFeatureArray& aList )
sl@0:     {
sl@0:     FUNC_LOG
sl@0:     
sl@0:     TInt count = aList.Count();
sl@0: 
sl@0:     for ( TInt i = 0; i < count; i++ )
sl@0:         {
sl@0:         //Check for feature flag errors
sl@0:         ValidateFeatureFlagL(aList[i].FeatureFlags()) ; 
sl@0:         const TUid uid( aList[i].FeatureUid() );
sl@0:         TInt index = SearchFeature( uid );
sl@0:         
sl@0:         if( index != KErrNotFound )
sl@0:             {
sl@0:             if ( !IsFlagSet( index, EFeatureBlackListed ) )
sl@0:                 {
sl@0:                 // Set existing entry in array with new info and data
sl@0:                 TFeatureServerEntry entry( uid, aList[i].FeatureFlags(), aList[i].FeatureData() );
sl@0:                 iFeatureList[index].Set(entry);
sl@0:                 }
sl@0:             else
sl@0:                 {
sl@0:                 INFO_LOG1( "CFeatMgrFeatureRegistry::MergePluginFeatures - 0x%08x blacklisted",
sl@0:                     iFeatureList[i].FeatureUid().iUid );
sl@0:                 }
sl@0:             }
sl@0:         else
sl@0:             {
sl@0:             // Insert new entry in array
sl@0:             TFeatureServerEntry newFeature( uid, aList[i].FeatureFlags(), aList[i].FeatureData() );
sl@0:             TInt err = iFeatureList.InsertInOrder( newFeature, FindByUid );
sl@0:             INFO_LOG2( "CFeatMgrFeatureRegistry::MergePluginFeatures - 0x%08x insert result %d",
sl@0:                 newFeature.FeatureUid().iUid, err );
sl@0:             User::LeaveIfError(err);
sl@0:             }
sl@0:         }
sl@0:     }
sl@0: 
sl@0: // -----------------------------------------------------------------------------
sl@0: // CFeatMgrFeatureRegistry::ValidateFeatureFlag
sl@0: // Following are the rule to check err in the ROM defined feature flags
sl@0: // Rule 1) If a feature flag is blacklisted then setting any of modifiable, persisted, Un-initialised bit will be an error
sl@0: // Rule 2) If a feature flag is non blacklisted, non modifiable  setting any of Un-initialised, Persisted bit will be an error
sl@0: // -----------------------------------------------------------------------------
sl@0: //  
sl@0:    
sl@0: void CFeatMgrFeatureRegistry::ValidateFeatureFlagL(TBitFlags32 aFlags)
sl@0: 	{
sl@0: 	_LIT(KPanicCategory, "FEATMGR-FLAGS");
sl@0: 	
sl@0: 	if(!aFlags.IsSet(EFeatureRuntime)) //ROM defined feature flag error check
sl@0: 		{
sl@0: 		//Rule 1
sl@0: 		if(aFlags.IsSet(EFeatureBlackListed) )
sl@0: 	    	{
sl@0: 	    	 if(aFlags.IsSet(EFeatureModifiable) || aFlags.IsSet(EFeaturePersisted) || aFlags.IsSet(EFeatureUninitialized) )
sl@0: 	    	 	{
sl@0: 	    	 	//error 
sl@0: 	    	 	::FmgrFatalErrorL(KErrArgument, KPanicCategory, EFmpInvalidFeatureBitFlagsRule1);
sl@0: 	    	  	}
sl@0: 	    	}
sl@0: 	    	
sl@0: 	    //Rule 2    	
sl@0: 	    if (!aFlags.IsSet(EFeatureModifiable))
sl@0: 	       	{
sl@0: 	       	if (aFlags.IsSet(EFeaturePersisted) || aFlags.IsSet(EFeatureUninitialized) )
sl@0: 	       	 	{
sl@0: 	        	//error 
sl@0: 	       	 	::FmgrFatalErrorL(KErrArgument, KPanicCategory, EFmpInvalidFeatureBitFlagsRule2);
sl@0: 	        	}	
sl@0: 	        }
sl@0: 		}
sl@0: 	else // Runtime feature this should not be in the rom
sl@0: 		{		
sl@0: 		::FmgrFatalErrorL(KErrArgument, KPanicCategory, EPanicInvalidFeatureInfo);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: /**
sl@0:  * This function is used to validate feature flags that are read from the features file on the ffs.
sl@0:  * This function is also used to validate feature flags that are modified or added with the execption of MergePluginFeatures.
sl@0:  * This validation compares the flags against a set of rules. This ffs file needs to be validate separately from the 
sl@0:  * rom file. If the rom validation method is used a panic can occur which is appropriate for checking the rom but not
sl@0:  * for the ffs.  
sl@0:  * This does not validate the dsr ranges. 
sl@0:  * The following are the rules to check for errors in the run time defined feature flags
sl@0:  * Rule 1)Blacklisting of a run-time defined feature flag is an error 
sl@0:  * Rule 2)Un-initialised feature flag should be modifiable.   
sl@0:  */
sl@0: void CFeatMgrFeatureRegistry::ValidateRuntimeFeatureFlagL(TBitFlags32 aFlags)
sl@0: 	{
sl@0: 	
sl@0: 	//Rule 1 (Blacklisting of run-time defined feature aFlags is not allowed)
sl@0: 	if(aFlags.IsSet(EFeatureBlackListed) ) 
sl@0:     	{
sl@0: 		//error 
sl@0:     	User::Leave( KErrArgument );
sl@0:     	}
sl@0:     	
sl@0:     //Rule 2 (non modifiable run-time feature aFlags should initialised
sl@0: 	if(!aFlags.IsSet(EFeatureModifiable) && aFlags.IsSet(EFeatureUninitialized) )
sl@0: 	 	{
sl@0: 	 	//error 
sl@0: 	 	User::Leave( KErrArgument );
sl@0: 	 	}
sl@0: 	}
sl@0: 
sl@0: 
sl@0: /**
sl@0:  * After restore, some features might have changed. This function will examine
sl@0:  * the differences between the old feature set and the newly restored feature set
sl@0:  * to discover if any changes have taken place: then it will handle the required
sl@0:  * notifications for new, deleted and changed featuers.
sl@0:  */
sl@0: void CFeatMgrFeatureRegistry::HandleRestoredFeatureNotificationsL()
sl@0: 	{
sl@0: 	// All comparisons are between the new list iFeatureList and the old list iFeatureListBackup
sl@0: 	TInt new_count = iFeatureList.Count();
sl@0: 	TInt old_count = iFeatureListBackup.Count();
sl@0: 	
sl@0: 	// Three lists, defining the differences between the two arrays
sl@0: 	RArray<TFeatureServerEntry> added;
sl@0: 	RArray<TFeatureServerEntry> removed;
sl@0: 	RArray<TFeatureServerEntry> changed;
sl@0: 
sl@0: 	// Regarding the newer iFeatureList array
sl@0: 	// Get the features according to the "new" iFeatureList array
sl@0: 	for( TInt i=0; i < new_count; i++ )
sl@0: 		{
sl@0: 	    // If not set, the feature flag is a ROM or plug-in
sl@0: 	    if( iFeatureList[i].FeatureFlags().IsSet(EFeatureRuntime) )
sl@0: 	        {
sl@0: 	        TUid uid( iFeatureList[i].FeatureUid() );
sl@0: 		    TInt index = iFeatureListBackup.FindInOrder( uid, FindByUid );
sl@0: 		    
sl@0: 			// KErrNotFound, if no matching object can be found
sl@0: 			if( KErrNotFound == index )
sl@0: 				{
sl@0: 				// Recently added feature
sl@0: 				added.AppendL( iFeatureList[i] );
sl@0: 				}
sl@0: 			else
sl@0: 				{
sl@0: 				// Get the features in iFeatureList that have recently been altered
sl@0: 		        TFeatureServerEntry old_item = iFeatureListBackup[index];
sl@0: 		        TFeatureServerEntry new_item = iFeatureList[i];
sl@0: 		        TUint32 old_flags = old_item.FeatureFlags().Value();
sl@0: 		        TUint32 new_flags = new_item.FeatureFlags().Value();
sl@0: 		        unsigned long int old_data = old_item.FeatureData();
sl@0: 		        unsigned long int new_data = new_item.FeatureData();
sl@0: 	        	// if any thing has changed, then add it to our list.
sl@0: 		        // there is no != overload for TBitFlags32
sl@0: 				if( !( old_flags == new_flags) || !( old_data == new_data) )
sl@0: 					{
sl@0: 					// changed in the "new" iFeatureList array
sl@0: 					changed.AppendL( iFeatureList[i] );
sl@0: 					}
sl@0: 				}
sl@0: 		
sl@0: 	        } // end if ! EFeatureRuntime
sl@0: 		} // end loop
sl@0: 
sl@0: 
sl@0: 	// Regarding the older iFeatureListBackup array
sl@0: 	// Get the features according to the "old" iFeatureListBackup array
sl@0: 	for( TInt i=0; i < old_count; i++ )
sl@0: 		{
sl@0: 	    // If not set, the feature flag is a ROM or plug-in
sl@0: 	    if( iFeatureListBackup[i].FeatureFlags().IsSet(EFeatureRuntime) )
sl@0: 	        {
sl@0: 	        TUid uid( iFeatureListBackup[i].FeatureUid() );
sl@0: 		    TInt index = iFeatureList.FindInOrder( uid, FindByUid );
sl@0: 		    
sl@0: 			// KErrNotFound, if no matching object can be found
sl@0: 			if( KErrNotFound == index )
sl@0: 				{
sl@0: 				// Recently removed feature
sl@0: 				removed.AppendL( iFeatureListBackup[i] );
sl@0: 				}
sl@0: 			// the else has already been completed in previous loop
sl@0: 		
sl@0: 	        } // end if ! EFeatureRuntime
sl@0: 		} // end loop
sl@0: 	
sl@0: 	TInt size_added 	= added.Count();
sl@0: 	TInt size_changed 	= changed.Count();
sl@0: 	TInt size_removed 	= removed.Count();
sl@0: 
sl@0: 	// notify the added features
sl@0:     for( TInt i = 0; i < size_added; i++ )
sl@0:         {
sl@0:         TFeatureServerEntry entry( added[i].FeatureUid(), added[i].FeatureFlags(), added[i].FeatureData() );
sl@0:         TFeatureChangeType changeType( EFeatureFeatureCreated );
sl@0:         iObserver.HandleFeatureChange( entry, changeType );
sl@0:         }
sl@0: 
sl@0: 	// notify the changed features
sl@0:     for( TInt i = 0; i < size_changed; i++ )
sl@0:         {
sl@0:         TFeatureServerEntry entry( changed[i].FeatureUid(), changed[i].FeatureFlags(), changed[i].FeatureData() );
sl@0:         TFeatureChangeType changeType( EFeatureStatusUpdated );
sl@0:         iObserver.HandleFeatureChange( entry, changeType );        
sl@0:         }
sl@0: 
sl@0: 	// notify the delete features
sl@0:     for( TInt i = 0; i < size_removed; i++ )
sl@0:         {
sl@0:         TFeatureServerEntry entry( removed[i].FeatureUid(), removed[i].FeatureFlags(), removed[i].FeatureData() );
sl@0:         TFeatureChangeType changeType( EFeatureFeatureDeleted );
sl@0:         iObserver.HandleFeatureChange( entry, changeType );
sl@0:         }
sl@0: 	}
sl@0: 
sl@0: // -----------------------------------------------------------------------------
sl@0: // CFeatMgrFeatureRegistry::SWIStart
sl@0: // -----------------------------------------------------------------------------
sl@0: //
sl@0: TInt CFeatMgrFeatureRegistry::SWIStart(TUint aSWIProcessId)
sl@0: 	{
sl@0: 	FUNC_LOG
sl@0: 	
sl@0: 	// If a previous call to SWIStart was made then return an error indicating that SWI
sl@0: 	// is already running. This assures that no two exes will enable the caching
sl@0: 	// mechanism at the same time.
sl@0: 	if( iSWICacheFeature )
sl@0: 		{
sl@0: 		INFO_LOG( "CFeatMgrFeatureRegistry::SWIStart - Already in use");
sl@0: 		return KErrInUse;
sl@0: 		}
sl@0: 	
sl@0: 	RProperty propertyHndl;
sl@0: 	TInt err =propertyHndl.Attach(KUidSystemCategory, KSAUidSoftwareInstallKeyValue);
sl@0: 	if (KErrNone != err)
sl@0: 		{
sl@0: 		return err;
sl@0: 		}
sl@0: 	TInt val = -1;
sl@0: 	err = propertyHndl.Get(val);
sl@0: 	propertyHndl.Close();
sl@0: 
sl@0: 	if( KErrNone == err )
sl@0: 		{
sl@0: 		// If an installation/uninstallation has started and no finishing status has been set for it
sl@0: 		if( ((val&ESASwisInstall) || (val&ESASwisUninstall)) && !(val&ESASwisStatusNone) )
sl@0: 			{
sl@0: 			// Set a flag to tell FeatMgr that features modified from this point onwards
sl@0: 		    // until a call to SWIEnd must be cached.
sl@0: 		    iSWICacheFeature = ETrue;
sl@0: 		    // SWI installation/uninstallation is in progress
sl@0: 		    iSWIStatus = ESWIInstalling;
sl@0: 		    // Set the ID of the process issuing Feature Manager commands to be cached
sl@0: 			iSWIProcessId = aSWIProcessId;
sl@0: 			// Start listening to P&S install property
sl@0: 		    TRAP(err, iSWIListener = CSWIListener::NewL(this));
sl@0: 		    if (KErrNone != err)
sl@0: 		    	{
sl@0: 		    	return err;
sl@0: 		    	}
sl@0: 		    
sl@0: 		    // Start the timer to handle the case of the launched exe hanging or not calling SWIEnd
sl@0: 		    // after SWIStart
sl@0: 		    TRAP(err, iSWITimer = CSWITimer::NewL(TTimeIntervalMicroSeconds32(SWITIMEOUT), this));
sl@0: 		    if (KErrNone != err)
sl@0: 		    	{
sl@0: 		    	return err;
sl@0: 		    	}
sl@0: 		    	
sl@0: 		    INFO_LOG( "CFeatMgrFeatureRegistry::SWIStart - err KErrNone");
sl@0: 		    return KErrNone;
sl@0: 			}
sl@0: 		}
sl@0: 	INFO_LOG( "CFeatMgrFeatureRegistry::SWIStart - err KErrNotReady");
sl@0: 
sl@0: 	return KErrNotReady;
sl@0: 	}
sl@0: 
sl@0: // -----------------------------------------------------------------------------
sl@0: // CFeatMgrFeatureRegistry::SWIEnd
sl@0: // -----------------------------------------------------------------------------
sl@0: //
sl@0: TInt CFeatMgrFeatureRegistry::SWIEnd(TUint aSWIProcessId)
sl@0: 	{
sl@0: 	FUNC_LOG
sl@0: 
sl@0: 	// reset the number of operations cached
sl@0: 	iSWIOperations = 0;
sl@0: 	
sl@0: 	// If it is the same process that made a call to SWIStart and caching is in progress
sl@0: 	if( iSWIProcessId == aSWIProcessId && iSWICacheFeature )
sl@0: 		{
sl@0: 		if( iSWIStatus == ESWIAborted )
sl@0: 			{
sl@0: 			SWIReset();
sl@0: 			
sl@0: 			INFO_LOG( "CFeatMgrFeatureRegistry::SWIEnd - SWIStatus = ESWIAborted");
sl@0: 			return KErrNone;
sl@0: 			}
sl@0: 		else if( iSWIStatus == ESWIInstalling )
sl@0: 			{
sl@0: 			// Stop time-out
sl@0: 			if( iSWITimer )
sl@0: 				{
sl@0: 				delete iSWITimer;
sl@0: 				iSWITimer = NULL;
sl@0: 				}
sl@0: 			// Stop caching
sl@0: 			iSWICacheFeature = EFalse;			
sl@0: 			
sl@0: 			TInt err = KErrGeneral;
sl@0: 
sl@0: 			if( !iOomOccured )
sl@0: 				{
sl@0: 				if( iAddFeatCount>0 )
sl@0: 					{
sl@0: 					err = iFeatureList.Reserve(iFeatureList.Count() + iAddFeatCount);
sl@0:                     if (err == KErrNoMemory)
sl@0:                          {
sl@0:                          iSWIStatus = ESWIOutOfMemory;
sl@0:                          }
sl@0: 					}
sl@0: 				}
sl@0: 			else
sl@0: 				{
sl@0: 				err = KErrNoMemory;
sl@0: 				iSWIStatus = ESWIOutOfMemory;
sl@0: 				}
sl@0: 			
sl@0: 			INFO_LOG( "CFeatMgrFeatureRegistry::SWIEnd - SWIStatus = ESWIInstalling");
sl@0: 			return err;
sl@0: 			}
sl@0: 		}
sl@0: 
sl@0: 	INFO_LOG( "CFeatMgrFeatureRegistry::SWIEnd - err KErrNotReady");
sl@0: 	return KErrNotReady;
sl@0: 	}
sl@0: 
sl@0: // -----------------------------------------------------------------------------
sl@0: // CFeatMgrFeatureRegistry::SWICacheCommand
sl@0: // -----------------------------------------------------------------------------
sl@0: //
sl@0: TInt CFeatMgrFeatureRegistry::SWICacheCommand(TSWIOperationCat aOptCat, TFeatureServerEntry aFeature)
sl@0: 	{
sl@0: 	FUNC_LOG
sl@0: 	
sl@0: 	TInt err;
sl@0: 
sl@0: 	if (iSWIOperations >= MAXSWIOPS)
sl@0: 		{
sl@0: 		err = KErrArgument;
sl@0: 		}
sl@0: 	else if (iOomOccured)
sl@0: 		{
sl@0: 		err = KErrNoMemory;
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		if( aOptCat == ESWIAddFeat )
sl@0: 			{
sl@0: 			++iAddFeatCount;
sl@0: 			}		
sl@0: 		TSWICachedOperation operation;
sl@0: 		operation.iFeatEntry = aFeature;
sl@0: 		operation.iCat = aOptCat;
sl@0:     	err = iSWICachedOperations.Append(operation);
sl@0:     	if( err == KErrNoMemory)
sl@0:     		{
sl@0:     		iOomOccured = ETrue;
sl@0:     		}
sl@0:     	else if( err == KErrNone )
sl@0:     		{
sl@0:     		++iSWIOperations;
sl@0:     		}
sl@0: 		}
sl@0: 	return err;
sl@0: 	}
sl@0: 
sl@0: // -----------------------------------------------------------------------------
sl@0: // CFeatMgrFeatureRegistry::CommitSWIFeatChanges
sl@0: // -----------------------------------------------------------------------------
sl@0: //
sl@0: void CFeatMgrFeatureRegistry::CommitSWIFeatChanges()
sl@0: 	{
sl@0: 	FUNC_LOG
sl@0: 	
sl@0: 	// Commit all cached features.
sl@0: 	if( !iSWICacheFeature )
sl@0: 		{
sl@0: 		TInt count = iSWICachedOperations.Count();
sl@0: 
sl@0: 		for( TInt i=0; i<count; ++i )
sl@0: 			{
sl@0: 			TSWIOperationCat optCat = iSWICachedOperations[i].iCat;
sl@0: 	
sl@0: 			switch(optCat)
sl@0: 				{
sl@0: 			case ESWIAddFeat:
sl@0: 				{
sl@0: 				AddFeature( iSWICachedOperations[i].iFeatEntry, 0 );
sl@0: 				}
sl@0: 				break;
sl@0: 			case ESWIDeleteFeat:
sl@0: 				{
sl@0: 				DeleteFeature( iSWICachedOperations[i].iFeatEntry.FeatureUid() );
sl@0: 				}
sl@0: 				break;
sl@0: 			case ESWISetFeatAndData:
sl@0: 				{
sl@0: 				TUint32 data = iSWICachedOperations[i].iFeatEntry.FeatureData();				
sl@0: 				SetFeature( iSWICachedOperations[i].iFeatEntry.FeatureUid(),
sl@0: 							iSWICachedOperations[i].iFeatEntry.FeatureFlags().Value(),
sl@0: 							&data);
sl@0: 		    	}
sl@0: 				break;
sl@0: 			case ESWISetFeatData:
sl@0: 				{
sl@0: 				TUint32 data = iSWICachedOperations[i].iFeatEntry.FeatureData();
sl@0: 				SetFeature(iSWICachedOperations[i].iFeatEntry.FeatureUid(),
sl@0: 							EFeatureSupportUntouch,&data);
sl@0: 				}
sl@0: 				break;
sl@0:             case ESWISetFeat:
sl@0:                 {
sl@0:                 SetFeature( iSWICachedOperations[i].iFeatEntry.FeatureUid(),
sl@0:                             iSWICachedOperations[i].iFeatEntry.FeatureFlags().Value(),
sl@0:                             NULL);
sl@0:                 }
sl@0:                 break;
sl@0: 			default:
sl@0: 				break;
sl@0: 				};
sl@0: 			}
sl@0: 		
sl@0: 		INFO_LOG( "CFeatMgrFeatureRegistry::CommitSWIFeatChanges - Committing completed");
sl@0: 		}
sl@0: 	SWIReset();
sl@0: 	}
sl@0: 
sl@0: // -----------------------------------------------------------------------------
sl@0: // CFeatMgrFeatureRegistry::SWIReset
sl@0: // -----------------------------------------------------------------------------
sl@0: //
sl@0: void CFeatMgrFeatureRegistry::SWIReset()
sl@0: 	{
sl@0: 	// Clear cached-features array
sl@0: 	iSWICachedOperations.Close();
sl@0: 
sl@0: 	// Reset caching flag
sl@0: 	iSWICacheFeature = EFalse;
sl@0: 	
sl@0: 	// Reset SWI process Id
sl@0: 	iSWIProcessId = 1;
sl@0: 	
sl@0: 	// Reset SWI completion status
sl@0: 	iSWIStatus = ESWIComplete;
sl@0: 
sl@0: 	// Reset the check for "out of memory" condition
sl@0: 	iOomOccured = EFalse;
sl@0: 	
sl@0: 	// Reset the operations counter
sl@0: 	iSWIOperations = 0;
sl@0: 	
sl@0: 	// No need to listen to P&S insall property any more
sl@0: 	delete iSWIListener;
sl@0: 	iSWIListener = NULL;
sl@0: 	
sl@0: 	// Stop time-out
sl@0: 	if( iSWITimer )
sl@0: 		{
sl@0: 		delete iSWITimer;
sl@0: 		iSWITimer = NULL;
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: // -----------------------------------------------------------------------------
sl@0: // CFeatMgrFeatureRegistry::SWIAborted
sl@0: // -----------------------------------------------------------------------------
sl@0: //
sl@0: void CFeatMgrFeatureRegistry::SWIAborted()
sl@0: 	{
sl@0: 	FUNC_LOG
sl@0: 	
sl@0: 	// If abort occured before SWIEnd is called
sl@0: 	if( iSWICacheFeature )
sl@0: 		{
sl@0: 		INFO_LOG( "CFeatMgrFeatureRegistry::SWIAborted - Abort occured before SWIEnd was called");
sl@0: 		iSWIStatus = ESWIAborted;
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		INFO_LOG( "CFeatMgrFeatureRegistry::SWIAborted - Abort occured after SWIEnd was called");
sl@0: 		SWIReset();
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: // -----------------------------------------------------------------------------
sl@0: // CFeatMgrFeatureRegistry::SWITimedOut
sl@0: // -----------------------------------------------------------------------------
sl@0: //
sl@0: void CFeatMgrFeatureRegistry::SWITimedOut()
sl@0: 	{
sl@0: 	FUNC_LOG
sl@0: 	
sl@0: 	if( iSWICacheFeature )
sl@0: 		{
sl@0: 		INFO_LOG( "CFeatMgrFeatureRegistry::SWITimedOut - Timeout expired");
sl@0: 		SWIReset();
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: // -----------------------------------------------------------------------------
sl@0: // CFeatMgrFeatureRegistry::SWICacheStarted
sl@0: // -----------------------------------------------------------------------------
sl@0: //
sl@0: TBool CFeatMgrFeatureRegistry::SWICacheStarted()
sl@0: 	{
sl@0: 	return iSWICacheFeature;
sl@0: 	}
sl@0: 
sl@0: // -----------------------------------------------------------------------------
sl@0: // CFeatMgrFeatureRegistry::SWICacheStatus
sl@0: // -----------------------------------------------------------------------------
sl@0: //
sl@0: TBool CFeatMgrFeatureRegistry::SWICacheStatusOOM()
sl@0: 	{
sl@0: 	if( iSWIStatus == ESWIOutOfMemory )
sl@0: 		{
sl@0: 		return ETrue;
sl@0: 		}
sl@0: 	return EFalse;
sl@0: 	}
sl@0: 	
sl@0: //  End of File