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

// All rights reserved.

// This component and the accompanying materials are made available

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

// which accompanies this distribution, and is available

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

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

//

// INCLUDE FILES

#include <ecom/ecom.h>

#include <e32uid.h>

#include <f32file.h>

#include <e32property.h>

#include <sacls.h>

#include "featmgrconfiguration.h"

#include "featmgrfeatureregistry.h"

#include "featmgrserver.h"

#include "featmgrdebug.h"

#define MAXSWIOPS 50

#define SWITIMEOUT 15000000

// CONSTANTS

_LIT( KZFeaturesFileNameMatch, "feature*" );

_LIT( KCRuntimeFeaturesFileName, "features.dat" );

#ifdef EXTENDED_FEATURE_MANAGER_TEST

_LIT( KZFeaturesDir, "C:\\Private\\102836E5\\" );

_LIT( KCFeatMgrPrivatePath, "?:\\Private\\102836E5\\runtime\\" );

#else

_LIT( KZFeaturesDir, "Z:\\Private\\10205054\\" );

_LIT( KCFeatMgrPrivatePath, "?:\\Private\\10205054\\" );

#endif // EXTENDED_FEATURE_MANAGER_TEST

const TUint32 KDefaultData( 0x00000000 );

// Feature file header constants. 

// First 4 bytes of config file: ASCII f-e-a-t followed by file version and flags.

const TUint32 KFileType( 0x74616566 );

const TUint16 KFileVersion( 1 );

const TUint16 KFileFlags( 0 );

// ============================= LOCAL FUNCTIONS ===============================

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

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

// CFeatMgrFeatureRegistry::CFeatMgrFeatureRegistry

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

//

CFeatMgrFeatureRegistry::CFeatMgrFeatureRegistry( RFs& aFs,

    MFeatMgrRegistryObserver& aObserver  )

    :

    iObserver( aObserver ),

    iFs( aFs ),

    iSWICacheFeature( EFalse ),

    iSWIStatus( ESWIComplete ),

    iSWIProcessId( 1 ),

    iOomOccured(EFalse)

    {

    }

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

// CFeatMgrFeatureRegistry::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CFeatMgrFeatureRegistry::ConstructL()

    {

    }

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

// CFeatMgrFeatureRegistry::NewL

// Two-phased constructor.

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

//

CFeatMgrFeatureRegistry* CFeatMgrFeatureRegistry::NewL( RFs& aFs, 

    MFeatMgrRegistryObserver& aObserver )

    {

    CFeatMgrFeatureRegistry* self = 

        new( ELeave ) CFeatMgrFeatureRegistry( aFs, aObserver );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// Destructor

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

//

CFeatMgrFeatureRegistry::~CFeatMgrFeatureRegistry()

    {

    FUNC_LOG

    iFeatureList.Close();

    iRangeList.Close();

    iFeatureListBackup.Close();    

    iSWICachedOperations.Close();

    if( iSWIListener )

    	{

        delete iSWIListener;    	

    	}

    if( iSWITimer )

    	{

    	delete iSWITimer;

    	}

    }

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

// CFeatMgrFeatureRegistry::IsFeatureSupported

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

//  

TInt CFeatMgrFeatureRegistry::IsFeatureSupported( TFeatureServerEntry& aFeature )

    {

    TInt err( KErrNotFound );

    const TInt index = SearchFeature( aFeature.FeatureUid() );

    if ( index == KErrNotFound )

        {

        // Check whether feature in supported ranges

        TInt count( iRangeList.Count() );

        TUid uid( aFeature.FeatureUid() );

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

            {

            if( (uid.iUid >= iRangeList[i].iLowUid.iUid) && 

                (uid.iUid <= iRangeList[i].iHighUid.iUid) )

                {

                TBitFlags32 flags( 0 );

                flags.Assign( EFeatureSupported, KFeatureSupported );

                TFeatureServerEntry entry( aFeature.FeatureUid(), flags, KDefaultData );

                aFeature = entry;

                err = KFeatureSupported;

                break;

                }

            }

        }

    else if( IsFlagSet( index, EFeatureUninitialized ) )

        {

        // Supported status bit is not taken into account if feature not yet initialized

        err = KErrNotReady;

        }

    else if ( (index < iFeatureList.Count()) && IsFlagSet( index, EFeatureSupported ) )

        {

        TBitFlags32 flags = iFeatureList[index].FeatureFlags();

        flags.Assign( EFeatureSupported, KFeatureSupported );

        TUint32 data = iFeatureList[index].FeatureData();

        TFeatureServerEntry entry( aFeature.FeatureUid(), flags, data );

        aFeature = entry;

        err = KFeatureSupported;

        }

    else

        {

        err = KFeatureUnsupported;

        }

    return err;

    }

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

// CFeatMgrFeatureRegistry::AddFeature

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

//

TInt CFeatMgrFeatureRegistry::AddFeature( TFeatureServerEntry& aFeature, TUint aPrcId )

    {

    TInt err( KErrAccessDenied );

    if( iSWIProcessId == aPrcId && iSWICacheFeature )

		{

		err = SWICacheCommand(ESWIAddFeat, aFeature);

		}

    else

    	{

        const TInt index = SearchFeature( aFeature.FeatureUid() );

	    if ( index == KErrNotFound )

	        {

	        TBitFlags32 flags( aFeature.FeatureFlags() );

	        flags.Set( EFeatureRuntime );

	        //Check the feature falg is valid

	        TRAP(err,ValidateRuntimeFeatureFlagL(flags));

	        if (err != KErrNone)

	            return err;

	        TFeatureServerEntry entry( aFeature.FeatureUid(), flags, aFeature.FeatureData() );	       

			err = iFeatureList.InsertInOrder( entry, FindByUid );

	        if ( err == KErrNone )

	            {

	            TFeatureChangeType changeType( EFeatureFeatureCreated );

	            err = HandleChange( entry, changeType );

	            }

	        }

	    else

	        {

	        err = KErrAlreadyExists;

	        }

	    INFO_LOG("CFeatMgrFeatureRegistry::AddFeature - Features directly stored in registry");

    	}

    LOG_IF_ERROR1( err, "CFeatMgrFeatureRegistry::AddFeature - result %d", err );

    return err;

    }

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

// CFeatMgrFeatureRegistry::DeleteFeature

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

//

TInt CFeatMgrFeatureRegistry::DeleteFeature( TUid aFeature, TUint aPrcId  )

    {

    TInt err( KErrAccessDenied );

    if( iSWIProcessId == aPrcId && iSWICacheFeature )

    	{

    	err = SWICacheCommand(ESWIDeleteFeat, aFeature);

    	}

    else

    	{

	    // Check if the feature is runtime

	    TInt index = SearchFeature( aFeature );

	    if ( index == KErrNotFound )

	        {

	        return KErrNotFound;

	        }

	    if ( !iFeatureList[index].FeatureFlags().IsSet(EFeatureRuntime) )

	        {

	        return KErrAccessDenied;

	        }

	    TFeatureServerEntry entry = iFeatureList[index];

    	iFeatureList.Remove( index );

        TFeatureChangeType changeType( EFeatureFeatureDeleted );

        err = HandleChange( entry, changeType );

        INFO_LOG("CFeatMgrFeatureRegistry::DeleteFeature - Features deleted directly from registry");

        }

    LOG_IF_ERROR1( err, "CFeatMgrFeatureRegistry::DeleteFeature - result %d", err );

    return err;

    }

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

// CFeatMgrFeatureRegistry::SetFeature

//This method cannot set feature flag range in DSR unless it is added to before

//using CFeatMgrFeatureRegistry::AddFeature()

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

//	

TInt CFeatMgrFeatureRegistry::SetFeature( TUid aFeature, TInt aEnable, const TUint32 *aData, TUint aPrcId  )

    {

    FUNC_LOG

    TInt err( KErrNone );

    if( iSWIProcessId == aPrcId && iSWICacheFeature )

    	{

    	}

    else 

    	{

	    TInt index;

	    // Validate feature exists and is modifiable

	    err = ValidateFeature( aFeature, index );

	    if ( err != KErrNone )

	        {

			return err;

	        }

	    if ( (index >= 0 && index < iFeatureList.Count()) )

	        {

        	TBitFlags32 flags = iFeatureList[index].FeatureFlags();

	        TUint32 data = iFeatureList[index].FeatureData();

	        TFeatureChangeType changeType( EFeatureStatusUpdated );

	        // Update "supported" info according to request

	        if( (aEnable == EFeatureSupportEnable) || (aEnable == EFeatureSupportDisable) )

	            {

	            INFO_LOG1( "CFeatMgrFeatureRegistry::SetFeature() - aEnable %d", aEnable );

	            flags.Assign( EFeatureSupported, aEnable );

	            }

	        // When setting feature, always unset "uninitialized" bit

	        flags.Assign( EFeatureUninitialized, 0 );

	        // Update data whenever applied

	        if( aData )

	            {

	            INFO_LOG1( "CFeatMgrFeatureRegistry::SetFeature() - aData %d", aData );

	            data = *aData;

	            if( aEnable == EFeatureSupportUntouch )

	                {

	                changeType = EFeatureDataUpdated;

	                }

	            else

	                {

	                changeType = EFeatureStatusDataUpdated;

	                }

	            }

	        TFeatureServerEntry entry( aFeature, flags, data );

	        //Check if the feature will actually change

	        if(iFeatureList[index].FeatureFlags() == flags && iFeatureList[index].FeatureData() == data )

	        	{

	        	//No change were made, set change type to EFeatureNoChange

	        	changeType = EFeatureNoChange;

	        	}

	        else

	        	{

	        	// Set the feature entry in list with updated information

	        	iFeatureList[index].Set(entry);

	        	}

	        err = HandleChange( entry, changeType );

	        }

    	}

    LOG_IF_ERROR1( err, "CFeatMgrFeatureRegistry::SetFeature - result %d", err );

    return err;

    }

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

// CFeatMgrFeatureRegistry::HandleChange

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

//  

TInt CFeatMgrFeatureRegistry::HandleChange( TFeatureServerEntry& aFeature, 

    TFeatureChangeType aType )

    {

    FUNC_LOG

    TInt err( KErrNone );

    // Update feature file, when feature is specified as persisted.

    if ( aFeature.FeatureFlags().IsSet( EFeaturePersisted ) )

        {

        TRAP( err, UpdateRuntimeFeaturesFileL( aFeature, aType ) );

        LOG_IF_ERROR1( err, "CFeatMgrFeatureRegistry::HandleChange - update error %d", err );

        // It is questionnable whether we should remove the feature from iFeatureList.

        // However, feature is usable until device is powered down and features reloaded.

        // if ( err == KErrNone )

        }

    // It is also questionnable whether we should suppress notification in case file 

    // update failed.

    // if ( err == KErrNone )

    iObserver.HandleFeatureChange( aFeature, aType );

    return err;

    }

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

// CFeatMgrFeatureRegistry::ValidateFeature

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

//  

TInt CFeatMgrFeatureRegistry::ValidateFeature( TUid aFeature, TInt &aIndex )

    {

    TInt err( KErrNone );

    aIndex = SearchFeature( aFeature );

    if ( aIndex == KErrNotFound )

        {

        err = KErrNotFound;

        }

    else if ( !IsFlagSet( aIndex, EFeatureModifiable ) )

        {

        err = KErrAccessDenied;

        }

    return err;

    }

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

// CFeatMgrFeatureRegistry::FindByUid

// Returns Zero if UIDs do match.

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

//  

TInt CFeatMgrFeatureRegistry::FindByUid( const TUid *aFeature, 

    const TFeatureServerEntry& aItem )

    {

    if ( aFeature->iUid < aItem.FeatureUid().iUid )

        {

        return -1;

        }

    else if ( aFeature->iUid > aItem.FeatureUid().iUid )

        {

        return 1;

        }

    return 0;

    }

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

// CFeatMgrFeatureRegistry::FindByUid

// Returns Zero if UIDs do match.

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

//  

TInt CFeatMgrFeatureRegistry::FindByUid( const TFeatureServerEntry& aFeature, 

    const TFeatureServerEntry& aItem )

    {

    if ( aFeature.FeatureUid().iUid < aItem.FeatureUid().iUid )

        {

        return -1;

        }

    else if ( aFeature.FeatureUid().iUid > aItem.FeatureUid().iUid )

        {

        return 1;

        }

    return 0;

    }

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

// CFeatMgrFeatureRegistry::SearchFeature

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

//  

TInt CFeatMgrFeatureRegistry::SearchFeature( TUid aFeature )

    {

    const TUid& uid( aFeature );

    return iFeatureList.FindInOrder( uid, FindByUid );

    }

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

// CFeatMgrFeatureRegistry::IsFlagSet

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

//  

TBool CFeatMgrFeatureRegistry::IsFlagSet( TInt aIndex, TFeatureFlags aFlag )

    {

    TBool isSet( EFalse );

    if( aIndex < iFeatureList.Count() )

        {

        isSet = iFeatureList[aIndex].FeatureFlags().IsSet(aFlag);

        }

    return isSet;

    }

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

// CFeatMgrFeatureRegistry::SupportedFeatures

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

//  

void CFeatMgrFeatureRegistry::SupportedFeaturesL( RFeatureUidArray& aSupportedFeatures )

    {

    FUNC_LOG

    TInt count = iFeatureList.Count();

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

        {

        if( IsFlagSet( i, EFeatureSupported) )

            {

            aSupportedFeatures.AppendL( iFeatureList[i].FeatureUid() );

            }

        }

    }

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

// CFeatMgrFeatureRegistry::NumberOfSupportedFeatures

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

//  

TInt CFeatMgrFeatureRegistry::NumberOfSupportedFeatures()

    {

    FUNC_LOG

    TInt count = iFeatureList.Count();

    TInt countSupported(0);

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

        {

        if( IsFlagSet( i, EFeatureSupported) )

            {

            countSupported++;

            }

        }

    return countSupported;

    }

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

TInt CFeatMgrFeatureRegistry::ResetFeatures()

    {

    FUNC_LOG

    // backup the feature list before it is destroyed

    iFeatureListBackup.Reset();

    TInt count = iFeatureList.Count();

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

        {

        iFeatureListBackup.Append( iFeatureList[i] );

        }

    // destroy the feature list

    iFeatureList.Reset();

    iFeatureList.Close();

    iRangeList.Reset();

    iRangeList.Close();

    return( 0 );