os/persistentdata/featuremgmt/featuremgr/src/serverexe/featmgrfeatureregistry.cpp
1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/persistentdata/featuremgmt/featuremgr/src/serverexe/featmgrfeatureregistry.cpp Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,1571 @@
1.4 +// Copyright (c) 2007-2010 Nokia Corporation and/or its subsidiary(-ies).
1.5 +// All rights reserved.
1.6 +// This component and the accompanying materials are made available
1.7 +// under the terms of "Eclipse Public License v1.0"
1.8 +// which accompanies this distribution, and is available
1.9 +// at the URL "http://www.eclipse.org/legal/epl-v10.html".
1.10 +//
1.11 +// Initial Contributors:
1.12 +// Nokia Corporation - initial contribution.
1.13 +//
1.14 +// Contributors:
1.15 +//
1.16 +// Description:
1.17 +//
1.18 +
1.19 +
1.20 +
1.21 +
1.22 +// INCLUDE FILES
1.23 +#include <ecom/ecom.h>
1.24 +#include <e32uid.h>
1.25 +#include <f32file.h>
1.26 +#include <e32property.h>
1.27 +#include <sacls.h>
1.28 +#include "featmgrconfiguration.h"
1.29 +#include "featmgrfeatureregistry.h"
1.30 +#include "featmgrserver.h"
1.31 +#include "featmgrdebug.h"
1.32 +
1.33 +#define MAXSWIOPS 50
1.34 +#define SWITIMEOUT 15000000
1.35 +
1.36 +// CONSTANTS
1.37 +_LIT( KZFeaturesFileNameMatch, "feature*" );
1.38 +_LIT( KCRuntimeFeaturesFileName, "features.dat" );
1.39 +#ifdef EXTENDED_FEATURE_MANAGER_TEST
1.40 +_LIT( KZFeaturesDir, "C:\\Private\\102836E5\\" );
1.41 +_LIT( KCFeatMgrPrivatePath, "?:\\Private\\102836E5\\runtime\\" );
1.42 +#else
1.43 +_LIT( KZFeaturesDir, "Z:\\Private\\10205054\\" );
1.44 +_LIT( KCFeatMgrPrivatePath, "?:\\Private\\10205054\\" );
1.45 +#endif // EXTENDED_FEATURE_MANAGER_TEST
1.46 +
1.47 +const TUint32 KDefaultData( 0x00000000 );
1.48 +// Feature file header constants.
1.49 +// First 4 bytes of config file: ASCII f-e-a-t followed by file version and flags.
1.50 +const TUint32 KFileType( 0x74616566 );
1.51 +const TUint16 KFileVersion( 1 );
1.52 +const TUint16 KFileFlags( 0 );
1.53 +
1.54 +
1.55 +// ============================= LOCAL FUNCTIONS ===============================
1.56 +
1.57 +// ============================ MEMBER FUNCTIONS ===============================
1.58 +
1.59 +// -----------------------------------------------------------------------------
1.60 +// CFeatMgrFeatureRegistry::CFeatMgrFeatureRegistry
1.61 +// -----------------------------------------------------------------------------
1.62 +//
1.63 +CFeatMgrFeatureRegistry::CFeatMgrFeatureRegistry( RFs& aFs,
1.64 + MFeatMgrRegistryObserver& aObserver )
1.65 + :
1.66 + iObserver( aObserver ),
1.67 + iFs( aFs ),
1.68 + iSWICacheFeature( EFalse ),
1.69 + iSWIStatus( ESWIComplete ),
1.70 + iSWIProcessId( 1 ),
1.71 + iOomOccured(EFalse)
1.72 + {
1.73 + }
1.74 +
1.75 +// -----------------------------------------------------------------------------
1.76 +// CFeatMgrFeatureRegistry::ConstructL
1.77 +// Symbian 2nd phase constructor can leave.
1.78 +// -----------------------------------------------------------------------------
1.79 +//
1.80 +void CFeatMgrFeatureRegistry::ConstructL()
1.81 + {
1.82 + }
1.83 +
1.84 +// -----------------------------------------------------------------------------
1.85 +// CFeatMgrFeatureRegistry::NewL
1.86 +// Two-phased constructor.
1.87 +// -----------------------------------------------------------------------------
1.88 +//
1.89 +CFeatMgrFeatureRegistry* CFeatMgrFeatureRegistry::NewL( RFs& aFs,
1.90 + MFeatMgrRegistryObserver& aObserver )
1.91 + {
1.92 + CFeatMgrFeatureRegistry* self =
1.93 + new( ELeave ) CFeatMgrFeatureRegistry( aFs, aObserver );
1.94 +
1.95 + CleanupStack::PushL( self );
1.96 + self->ConstructL();
1.97 + CleanupStack::Pop( self );
1.98 +
1.99 + return self;
1.100 + }
1.101 +
1.102 +// -----------------------------------------------------------------------------
1.103 +// Destructor
1.104 +// -----------------------------------------------------------------------------
1.105 +//
1.106 +CFeatMgrFeatureRegistry::~CFeatMgrFeatureRegistry()
1.107 + {
1.108 + FUNC_LOG
1.109 +
1.110 + iFeatureList.Close();
1.111 + iRangeList.Close();
1.112 + iFeatureListBackup.Close();
1.113 + iSWICachedOperations.Close();
1.114 + if( iSWIListener )
1.115 + {
1.116 + delete iSWIListener;
1.117 + }
1.118 + if( iSWITimer )
1.119 + {
1.120 + delete iSWITimer;
1.121 + }
1.122 + }
1.123 +
1.124 +
1.125 +// -----------------------------------------------------------------------------
1.126 +// CFeatMgrFeatureRegistry::IsFeatureSupported
1.127 +// -----------------------------------------------------------------------------
1.128 +//
1.129 +TInt CFeatMgrFeatureRegistry::IsFeatureSupported( TFeatureServerEntry& aFeature )
1.130 + {
1.131 + TInt err( KErrNotFound );
1.132 + const TInt index = SearchFeature( aFeature.FeatureUid() );
1.133 +
1.134 + if ( index == KErrNotFound )
1.135 + {
1.136 + // Check whether feature in supported ranges
1.137 + TInt count( iRangeList.Count() );
1.138 + TUid uid( aFeature.FeatureUid() );
1.139 + for( TInt i = 0; i < count; i++ )
1.140 + {
1.141 + if( (uid.iUid >= iRangeList[i].iLowUid.iUid) &&
1.142 + (uid.iUid <= iRangeList[i].iHighUid.iUid) )
1.143 + {
1.144 + TBitFlags32 flags( 0 );
1.145 + flags.Assign( EFeatureSupported, KFeatureSupported );
1.146 + TFeatureServerEntry entry( aFeature.FeatureUid(), flags, KDefaultData );
1.147 + aFeature = entry;
1.148 + err = KFeatureSupported;
1.149 + break;
1.150 + }
1.151 + }
1.152 + }
1.153 + else if( IsFlagSet( index, EFeatureUninitialized ) )
1.154 + {
1.155 + // Supported status bit is not taken into account if feature not yet initialized
1.156 + err = KErrNotReady;
1.157 + }
1.158 + else if ( (index < iFeatureList.Count()) && IsFlagSet( index, EFeatureSupported ) )
1.159 + {
1.160 + TBitFlags32 flags = iFeatureList[index].FeatureFlags();
1.161 + flags.Assign( EFeatureSupported, KFeatureSupported );
1.162 + TUint32 data = iFeatureList[index].FeatureData();
1.163 + TFeatureServerEntry entry( aFeature.FeatureUid(), flags, data );
1.164 + aFeature = entry;
1.165 + err = KFeatureSupported;
1.166 + }
1.167 + else
1.168 + {
1.169 + TBitFlags32 flags = iFeatureList[index].FeatureFlags();
1.170 + flags.Assign( EFeatureSupported, KFeatureUnsupported );
1.171 + TUint32 data = iFeatureList[index].FeatureData();
1.172 + TFeatureServerEntry entry( aFeature.FeatureUid(), flags, data );
1.173 + aFeature = entry;
1.174 + err = KFeatureUnsupported;
1.175 + }
1.176 +
1.177 + return err;
1.178 + }
1.179 +
1.180 +// -----------------------------------------------------------------------------
1.181 +// CFeatMgrFeatureRegistry::AddFeature
1.182 +// -----------------------------------------------------------------------------
1.183 +//
1.184 +TInt CFeatMgrFeatureRegistry::AddFeature( TFeatureServerEntry& aFeature, TUint aPrcId )
1.185 + {
1.186 + TInt err( KErrAccessDenied );
1.187 +
1.188 + if( iSWIProcessId == aPrcId && iSWICacheFeature )
1.189 + {
1.190 + err = SWICacheCommand(ESWIAddFeat, aFeature);
1.191 + }
1.192 + else
1.193 + {
1.194 + const TInt index = SearchFeature( aFeature.FeatureUid() );
1.195 +
1.196 + if ( index == KErrNotFound )
1.197 + {
1.198 + TBitFlags32 flags( aFeature.FeatureFlags() );
1.199 + flags.Set( EFeatureRuntime );
1.200 +
1.201 + //Check the feature falg is valid
1.202 + TRAP(err,ValidateRuntimeFeatureFlagL(flags));
1.203 + if (err != KErrNone)
1.204 + return err;
1.205 +
1.206 + TFeatureServerEntry entry( aFeature.FeatureUid(), flags, aFeature.FeatureData() );
1.207 + err = iFeatureList.InsertInOrder( entry, FindByUid );
1.208 + if ( err == KErrNone )
1.209 + {
1.210 + TFeatureChangeType changeType( EFeatureFeatureCreated );
1.211 + err = HandleChange( entry, changeType );
1.212 + }
1.213 + }
1.214 + else
1.215 + {
1.216 + err = KErrAlreadyExists;
1.217 + }
1.218 +
1.219 + INFO_LOG("CFeatMgrFeatureRegistry::AddFeature - Features directly stored in registry");
1.220 + }
1.221 +
1.222 + LOG_IF_ERROR1( err, "CFeatMgrFeatureRegistry::AddFeature - result %d", err );
1.223 +
1.224 + return err;
1.225 + }
1.226 +
1.227 +// -----------------------------------------------------------------------------
1.228 +// CFeatMgrFeatureRegistry::DeleteFeature
1.229 +// -----------------------------------------------------------------------------
1.230 +//
1.231 +TInt CFeatMgrFeatureRegistry::DeleteFeature( TUid aFeature, TUint aPrcId )
1.232 + {
1.233 + TInt err( KErrAccessDenied );
1.234 +
1.235 + if( iSWIProcessId == aPrcId && iSWICacheFeature )
1.236 + {
1.237 + err = SWICacheCommand(ESWIDeleteFeat, aFeature);
1.238 + }
1.239 + else
1.240 + {
1.241 + // Check if the feature is runtime
1.242 + TInt index = SearchFeature( aFeature );
1.243 + if ( index == KErrNotFound )
1.244 + {
1.245 + return KErrNotFound;
1.246 + }
1.247 + if ( !iFeatureList[index].FeatureFlags().IsSet(EFeatureRuntime) )
1.248 + {
1.249 + return KErrAccessDenied;
1.250 + }
1.251 +
1.252 + TFeatureServerEntry entry = iFeatureList[index];
1.253 +
1.254 + iFeatureList.Remove( index );
1.255 + TFeatureChangeType changeType( EFeatureFeatureDeleted );
1.256 + err = HandleChange( entry, changeType );
1.257 +
1.258 + INFO_LOG("CFeatMgrFeatureRegistry::DeleteFeature - Features deleted directly from registry");
1.259 + }
1.260 +
1.261 + LOG_IF_ERROR1( err, "CFeatMgrFeatureRegistry::DeleteFeature - result %d", err );
1.262 +
1.263 + return err;
1.264 + }
1.265 +
1.266 +// -----------------------------------------------------------------------------
1.267 +// CFeatMgrFeatureRegistry::SetFeature
1.268 +//This method cannot set feature flag range in DSR unless it is added to before
1.269 +//using CFeatMgrFeatureRegistry::AddFeature()
1.270 +// -----------------------------------------------------------------------------
1.271 +//
1.272 +TInt CFeatMgrFeatureRegistry::SetFeature( TUid aFeature, TInt aEnable, const TUint32 *aData, TUint aPrcId )
1.273 + {
1.274 + FUNC_LOG
1.275 +
1.276 + TInt err( KErrNone );
1.277 +
1.278 + if( iSWIProcessId == aPrcId && iSWICacheFeature )
1.279 + {
1.280 + TBitFlags32 flags(0);
1.281 + flags.Assign( EFeatureSupported, aEnable );
1.282 + TUint32 data = 0;
1.283 + if( aData )
1.284 + {
1.285 + data = *aData;
1.286 + }
1.287 +
1.288 + TFeatureServerEntry entry( aFeature, flags, data );
1.289 +
1.290 + // If aData is not null, we want to change the user data too
1.291 + // otherwise only change the feature status.
1.292 + if( aData )
1.293 + {
1.294 + err = SWICacheCommand(ESWISetFeatAndData, entry);
1.295 + }
1.296 + else
1.297 + {
1.298 + err = SWICacheCommand(ESWISetFeat, entry);
1.299 + }
1.300 + }
1.301 + else
1.302 + {
1.303 + TInt index;
1.304 +
1.305 + // Validate feature exists and is modifiable
1.306 + err = ValidateFeature( aFeature, index );
1.307 +
1.308 + if ( err != KErrNone )
1.309 + {
1.310 + return err;
1.311 + }
1.312 +
1.313 + if ( (index >= 0 && index < iFeatureList.Count()) )
1.314 + {
1.315 + TBitFlags32 flags = iFeatureList[index].FeatureFlags();
1.316 + TUint32 data = iFeatureList[index].FeatureData();
1.317 + TFeatureChangeType changeType( EFeatureStatusUpdated );
1.318 +
1.319 + // Update "supported" info according to request
1.320 + if( (aEnable == EFeatureSupportEnable) || (aEnable == EFeatureSupportDisable) )
1.321 + {
1.322 + INFO_LOG1( "CFeatMgrFeatureRegistry::SetFeature() - aEnable %d", aEnable );
1.323 + flags.Assign( EFeatureSupported, aEnable );
1.324 + }
1.325 + // When setting feature, always unset "uninitialized" bit
1.326 + flags.Assign( EFeatureUninitialized, 0 );
1.327 +
1.328 + // Update data whenever applied
1.329 + if( aData )
1.330 + {
1.331 + INFO_LOG1( "CFeatMgrFeatureRegistry::SetFeature() - aData %d", aData );
1.332 + data = *aData;
1.333 +
1.334 + if( aEnable == EFeatureSupportUntouch )
1.335 + {
1.336 + changeType = EFeatureDataUpdated;
1.337 + }
1.338 + else
1.339 + {
1.340 + changeType = EFeatureStatusDataUpdated;
1.341 + }
1.342 + }
1.343 +
1.344 + TFeatureServerEntry entry( aFeature, flags, data );
1.345 + //Check if the feature will actually change
1.346 + if(iFeatureList[index].FeatureFlags() == flags && iFeatureList[index].FeatureData() == data )
1.347 + {
1.348 + //No change were made, set change type to EFeatureNoChange
1.349 + changeType = EFeatureNoChange;
1.350 + }
1.351 + else
1.352 + {
1.353 + // Set the feature entry in list with updated information
1.354 + iFeatureList[index].Set(entry);
1.355 + }
1.356 +
1.357 + err = HandleChange( entry, changeType );
1.358 + }
1.359 + }
1.360 +
1.361 + LOG_IF_ERROR1( err, "CFeatMgrFeatureRegistry::SetFeature - result %d", err );
1.362 +
1.363 + return err;
1.364 + }
1.365 +
1.366 +// -----------------------------------------------------------------------------
1.367 +// CFeatMgrFeatureRegistry::HandleChange
1.368 +// -----------------------------------------------------------------------------
1.369 +//
1.370 +TInt CFeatMgrFeatureRegistry::HandleChange( TFeatureServerEntry& aFeature,
1.371 + TFeatureChangeType aType )
1.372 + {
1.373 + FUNC_LOG
1.374 +
1.375 + TInt err( KErrNone );
1.376 +
1.377 + // Update feature file, when feature is specified as persisted.
1.378 + if ( aFeature.FeatureFlags().IsSet( EFeaturePersisted ) )
1.379 + {
1.380 + TRAP( err, UpdateRuntimeFeaturesFileL( aFeature, aType ) );
1.381 + LOG_IF_ERROR1( err, "CFeatMgrFeatureRegistry::HandleChange - update error %d", err );
1.382 +
1.383 + // It is questionnable whether we should remove the feature from iFeatureList.
1.384 + // However, feature is usable until device is powered down and features reloaded.
1.385 + // if ( err == KErrNone )
1.386 + }
1.387 +
1.388 + // It is also questionnable whether we should suppress notification in case file
1.389 + // update failed.
1.390 + // if ( err == KErrNone )
1.391 + iObserver.HandleFeatureChange( aFeature, aType );
1.392 +
1.393 + return err;
1.394 + }
1.395 +
1.396 +// -----------------------------------------------------------------------------
1.397 +// CFeatMgrFeatureRegistry::ValidateFeature
1.398 +// -----------------------------------------------------------------------------
1.399 +//
1.400 +TInt CFeatMgrFeatureRegistry::ValidateFeature( TUid aFeature, TInt &aIndex )
1.401 + {
1.402 + TInt err( KErrNone );
1.403 +
1.404 + aIndex = SearchFeature( aFeature );
1.405 +
1.406 + if ( aIndex == KErrNotFound )
1.407 + {
1.408 + err = KErrNotFound;
1.409 + }
1.410 + else if ( !IsFlagSet( aIndex, EFeatureModifiable ) )
1.411 + {
1.412 + err = KErrAccessDenied;
1.413 + }
1.414 +
1.415 + return err;
1.416 + }
1.417 +
1.418 +// -----------------------------------------------------------------------------
1.419 +// CFeatMgrFeatureRegistry::FindByUid
1.420 +// Returns Zero if UIDs do match.
1.421 +// -----------------------------------------------------------------------------
1.422 +//
1.423 +TInt CFeatMgrFeatureRegistry::FindByUid( const TUid *aFeature,
1.424 + const TFeatureServerEntry& aItem )
1.425 + {
1.426 + if ( aFeature->iUid < aItem.FeatureUid().iUid )
1.427 + {
1.428 + return -1;
1.429 + }
1.430 + else if ( aFeature->iUid > aItem.FeatureUid().iUid )
1.431 + {
1.432 + return 1;
1.433 + }
1.434 +
1.435 + return 0;
1.436 + }
1.437 +
1.438 +// -----------------------------------------------------------------------------
1.439 +// CFeatMgrFeatureRegistry::FindByUid
1.440 +// Returns Zero if UIDs do match.
1.441 +// -----------------------------------------------------------------------------
1.442 +//
1.443 +TInt CFeatMgrFeatureRegistry::FindByUid( const TFeatureServerEntry& aFeature,
1.444 + const TFeatureServerEntry& aItem )
1.445 + {
1.446 + if ( aFeature.FeatureUid().iUid < aItem.FeatureUid().iUid )
1.447 + {
1.448 + return -1;
1.449 + }
1.450 + else if ( aFeature.FeatureUid().iUid > aItem.FeatureUid().iUid )
1.451 + {
1.452 + return 1;
1.453 + }
1.454 +
1.455 + return 0;
1.456 + }
1.457 +
1.458 +// -----------------------------------------------------------------------------
1.459 +// CFeatMgrFeatureRegistry::SearchFeature
1.460 +// -----------------------------------------------------------------------------
1.461 +//
1.462 +TInt CFeatMgrFeatureRegistry::SearchFeature( TUid aFeature )
1.463 + {
1.464 + const TUid& uid( aFeature );
1.465 + return iFeatureList.FindInOrder( uid, FindByUid );
1.466 + }
1.467 +
1.468 +// -----------------------------------------------------------------------------
1.469 +// CFeatMgrFeatureRegistry::IsFlagSet
1.470 +// -----------------------------------------------------------------------------
1.471 +//
1.472 +TBool CFeatMgrFeatureRegistry::IsFlagSet( TInt aIndex, TFeatureFlags aFlag )
1.473 + {
1.474 + TBool isSet( EFalse );
1.475 + if( aIndex < iFeatureList.Count() )
1.476 + {
1.477 + isSet = iFeatureList[aIndex].FeatureFlags().IsSet(aFlag);
1.478 + }
1.479 +
1.480 + return isSet;
1.481 + }
1.482 +
1.483 +// -----------------------------------------------------------------------------
1.484 +// CFeatMgrFeatureRegistry::SupportedFeatures
1.485 +// -----------------------------------------------------------------------------
1.486 +//
1.487 +void CFeatMgrFeatureRegistry::SupportedFeaturesL( RFeatureUidArray& aSupportedFeatures )
1.488 + {
1.489 + FUNC_LOG
1.490 +
1.491 + TInt count = iFeatureList.Count();
1.492 +
1.493 + for ( TInt i = 0; i < count; i++ )
1.494 + {
1.495 + if( IsFlagSet( i, EFeatureSupported) )
1.496 + {
1.497 + aSupportedFeatures.AppendL( iFeatureList[i].FeatureUid() );
1.498 + }
1.499 + }
1.500 + }
1.501 +
1.502 +// -----------------------------------------------------------------------------
1.503 +// CFeatMgrFeatureRegistry::NumberOfSupportedFeatures
1.504 +// -----------------------------------------------------------------------------
1.505 +//
1.506 +TInt CFeatMgrFeatureRegistry::NumberOfSupportedFeatures()
1.507 + {
1.508 + FUNC_LOG
1.509 +
1.510 + TInt count = iFeatureList.Count();
1.511 + TInt countSupported(0);
1.512 +
1.513 + for ( TInt i = 0; i < count; i++ )
1.514 + {
1.515 + if( IsFlagSet( i, EFeatureSupported) )
1.516 + {
1.517 + countSupported++;
1.518 + }
1.519 + }
1.520 +
1.521 + return countSupported;
1.522 + }
1.523 +
1.524 +// -----------------------------------------------------------------------------
1.525 +
1.526 +void CFeatMgrFeatureRegistry::ResetFeaturesL()
1.527 + {
1.528 + FUNC_LOG
1.529 +
1.530 + // backup the feature list before it is destroyed
1.531 + iFeatureListBackup.Reset();
1.532 + const TInt KCount = iFeatureList.Count();
1.533 + iFeatureListBackup.ReserveL(KCount);
1.534 + for(TInt i(0); i < KCount; i++)
1.535 + {
1.536 + // The main error here would be KErrNoMemory which should not happen as
1.537 + // we have already reserved the space. However, we should still check.
1.538 + iFeatureListBackup.AppendL(iFeatureList[i]);
1.539 + }
1.540 +
1.541 + // destroy the feature list
1.542 + iFeatureList.Reset();
1.543 + iFeatureList.Close();
1.544 +
1.545 + iRangeList.Reset();
1.546 + iRangeList.Close();
1.547 + }
1.548 +
1.549 +/**
1.550 + * Get the fully qualified path and filename to the features.dat
1.551 + * data file.
1.552 + */
1.553 +TFileName CFeatMgrFeatureRegistry::GetFeaturesFilePathAndName( void )
1.554 + {
1.555 + TFileName path( KCFeatMgrPrivatePath );
1.556 +
1.557 + path[0] = iFs.GetSystemDriveChar();
1.558 + path.Append( KCRuntimeFeaturesFileName );
1.559 +
1.560 + return path;
1.561 + }
1.562 +
1.563 +// CFeatMgrFeatureRegistry::ReadFeatureFilesL
1.564 +// Reads platform and product feature files.
1.565 +// -----------------------------------------------------------------------------
1.566 +//
1.567 +void CFeatMgrFeatureRegistry::ReadFeatureFilesL()
1.568 + {
1.569 + FUNC_LOG
1.570 +
1.571 + // Read feature files from Z
1.572 + ReadFilesFromDirL( KZFeaturesDir );
1.573 +
1.574 + //check that there is at least one DSR
1.575 + if (!iRangeList.Count())
1.576 + {
1.577 + _LIT(KPanicCategory, "FeatMgrServer");
1.578 + ERROR_LOG( "CFeatMgrFeatureRegistry::ReadFilesFromDirL() - no DSR found in ROM; this indicates a system integration error - going to panic" );
1.579 + ::FmgrFatalErrorL(KErrNotFound, KPanicCategory, EPanicNoDSR);
1.580 + }
1.581 + }
1.582 +
1.583 +// -----------------------------------------------------------------------------
1.584 +// CFeatMgrFeatureRegistry::ReadFilesFromDirL
1.585 +// -----------------------------------------------------------------------------
1.586 +//
1.587 +void CFeatMgrFeatureRegistry::ReadFilesFromDirL( const TDesC& aDirName )
1.588 + {
1.589 + _LIT(KPanicCategory, "FEATMGR-READFILE");
1.590 +
1.591 + CDir* dir = NULL;
1.592 + TInt err( KErrNone );
1.593 +
1.594 + err = iFs.GetDir( aDirName, KEntryAttNormal, ESortByName, dir );
1.595 + CleanupStack::PushL( dir );
1.596 +
1.597 + if( err == KErrNone )
1.598 + {
1.599 + err = ReadFiles( aDirName, dir );
1.600 + if ( err != KErrNone )
1.601 + {
1.602 + ERROR_LOG1( "CFeatMgrFeatureRegistry::ReadFilesFromDirL() - err %d ", err );
1.603 + User::Leave( err );
1.604 + }
1.605 + }
1.606 + else if( err == KErrPathNotFound )
1.607 + {
1.608 + ::FmgrFatalErrorL(err, KPanicCategory, EPanicNoFeatureFiles);
1.609 + }
1.610 + else
1.611 + {
1.612 + ERROR_LOG1( "CFeatMgrFeatureRegistry::ReadFilesFromDirL() - err %d ", err );
1.613 + User::Leave( err );
1.614 + }
1.615 +
1.616 + CleanupStack::PopAndDestroy( dir );
1.617 + }
1.618 +
1.619 +// -----------------------------------------------------------------------------
1.620 +// CFeatMgrFeatureRegistry::ReadRuntimeFeaturesL
1.621 +// -----------------------------------------------------------------------------
1.622 +//
1.623 +void CFeatMgrFeatureRegistry::ReadRuntimeFeaturesL( TBool &aFeaturesReady )
1.624 + {
1.625 + TFileName path( KCFeatMgrPrivatePath );
1.626 + path[0] = iFs.GetSystemDriveChar();
1.627 + path.Append( KCRuntimeFeaturesFileName );
1.628 +
1.629 + TInt err( KErrNone );
1.630 + TRAP( err, ReadFileL( path ) );
1.631 +
1.632 + if ((err == KErrCorrupt) || (err == KErrArgument))
1.633 + {
1.634 + User::LeaveIfError(iFs.Delete(path));
1.635 + aFeaturesReady = ETrue;
1.636 + }
1.637 + else if ( err != KErrNone && err != KErrNotFound && err != KErrPathNotFound )
1.638 + {
1.639 + ERROR_LOG1( "CFeatMgrFeatureRegistry::ReadRuntimeFeatures - ReadFileL returned err %d", err );
1.640 + User::Leave( err );
1.641 + }
1.642 + else
1.643 + {
1.644 + aFeaturesReady = ETrue;
1.645 + }
1.646 + }
1.647 +
1.648 +// -----------------------------------------------------------------------------
1.649 +// CFeatMgrFeatureRegistry::ReadFiles
1.650 +// -----------------------------------------------------------------------------
1.651 +//
1.652 +TInt CFeatMgrFeatureRegistry::ReadFiles( const TDesC& aPath, CDir* aDir )
1.653 + {
1.654 + TInt fileCount = aDir->Count();
1.655 + TFileName fileName;
1.656 + TInt err( KErrNotFound );
1.657 +
1.658 + for ( TInt file = 0; file < fileCount; file++ )
1.659 + {
1.660 + TInt match = (*aDir)[file].iName.MatchC( KZFeaturesFileNameMatch );
1.661 + if( match != KErrNotFound )
1.662 + {
1.663 + fileName.Copy(aPath);
1.664 + fileName.Append((*aDir)[file].iName);
1.665 +
1.666 + INFO_LOG1( "CFeatMgrFeatureRegistry::ReadFiles - file: %S", &fileName );
1.667 + TRAP( err, ReadFileL( fileName ) );
1.668 + LOG_IF_ERROR2( err, "CFeatMgrFeatureRegistry::ReadFiles - file: %S, err %d",
1.669 + &fileName, err );
1.670 +
1.671 + // Return error if reading of any feature file fails.
1.672 + if( err != KErrNone )
1.673 + {
1.674 + break;
1.675 + }
1.676 + }
1.677 + }
1.678 +
1.679 + return( err );
1.680 + }
1.681 +
1.682 +// -----------------------------------------------------------------------------
1.683 +// CFeatMgrFeatureRegistry::ReadFileL
1.684 +// -----------------------------------------------------------------------------
1.685 +//
1.686 +void CFeatMgrFeatureRegistry::ReadFileL( const TDesC& aFullPath )
1.687 + {
1.688 + FUNC_LOG
1.689 +
1.690 + TUint32 count;
1.691 + RFileReadStream readStream;
1.692 +
1.693 + // Open the file and attach to stream
1.694 + User::LeaveIfError( readStream.Open( iFs, aFullPath, EFileRead ) );
1.695 + CleanupClosePushL( readStream );
1.696 + TUint32 countDSRs;
1.697 +
1.698 + //Validate the header
1.699 + ValidateHeaderL( readStream, count, countDSRs );
1.700 +
1.701 + RArray<TFeatureServerEntry> tempFeatureArray;
1.702 + CleanupClosePushL( tempFeatureArray );
1.703 +
1.704 + //Find the directory that the feature file is contained in.
1.705 + TFileName dirName(aFullPath);
1.706 + TChar toFind = '\\';
1.707 + dirName.Delete((dirName.LocateReverse(toFind)+1), dirName.Length() );
1.708 + TBool runtimeFile = EFalse;
1.709 + if (dirName.Compare(KZFeaturesDir) != 0) //Location of the feature file.
1.710 + {
1.711 + runtimeFile = ETrue;
1.712 + }
1.713 +
1.714 + tempFeatureArray.ReserveL(count);
1.715 +
1.716 + for(TInt i = 0; i < count; i++)
1.717 + {
1.718 + TFeatureServerEntry entry;
1.719 + entry.InternalizeL( readStream );
1.720 +
1.721 + //Check for feature flag errors
1.722 + TBitFlags32 flags = entry.FeatureFlags();
1.723 + TInt err = KErrNone;
1.724 +
1.725 + //Validate the flags
1.726 + // This validation is done in this read function because the validation functions used
1.727 + // are called in other places were this validation is not appropriate.
1.728 + if (runtimeFile)
1.729 + {
1.730 + 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.
1.731 + {
1.732 + if (SearchFeature( entry.FeatureUid() ) == KErrNotFound )// Check to see if the feature has been read in previously from the rom.
1.733 + {
1.734 + User::Leave(KErrCorrupt);
1.735 + }
1.736 + else //The feature has not been read in previously from the rom file and is therefore invalid. The file is deemed to be corrupt
1.737 + {
1.738 + ValidateRuntimeFeatureFlagL(flags);
1.739 + }
1.740 + }
1.741 + else //Flag set the feature is runtime this is then validated as normal
1.742 + {
1.743 + ValidateRuntimeFeatureFlagL(flags);
1.744 + }
1.745 +
1.746 + }
1.747 + else //File is not as runtime file.
1.748 + {
1.749 + ValidateFeatureFlagL(flags);
1.750 + }
1.751 +
1.752 + //If a feature flag defined in system drive (c:) is invalid, it will not be added to Feature Manager
1.753 + if ( (err != KErrNone) && flags.IsSet(EFeatureRuntime) )
1.754 + {
1.755 + continue;
1.756 + }
1.757 +
1.758 + tempFeatureArray.InsertL( entry, i);
1.759 + }
1.760 +
1.761 + // Reserve memory if list still empty
1.762 + if( !iFeatureList.Count() )
1.763 + {
1.764 + iFeatureList.ReserveL( tempFeatureArray.Count() );
1.765 + }
1.766 +
1.767 + // Read features from temp array
1.768 + for(TInt i = 0; i < tempFeatureArray.Count(); i++)
1.769 + {
1.770 + TFeatureServerEntry entry = tempFeatureArray[i];
1.771 +
1.772 + TInt index = SearchFeature( entry.FeatureUid() );
1.773 +
1.774 + if( index == KErrNotFound)
1.775 + {
1.776 + iFeatureList.InsertInOrderL( entry, FindByUid );
1.777 + }
1.778 + else
1.779 + {
1.780 + INFO_LOG1( "CFeatMgrFeatureRegistry::ReadFileL - replacing uid 0x%08x",
1.781 + iFeatureList[index].FeatureUid().iUid );
1.782 + // Set the feature if it is not previously blacklisted
1.783 + if ( !IsFlagSet( index, EFeatureBlackListed ) )
1.784 + {
1.785 + iFeatureList[index].Set(entry);
1.786 + }
1.787 + }
1.788 + }
1.789 +
1.790 + // Reserve memory if DSR list still empty
1.791 + if( !iRangeList.Count() )
1.792 + {
1.793 + iRangeList.ReserveL( countDSRs );
1.794 + }
1.795 +
1.796 + // Read default supported ranges from file
1.797 + for(TInt i = 0; i < countDSRs; i++)
1.798 + {
1.799 + TDefaultRange range;
1.800 + range.iLowUid = TUid::Uid( readStream.ReadUint32L() );
1.801 + range.iHighUid = TUid::Uid( readStream.ReadUint32L() );
1.802 + iRangeList.AppendL( range );
1.803 + if( iRangeList[i].iLowUid.iUid > iRangeList[i].iHighUid.iUid )
1.804 + {
1.805 + ERROR_LOG( "CFeatMgrFeatureRegistry::ReadFileL - invalid supported range" );
1.806 + iRangeList.Remove( i );
1.807 + User::Leave( KErrCorrupt );
1.808 + }
1.809 + }
1.810 +
1.811 +#if defined(FEATMGR_INFO_LOG_ENABLED)
1.812 + count = iFeatureList.Count();
1.813 + INFO_LOG1( "CFeatMgrFeatureRegistry::ReadFileL - feature entries: %d", count );
1.814 + for(TInt i = 0; i < count; i++)
1.815 + {
1.816 + INFO_LOG3( "CFeatMgrFeatureRegistry::ReadFileL - uid 0x%08x, flags %d, data %d",
1.817 + iFeatureList[i].FeatureUid().iUid, iFeatureList[i].FeatureFlags().iFlags,
1.818 + iFeatureList[i].FeatureData() );
1.819 + }
1.820 +
1.821 + count = iRangeList.Count();
1.822 + INFO_LOG1( "CFeatMgrFeatureRegistry::ReadFileL - supported ranges: %d", count );
1.823 + for(TInt i = 0; i < count; i++)
1.824 + {
1.825 + INFO_LOG2( "CFeatMgrFeatureRegistry::ReadFileL - low 0x%08x, high 0x%08x",
1.826 + iRangeList[i].iLowUid, iRangeList[i].iHighUid );
1.827 + }
1.828 +#endif
1.829 +
1.830 + CleanupStack::PopAndDestroy( &tempFeatureArray);
1.831 + CleanupStack::PopAndDestroy( &readStream );
1.832 +
1.833 + }
1.834 +
1.835 +// -----------------------------------------------------------------------------
1.836 +// CFeatMgrFeatureRegistry::ValidateHeaderL
1.837 +// -----------------------------------------------------------------------------
1.838 +//
1.839 +void CFeatMgrFeatureRegistry::ValidateHeaderL( RFileReadStream &aStream,
1.840 + TUint32& aCount, TUint32& aCountDSRs )
1.841 + {
1.842 + FUNC_LOG
1.843 +
1.844 + TUint32 identifier = aStream.ReadUint32L();
1.845 + TUint16 fileVersion = aStream.ReadUint16L();
1.846 + TUint16 fileFlags = aStream.ReadUint16L();
1.847 + aCount = aStream.ReadUint32L();
1.848 + aCountDSRs = aStream.ReadUint32L();
1.849 +
1.850 + // Carry out simple verification of file content
1.851 + if((identifier != KFileType) || fileVersion != KFileVersion ||
1.852 + fileFlags != KFileFlags )
1.853 + {
1.854 + User::Leave( KErrCorrupt );
1.855 + }
1.856 + }
1.857 +
1.858 +// -----------------------------------------------------------------------------
1.859 +// CFeatMgrFeatureRegistry::UpdateRuntimeFeaturesFileL
1.860 +// -----------------------------------------------------------------------------
1.861 +//
1.862 +void CFeatMgrFeatureRegistry::UpdateRuntimeFeaturesFileL( TFeatureServerEntry& aFeature,
1.863 + TFeatureChangeType aType )
1.864 + {
1.865 + FUNC_LOG
1.866 +
1.867 + // Opens a file containing a stream and prepares the stream for writing.
1.868 + TInt err( KErrNone );
1.869 + RFileWriteStream writeStream;
1.870 + TFileName path( KCFeatMgrPrivatePath );
1.871 + path[0] = iFs.GetSystemDriveChar();
1.872 + path.Append( KCRuntimeFeaturesFileName );
1.873 +
1.874 + err = writeStream.Open( iFs, path, EFileWrite );
1.875 + CleanupClosePushL( writeStream );
1.876 +
1.877 + if( err == KErrPathNotFound || err == KErrNotFound )
1.878 + {
1.879 + // Create folder and file.
1.880 + if ( err == KErrPathNotFound )
1.881 + {
1.882 + path = KCFeatMgrPrivatePath;
1.883 + path[0] = iFs.GetSystemDriveChar();
1.884 + User::LeaveIfError( iFs.MkDirAll( path ) );
1.885 + path.Append( KCRuntimeFeaturesFileName );
1.886 + }
1.887 + User::LeaveIfError( writeStream.Create( iFs, path, EFileWrite ) );
1.888 +
1.889 + // Write header and entry
1.890 + RFeatureServerArray temp(1);
1.891 + CleanupClosePushL( temp );
1.892 + temp.AppendL( aFeature );
1.893 + WriteHeaderAndEntriesL( writeStream, temp );
1.894 + CleanupStack::PopAndDestroy( &temp );
1.895 + CleanupStack::PopAndDestroy( &writeStream );
1.896 + }
1.897 + else if( err == KErrNone )
1.898 + {
1.899 + // Close write- and open readstream
1.900 + CleanupStack::PopAndDestroy( &writeStream );
1.901 + RFileReadStream readStream;
1.902 + User::LeaveIfError( readStream.Open( iFs, path, EFileRead ) );
1.903 + CleanupClosePushL( readStream );
1.904 +
1.905 + // Read entries from file to temporary array
1.906 + TUint32 count;
1.907 + TUint32 countDSRs;
1.908 + ValidateHeaderL( readStream, count, countDSRs );
1.909 + TUint32 granularity = 8;
1.910 + if (count>granularity)
1.911 + {
1.912 + granularity=count;
1.913 + }
1.914 + RFeatureServerArray temp(granularity);
1.915 + CleanupClosePushL( temp );
1.916 + for(TInt i = 0; i < count; i++)
1.917 + {
1.918 + TFeatureServerEntry entry;
1.919 + entry.InternalizeL( readStream );
1.920 + temp.AppendL( entry );
1.921 + }
1.922 + // Close read-stream and handle temp array in cleanup stack
1.923 + CleanupStack::Pop( &temp );
1.924 + CleanupStack::PopAndDestroy( &readStream );
1.925 + CleanupClosePushL( temp );
1.926 +
1.927 + // Set or insert a new entry in to the array
1.928 + const TUid& uid( aFeature.FeatureUid() );
1.929 + TInt index = temp.FindInOrder( uid, FindByUid );
1.930 + if( index != KErrNotFound )
1.931 + {
1.932 + if ( aType != EFeatureFeatureDeleted )
1.933 + {
1.934 + temp[index].Set( aFeature);
1.935 + }
1.936 + else
1.937 + {
1.938 + temp.Remove( index );
1.939 + }
1.940 + }
1.941 + else
1.942 + {
1.943 + User::LeaveIfError( temp.InsertInOrder( aFeature, FindByUid ) );
1.944 + }
1.945 +
1.946 + //Create a Temporary File
1.947 + RFileWriteStream writeStreamTemp;
1.948 + const TPtrC KTestFile=_L("TFEATURES.DAT");
1.949 + TFileName tempPath( KCFeatMgrPrivatePath );
1.950 + tempPath[0] = iFs.GetSystemDriveChar();
1.951 + tempPath.Append( KTestFile );
1.952 + User::LeaveIfError(writeStreamTemp.Replace( iFs, tempPath, EFileWrite ));
1.953 + CleanupClosePushL( writeStreamTemp);
1.954 + WriteHeaderAndEntriesL( writeStreamTemp, temp );
1.955 + writeStreamTemp.CommitL();
1.956 + CleanupStack::PopAndDestroy(&writeStreamTemp);
1.957 + CleanupStack::PopAndDestroy( &temp );
1.958 + User::LeaveIfError(iFs.Replace(tempPath,path));
1.959 +
1.960 + }
1.961 + else
1.962 + {
1.963 + ERROR_LOG1( "CFeatMgrFeatureRegistry::UpdateRuntimeFeatures - err %d", err );
1.964 + User::Leave( err );
1.965 + }
1.966 + }
1.967 +
1.968 +// -----------------------------------------------------------------------------
1.969 +// CFeatMgrFeatureRegistry::WriteHeaderAndEntriesL
1.970 +// -----------------------------------------------------------------------------
1.971 +//
1.972 +void CFeatMgrFeatureRegistry::WriteHeaderAndEntriesL( RFileWriteStream &aStream,
1.973 + RFeatureServerArray& aArray )
1.974 + {
1.975 + FUNC_LOG
1.976 +
1.977 + TInt count( aArray.Count() );
1.978 + aStream.WriteUint32L( KFileType );
1.979 + aStream.WriteUint16L( KFileVersion );
1.980 + aStream.WriteUint16L( KFileFlags );
1.981 + aStream.WriteUint32L( count );
1.982 + aStream.WriteUint32L( 0 );
1.983 + for(TInt i = 0; i < count; i++)
1.984 + {
1.985 + aArray[i].ExternalizeL( aStream );
1.986 + }
1.987 + aStream.CommitL();
1.988 + }
1.989 +
1.990 +// -----------------------------------------------------------------------------
1.991 +// CFeatMgrFeatureRegistry::MergePluginFeatures
1.992 +// -----------------------------------------------------------------------------
1.993 +//
1.994 +void CFeatMgrFeatureRegistry::MergePluginFeaturesL(
1.995 + RArray<FeatureInfoCommand::TFeature>& aList )
1.996 + {
1.997 + FUNC_LOG
1.998 +
1.999 + TInt count = aList.Count();
1.1000 +
1.1001 + for ( TInt i = 0; i < count; i++ )
1.1002 + {
1.1003 + const TUid uid( TUid::Uid( aList[i].iFeatureID ) );
1.1004 + TInt index = SearchFeature( uid );
1.1005 +
1.1006 + if(index != KErrNotFound)
1.1007 + {
1.1008 + if ( !IsFlagSet( index, EFeatureBlackListed ) )
1.1009 + {
1.1010 + // Update support-status bit
1.1011 + TBitFlags32 flags( iFeatureList[index].FeatureFlags() );
1.1012 + flags.Assign( EFeatureSupported, aList[i].iValue);
1.1013 +
1.1014 + // Set existing entry in array
1.1015 + TFeatureServerEntry entry( uid, flags, iFeatureList[index].FeatureData());
1.1016 + iFeatureList[index].Set(entry);
1.1017 + }
1.1018 + else
1.1019 + {
1.1020 + INFO_LOG1( "CFeatMgrFeatureRegistry::MergePluginFeatures - 0x%08x blacklisted",
1.1021 + iFeatureList[i].FeatureUid().iUid );
1.1022 + }
1.1023 + }
1.1024 + else
1.1025 + {
1.1026 + TBitFlags32 flags;
1.1027 + flags.Assign( EFeatureSupported, aList[i].iValue);
1.1028 + // Insert new entry in array
1.1029 + TFeatureServerEntry newFeature( uid, flags, KDefaultData );
1.1030 + TInt err = iFeatureList.InsertInOrder( newFeature, FindByUid );
1.1031 + INFO_LOG2( "CFeatMgrFeatureRegistry::MergePluginFeatures - 0x%08x insert result %d",
1.1032 + newFeature.FeatureUid().iUid, err );
1.1033 + User::LeaveIfError(err);
1.1034 + }
1.1035 + }
1.1036 + }
1.1037 +
1.1038 +// -----------------------------------------------------------------------------
1.1039 +// CFeatMgrFeatureRegistry::MergePluginFeatures
1.1040 +// -----------------------------------------------------------------------------
1.1041 +//
1.1042 +void CFeatMgrFeatureRegistry::MergePluginFeaturesL( RFeatureArray& aList )
1.1043 + {
1.1044 + FUNC_LOG
1.1045 +
1.1046 + TInt count = aList.Count();
1.1047 +
1.1048 + for ( TInt i = 0; i < count; i++ )
1.1049 + {
1.1050 + //Check for feature flag errors
1.1051 + ValidateFeatureFlagL(aList[i].FeatureFlags()) ;
1.1052 + const TUid uid( aList[i].FeatureUid() );
1.1053 + TInt index = SearchFeature( uid );
1.1054 +
1.1055 + if( index != KErrNotFound )
1.1056 + {
1.1057 + if ( !IsFlagSet( index, EFeatureBlackListed ) )
1.1058 + {
1.1059 + // Set existing entry in array with new info and data
1.1060 + TFeatureServerEntry entry( uid, aList[i].FeatureFlags(), aList[i].FeatureData() );
1.1061 + iFeatureList[index].Set(entry);
1.1062 + }
1.1063 + else
1.1064 + {
1.1065 + INFO_LOG1( "CFeatMgrFeatureRegistry::MergePluginFeatures - 0x%08x blacklisted",
1.1066 + iFeatureList[i].FeatureUid().iUid );
1.1067 + }
1.1068 + }
1.1069 + else
1.1070 + {
1.1071 + // Insert new entry in array
1.1072 + TFeatureServerEntry newFeature( uid, aList[i].FeatureFlags(), aList[i].FeatureData() );
1.1073 + TInt err = iFeatureList.InsertInOrder( newFeature, FindByUid );
1.1074 + INFO_LOG2( "CFeatMgrFeatureRegistry::MergePluginFeatures - 0x%08x insert result %d",
1.1075 + newFeature.FeatureUid().iUid, err );
1.1076 + User::LeaveIfError(err);
1.1077 + }
1.1078 + }
1.1079 + }
1.1080 +
1.1081 +// -----------------------------------------------------------------------------
1.1082 +// CFeatMgrFeatureRegistry::ValidateFeatureFlag
1.1083 +// Following are the rule to check err in the ROM defined feature flags
1.1084 +// Rule 1) If a feature flag is blacklisted then setting any of modifiable, persisted, Un-initialised bit will be an error
1.1085 +// Rule 2) If a feature flag is non blacklisted, non modifiable setting any of Un-initialised, Persisted bit will be an error
1.1086 +// -----------------------------------------------------------------------------
1.1087 +//
1.1088 +
1.1089 +void CFeatMgrFeatureRegistry::ValidateFeatureFlagL(TBitFlags32 aFlags)
1.1090 + {
1.1091 + _LIT(KPanicCategory, "FEATMGR-FLAGS");
1.1092 +
1.1093 + if(!aFlags.IsSet(EFeatureRuntime)) //ROM defined feature flag error check
1.1094 + {
1.1095 + //Rule 1
1.1096 + if(aFlags.IsSet(EFeatureBlackListed) )
1.1097 + {
1.1098 + if(aFlags.IsSet(EFeatureModifiable) || aFlags.IsSet(EFeaturePersisted) || aFlags.IsSet(EFeatureUninitialized) )
1.1099 + {
1.1100 + //error
1.1101 + ::FmgrFatalErrorL(KErrArgument, KPanicCategory, EFmpInvalidFeatureBitFlagsRule1);
1.1102 + }
1.1103 + }
1.1104 +
1.1105 + //Rule 2
1.1106 + if (!aFlags.IsSet(EFeatureModifiable))
1.1107 + {
1.1108 + if (aFlags.IsSet(EFeaturePersisted) || aFlags.IsSet(EFeatureUninitialized) )
1.1109 + {
1.1110 + //error
1.1111 + ::FmgrFatalErrorL(KErrArgument, KPanicCategory, EFmpInvalidFeatureBitFlagsRule2);
1.1112 + }
1.1113 + }
1.1114 + }
1.1115 + else // Runtime feature this should not be in the rom
1.1116 + {
1.1117 + ::FmgrFatalErrorL(KErrArgument, KPanicCategory, EPanicInvalidFeatureInfo);
1.1118 + }
1.1119 + }
1.1120 +
1.1121 +/**
1.1122 + * This function is used to validate feature flags that are read from the features file on the ffs.
1.1123 + * This function is also used to validate feature flags that are modified or added with the execption of MergePluginFeatures.
1.1124 + * This validation compares the flags against a set of rules. This ffs file needs to be validate separately from the
1.1125 + * rom file. If the rom validation method is used a panic can occur which is appropriate for checking the rom but not
1.1126 + * for the ffs.
1.1127 + * This does not validate the dsr ranges.
1.1128 + * The following are the rules to check for errors in the run time defined feature flags
1.1129 + * Rule 1)Blacklisting of a run-time defined feature flag is an error
1.1130 + * Rule 2)Un-initialised feature flag should be modifiable.
1.1131 + */
1.1132 +void CFeatMgrFeatureRegistry::ValidateRuntimeFeatureFlagL(TBitFlags32 aFlags)
1.1133 + {
1.1134 +
1.1135 + //Rule 1 (Blacklisting of run-time defined feature aFlags is not allowed)
1.1136 + if(aFlags.IsSet(EFeatureBlackListed) )
1.1137 + {
1.1138 + //error
1.1139 + User::Leave( KErrArgument );
1.1140 + }
1.1141 +
1.1142 + //Rule 2 (non modifiable run-time feature aFlags should initialised
1.1143 + if(!aFlags.IsSet(EFeatureModifiable) && aFlags.IsSet(EFeatureUninitialized) )
1.1144 + {
1.1145 + //error
1.1146 + User::Leave( KErrArgument );
1.1147 + }
1.1148 + }
1.1149 +
1.1150 +
1.1151 +/**
1.1152 + * After restore, some features might have changed. This function will examine
1.1153 + * the differences between the old feature set and the newly restored feature set
1.1154 + * to discover if any changes have taken place: then it will handle the required
1.1155 + * notifications for new, deleted and changed featuers.
1.1156 + */
1.1157 +void CFeatMgrFeatureRegistry::HandleRestoredFeatureNotificationsL()
1.1158 + {
1.1159 + // All comparisons are between the new list iFeatureList and the old list iFeatureListBackup
1.1160 + TInt new_count = iFeatureList.Count();
1.1161 + TInt old_count = iFeatureListBackup.Count();
1.1162 +
1.1163 + // Three lists, defining the differences between the two arrays
1.1164 + RArray<TFeatureServerEntry> added;
1.1165 + RArray<TFeatureServerEntry> removed;
1.1166 + RArray<TFeatureServerEntry> changed;
1.1167 +
1.1168 + // Regarding the newer iFeatureList array
1.1169 + // Get the features according to the "new" iFeatureList array
1.1170 + for( TInt i=0; i < new_count; i++ )
1.1171 + {
1.1172 + // If not set, the feature flag is a ROM or plug-in
1.1173 + if( iFeatureList[i].FeatureFlags().IsSet(EFeatureRuntime) )
1.1174 + {
1.1175 + TUid uid( iFeatureList[i].FeatureUid() );
1.1176 + TInt index = iFeatureListBackup.FindInOrder( uid, FindByUid );
1.1177 +
1.1178 + // KErrNotFound, if no matching object can be found
1.1179 + if( KErrNotFound == index )
1.1180 + {
1.1181 + // Recently added feature
1.1182 + added.AppendL( iFeatureList[i] );
1.1183 + }
1.1184 + else
1.1185 + {
1.1186 + // Get the features in iFeatureList that have recently been altered
1.1187 + TFeatureServerEntry old_item = iFeatureListBackup[index];
1.1188 + TFeatureServerEntry new_item = iFeatureList[i];
1.1189 + TUint32 old_flags = old_item.FeatureFlags().Value();
1.1190 + TUint32 new_flags = new_item.FeatureFlags().Value();
1.1191 + unsigned long int old_data = old_item.FeatureData();
1.1192 + unsigned long int new_data = new_item.FeatureData();
1.1193 + // if any thing has changed, then add it to our list.
1.1194 + // there is no != overload for TBitFlags32
1.1195 + if( !( old_flags == new_flags) || !( old_data == new_data) )
1.1196 + {
1.1197 + // changed in the "new" iFeatureList array
1.1198 + changed.AppendL( iFeatureList[i] );
1.1199 + }
1.1200 + }
1.1201 +
1.1202 + } // end if ! EFeatureRuntime
1.1203 + } // end loop
1.1204 +
1.1205 +
1.1206 + // Regarding the older iFeatureListBackup array
1.1207 + // Get the features according to the "old" iFeatureListBackup array
1.1208 + for( TInt i=0; i < old_count; i++ )
1.1209 + {
1.1210 + // If not set, the feature flag is a ROM or plug-in
1.1211 + if( iFeatureListBackup[i].FeatureFlags().IsSet(EFeatureRuntime) )
1.1212 + {
1.1213 + TUid uid( iFeatureListBackup[i].FeatureUid() );
1.1214 + TInt index = iFeatureList.FindInOrder( uid, FindByUid );
1.1215 +
1.1216 + // KErrNotFound, if no matching object can be found
1.1217 + if( KErrNotFound == index )
1.1218 + {
1.1219 + // Recently removed feature
1.1220 + removed.AppendL( iFeatureListBackup[i] );
1.1221 + }
1.1222 + // the else has already been completed in previous loop
1.1223 +
1.1224 + } // end if ! EFeatureRuntime
1.1225 + } // end loop
1.1226 +
1.1227 + TInt size_added = added.Count();
1.1228 + TInt size_changed = changed.Count();
1.1229 + TInt size_removed = removed.Count();
1.1230 +
1.1231 + // notify the added features
1.1232 + for( TInt i = 0; i < size_added; i++ )
1.1233 + {
1.1234 + TFeatureServerEntry entry( added[i].FeatureUid(), added[i].FeatureFlags(), added[i].FeatureData() );
1.1235 + TFeatureChangeType changeType( EFeatureFeatureCreated );
1.1236 + iObserver.HandleFeatureChange( entry, changeType );
1.1237 + }
1.1238 +
1.1239 + // notify the changed features
1.1240 + for( TInt i = 0; i < size_changed; i++ )
1.1241 + {
1.1242 + TFeatureServerEntry entry( changed[i].FeatureUid(), changed[i].FeatureFlags(), changed[i].FeatureData() );
1.1243 + TFeatureChangeType changeType( EFeatureStatusUpdated );
1.1244 + iObserver.HandleFeatureChange( entry, changeType );
1.1245 + }
1.1246 +
1.1247 + // notify the delete features
1.1248 + for( TInt i = 0; i < size_removed; i++ )
1.1249 + {
1.1250 + TFeatureServerEntry entry( removed[i].FeatureUid(), removed[i].FeatureFlags(), removed[i].FeatureData() );
1.1251 + TFeatureChangeType changeType( EFeatureFeatureDeleted );
1.1252 + iObserver.HandleFeatureChange( entry, changeType );
1.1253 + }
1.1254 + }
1.1255 +
1.1256 +// -----------------------------------------------------------------------------
1.1257 +// CFeatMgrFeatureRegistry::SWIStart
1.1258 +// -----------------------------------------------------------------------------
1.1259 +//
1.1260 +TInt CFeatMgrFeatureRegistry::SWIStart(TUint aSWIProcessId)
1.1261 + {
1.1262 + FUNC_LOG
1.1263 +
1.1264 + // If a previous call to SWIStart was made then return an error indicating that SWI
1.1265 + // is already running. This assures that no two exes will enable the caching
1.1266 + // mechanism at the same time.
1.1267 + if( iSWICacheFeature )
1.1268 + {
1.1269 + INFO_LOG( "CFeatMgrFeatureRegistry::SWIStart - Already in use");
1.1270 + return KErrInUse;
1.1271 + }
1.1272 +
1.1273 + RProperty propertyHndl;
1.1274 + TInt err =propertyHndl.Attach(KUidSystemCategory, KSAUidSoftwareInstallKeyValue);
1.1275 + if (KErrNone != err)
1.1276 + {
1.1277 + return err;
1.1278 + }
1.1279 + TInt val = -1;
1.1280 + err = propertyHndl.Get(val);
1.1281 + propertyHndl.Close();
1.1282 +
1.1283 + if( KErrNone == err )
1.1284 + {
1.1285 + // If an installation/uninstallation has started and no finishing status has been set for it
1.1286 + if( ((val&ESASwisInstall) || (val&ESASwisUninstall)) && !(val&ESASwisStatusNone) )
1.1287 + {
1.1288 + // Set a flag to tell FeatMgr that features modified from this point onwards
1.1289 + // until a call to SWIEnd must be cached.
1.1290 + iSWICacheFeature = ETrue;
1.1291 + // SWI installation/uninstallation is in progress
1.1292 + iSWIStatus = ESWIInstalling;
1.1293 + // Set the ID of the process issuing Feature Manager commands to be cached
1.1294 + iSWIProcessId = aSWIProcessId;
1.1295 + // Start listening to P&S install property
1.1296 + TRAP(err, iSWIListener = CSWIListener::NewL(this));
1.1297 + if (KErrNone != err)
1.1298 + {
1.1299 + return err;
1.1300 + }
1.1301 +
1.1302 + // Start the timer to handle the case of the launched exe hanging or not calling SWIEnd
1.1303 + // after SWIStart
1.1304 + TRAP(err, iSWITimer = CSWITimer::NewL(TTimeIntervalMicroSeconds32(SWITIMEOUT), this));
1.1305 + if (KErrNone != err)
1.1306 + {
1.1307 + return err;
1.1308 + }
1.1309 +
1.1310 + INFO_LOG( "CFeatMgrFeatureRegistry::SWIStart - err KErrNone");
1.1311 + return KErrNone;
1.1312 + }
1.1313 + }
1.1314 + INFO_LOG( "CFeatMgrFeatureRegistry::SWIStart - err KErrNotReady");
1.1315 +
1.1316 + return KErrNotReady;
1.1317 + }
1.1318 +
1.1319 +// -----------------------------------------------------------------------------
1.1320 +// CFeatMgrFeatureRegistry::SWIEnd
1.1321 +// -----------------------------------------------------------------------------
1.1322 +//
1.1323 +TInt CFeatMgrFeatureRegistry::SWIEnd(TUint aSWIProcessId)
1.1324 + {
1.1325 + FUNC_LOG
1.1326 +
1.1327 + // reset the number of operations cached
1.1328 + iSWIOperations = 0;
1.1329 +
1.1330 + // If it is the same process that made a call to SWIStart and caching is in progress
1.1331 + if( iSWIProcessId == aSWIProcessId && iSWICacheFeature )
1.1332 + {
1.1333 + if( iSWIStatus == ESWIAborted )
1.1334 + {
1.1335 + SWIReset();
1.1336 +
1.1337 + INFO_LOG( "CFeatMgrFeatureRegistry::SWIEnd - SWIStatus = ESWIAborted");
1.1338 + return KErrNone;
1.1339 + }
1.1340 + else if( iSWIStatus == ESWIInstalling )
1.1341 + {
1.1342 + // Stop time-out
1.1343 + if( iSWITimer )
1.1344 + {
1.1345 + delete iSWITimer;
1.1346 + iSWITimer = NULL;
1.1347 + }
1.1348 + // Stop caching
1.1349 + iSWICacheFeature = EFalse;
1.1350 +
1.1351 + TInt err = KErrGeneral;
1.1352 +
1.1353 + if( !iOomOccured )
1.1354 + {
1.1355 + if( iAddFeatCount>0 )
1.1356 + {
1.1357 + err = iFeatureList.Reserve(iFeatureList.Count() + iAddFeatCount);
1.1358 + if (err == KErrNoMemory)
1.1359 + {
1.1360 + iSWIStatus = ESWIOutOfMemory;
1.1361 + }
1.1362 + }
1.1363 + }
1.1364 + else
1.1365 + {
1.1366 + err = KErrNoMemory;
1.1367 + iSWIStatus = ESWIOutOfMemory;
1.1368 + }
1.1369 +
1.1370 + INFO_LOG( "CFeatMgrFeatureRegistry::SWIEnd - SWIStatus = ESWIInstalling");
1.1371 + return err;
1.1372 + }
1.1373 + }
1.1374 +
1.1375 + INFO_LOG( "CFeatMgrFeatureRegistry::SWIEnd - err KErrNotReady");
1.1376 + return KErrNotReady;
1.1377 + }
1.1378 +
1.1379 +// -----------------------------------------------------------------------------
1.1380 +// CFeatMgrFeatureRegistry::SWICacheCommand
1.1381 +// -----------------------------------------------------------------------------
1.1382 +//
1.1383 +TInt CFeatMgrFeatureRegistry::SWICacheCommand(TSWIOperationCat aOptCat, TFeatureServerEntry aFeature)
1.1384 + {
1.1385 + FUNC_LOG
1.1386 +
1.1387 + TInt err;
1.1388 +
1.1389 + if (iSWIOperations >= MAXSWIOPS)
1.1390 + {
1.1391 + err = KErrArgument;
1.1392 + }
1.1393 + else if (iOomOccured)
1.1394 + {
1.1395 + err = KErrNoMemory;
1.1396 + }
1.1397 + else
1.1398 + {
1.1399 + if( aOptCat == ESWIAddFeat )
1.1400 + {
1.1401 + ++iAddFeatCount;
1.1402 + }
1.1403 + TSWICachedOperation operation;
1.1404 + operation.iFeatEntry = aFeature;
1.1405 + operation.iCat = aOptCat;
1.1406 + err = iSWICachedOperations.Append(operation);
1.1407 + if( err == KErrNoMemory)
1.1408 + {
1.1409 + iOomOccured = ETrue;
1.1410 + }
1.1411 + else if( err == KErrNone )
1.1412 + {
1.1413 + ++iSWIOperations;
1.1414 + }
1.1415 + }
1.1416 + return err;
1.1417 + }
1.1418 +
1.1419 +// -----------------------------------------------------------------------------
1.1420 +// CFeatMgrFeatureRegistry::CommitSWIFeatChanges
1.1421 +// -----------------------------------------------------------------------------
1.1422 +//
1.1423 +void CFeatMgrFeatureRegistry::CommitSWIFeatChanges()
1.1424 + {
1.1425 + FUNC_LOG
1.1426 +
1.1427 + // Commit all cached features.
1.1428 + if( !iSWICacheFeature )
1.1429 + {
1.1430 + TInt count = iSWICachedOperations.Count();
1.1431 +
1.1432 + for( TInt i=0; i<count; ++i )
1.1433 + {
1.1434 + TSWIOperationCat optCat = iSWICachedOperations[i].iCat;
1.1435 +
1.1436 + switch(optCat)
1.1437 + {
1.1438 + case ESWIAddFeat:
1.1439 + {
1.1440 + AddFeature( iSWICachedOperations[i].iFeatEntry, 0 );
1.1441 + }
1.1442 + break;
1.1443 + case ESWIDeleteFeat:
1.1444 + {
1.1445 + DeleteFeature( iSWICachedOperations[i].iFeatEntry.FeatureUid() );
1.1446 + }
1.1447 + break;
1.1448 + case ESWISetFeatAndData:
1.1449 + {
1.1450 + TUint32 data = iSWICachedOperations[i].iFeatEntry.FeatureData();
1.1451 + SetFeature( iSWICachedOperations[i].iFeatEntry.FeatureUid(),
1.1452 + iSWICachedOperations[i].iFeatEntry.FeatureFlags().Value(),
1.1453 + &data);
1.1454 + }
1.1455 + break;
1.1456 + case ESWISetFeatData:
1.1457 + {
1.1458 + TUint32 data = iSWICachedOperations[i].iFeatEntry.FeatureData();
1.1459 + SetFeature(iSWICachedOperations[i].iFeatEntry.FeatureUid(),
1.1460 + EFeatureSupportUntouch,&data);
1.1461 + }
1.1462 + break;
1.1463 + case ESWISetFeat:
1.1464 + {
1.1465 + SetFeature( iSWICachedOperations[i].iFeatEntry.FeatureUid(),
1.1466 + iSWICachedOperations[i].iFeatEntry.FeatureFlags().Value(),
1.1467 + NULL);
1.1468 + }
1.1469 + break;
1.1470 + default:
1.1471 + break;
1.1472 + };
1.1473 + }
1.1474 +
1.1475 + INFO_LOG( "CFeatMgrFeatureRegistry::CommitSWIFeatChanges - Committing completed");
1.1476 + }
1.1477 + SWIReset();
1.1478 + }
1.1479 +
1.1480 +// -----------------------------------------------------------------------------
1.1481 +// CFeatMgrFeatureRegistry::SWIReset
1.1482 +// -----------------------------------------------------------------------------
1.1483 +//
1.1484 +void CFeatMgrFeatureRegistry::SWIReset()
1.1485 + {
1.1486 + // Clear cached-features array
1.1487 + iSWICachedOperations.Close();
1.1488 +
1.1489 + // Reset caching flag
1.1490 + iSWICacheFeature = EFalse;
1.1491 +
1.1492 + // Reset SWI process Id
1.1493 + iSWIProcessId = 1;
1.1494 +
1.1495 + // Reset SWI completion status
1.1496 + iSWIStatus = ESWIComplete;
1.1497 +
1.1498 + // Reset the check for "out of memory" condition
1.1499 + iOomOccured = EFalse;
1.1500 +
1.1501 + // Reset the operations counter
1.1502 + iSWIOperations = 0;
1.1503 +
1.1504 + // No need to listen to P&S insall property any more
1.1505 + delete iSWIListener;
1.1506 + iSWIListener = NULL;
1.1507 +
1.1508 + // Stop time-out
1.1509 + if( iSWITimer )
1.1510 + {
1.1511 + delete iSWITimer;
1.1512 + iSWITimer = NULL;
1.1513 + }
1.1514 + }
1.1515 +
1.1516 +// -----------------------------------------------------------------------------
1.1517 +// CFeatMgrFeatureRegistry::SWIAborted
1.1518 +// -----------------------------------------------------------------------------
1.1519 +//
1.1520 +void CFeatMgrFeatureRegistry::SWIAborted()
1.1521 + {
1.1522 + FUNC_LOG
1.1523 +
1.1524 + // If abort occured before SWIEnd is called
1.1525 + if( iSWICacheFeature )
1.1526 + {
1.1527 + INFO_LOG( "CFeatMgrFeatureRegistry::SWIAborted - Abort occured before SWIEnd was called");
1.1528 + iSWIStatus = ESWIAborted;
1.1529 + }
1.1530 + else
1.1531 + {
1.1532 + INFO_LOG( "CFeatMgrFeatureRegistry::SWIAborted - Abort occured after SWIEnd was called");
1.1533 + SWIReset();
1.1534 + }
1.1535 + }
1.1536 +
1.1537 +// -----------------------------------------------------------------------------
1.1538 +// CFeatMgrFeatureRegistry::SWITimedOut
1.1539 +// -----------------------------------------------------------------------------
1.1540 +//
1.1541 +void CFeatMgrFeatureRegistry::SWITimedOut()
1.1542 + {
1.1543 + FUNC_LOG
1.1544 +
1.1545 + if( iSWICacheFeature )
1.1546 + {
1.1547 + INFO_LOG( "CFeatMgrFeatureRegistry::SWITimedOut - Timeout expired");
1.1548 + SWIReset();
1.1549 + }
1.1550 + }
1.1551 +
1.1552 +// -----------------------------------------------------------------------------
1.1553 +// CFeatMgrFeatureRegistry::SWICacheStarted
1.1554 +// -----------------------------------------------------------------------------
1.1555 +//
1.1556 +TBool CFeatMgrFeatureRegistry::SWICacheStarted()
1.1557 + {
1.1558 + return iSWICacheFeature;
1.1559 + }
1.1560 +
1.1561 +// -----------------------------------------------------------------------------
1.1562 +// CFeatMgrFeatureRegistry::SWICacheStatus
1.1563 +// -----------------------------------------------------------------------------
1.1564 +//
1.1565 +TBool CFeatMgrFeatureRegistry::SWICacheStatusOOM()
1.1566 + {
1.1567 + if( iSWIStatus == ESWIOutOfMemory )
1.1568 + {
1.1569 + return ETrue;
1.1570 + }
1.1571 + return EFalse;
1.1572 + }
1.1573 +
1.1574 +// End of File