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

// All rights reserved.

// This component and the accompanying materials are made available

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

// which accompanies this distribution, and is available

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

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

//

// INCLUDE FILES

#include <ecom/ecom.h>

#include <e32uid.h>

#include "featmgrconfiguration.h"

#include "featmgrserver.h"

#include "featmgrsession.h"

#include "featmgrpluginhandler.h"

#include "featmgrdebug.h"

#include "featmgrsecuritypolicy.h"

#include <f32file.h>

#include <s32file.h>

// LOCAL CONSTANTS AND MACROS

#ifdef EXTENDED_FEATURE_MANAGER_TEST

_LIT( KPanicCategory, "EnhancedFeatMgrServer" );

#else

_LIT( KPanicCategory, "FeatMgrServer" );

#endif // EXTENDED_FEATURE_MANAGER_TEST

// LOCAL FUNCTION PROTOTYPES

TInt E32Main(); // Process entry point

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

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

// CFeatMgrServer::CFeatMgrServer

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

// might leave.

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

//

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

    :

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

    iPluginsReady(EFalse), 

    iPluginsDeleted( EFalse ),

    iPendingRequests( ETrue ),

    iFeaturesReady(EFalse)

    {

    // Nothing to do

    }

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

// CFeatMgrServer::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CFeatMgrServer::ConstructL()

    {

    FUNC_LOG

#ifndef EXTENDED_FEATURE_MANAGER_TEST

    // Set server process system critical

    User::SetProcessCritical(User::ESystemCritical);

#else

    iShutdown.ConstructL();

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

    if( !iShutdown.IsActive() )

        {

        iShutdown.Start();

        }

#endif

    // Add server to active scheduler

    StartL( KServerProcessName );

    // Connect to file server.

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

    // register BUR

    iBackupNotification = CBaBackupSessionWrapper::NewL();

    // register the file 

	TFileName temp( iRegistry->GetFeaturesFilePathAndName() );

    iBackupNotification->RegisterFileL( temp, *this );

    // feature registry

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

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

    switch (err)

    	{

    	case KErrNotFound:

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

    		User::Panic( KPanicCategory, EPanicNoFeatureFiles );

    		break;

    	case KErrCorrupt:

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

    	    User::Panic( KPanicCategory, EPanicInvalidFeatureInfo );

    	    break;

    	default:

    		User::LeaveIfError(err);

    		break;

    	}

    // List and load plugins and feature info.

    TBool found = LoadPluginsL();

    if( found )

        {

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

        iTimer = CFeatMgrTimer::NewL( *this );

       }

    else

        {

        iRegistry->ReadRuntimeFeaturesL( iFeaturesReady );

        }

    }

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

// CFeatMgrServer::NewLC

// Two-phased constructor.

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

//

CFeatMgrServer* CFeatMgrServer::NewLC(const TInt aPriority)

    {

    FUNC_LOG

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

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

#ifdef EXTENDED_FEATURE_MANAGER_TEST

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

// A new session is being created

// Cancel the shutdown timer if it was running

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

//

void CFeatMgrServer::AddSession()

    {

    FUNC_LOG

    ++iSessionCount;

    iShutdown.Cancel();

    }

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

// A session is being destroyed

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

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

//

void CFeatMgrServer::DropSession()

    {

    FUNC_LOG

    if (--iSessionCount==0)

        {

        if( !iShutdown.IsActive() )

            {

            iShutdown.Start();

            }

        }

    }

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

// CShutDown

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

inline CShutdown::CShutdown()

    :CTimer(-1)

    {

    CActiveScheduler::Add(this);

    }

inline void CShutdown::ConstructL()

    {

    CTimer::ConstructL();

    }

inline void CShutdown::Start()

    {

    FUNC_LOG

    After(KShutdownTimeout);

    }

void CShutdown::RunL()

    {

    FUNC_LOG

    CActiveScheduler::Stop();

    }

#endif // EXTENDED_FEATURE_MANAGER_TEST

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

// Destructor

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

//

CFeatMgrServer::~CFeatMgrServer()

    {

    FUNC_LOG

    // Close all open sessions

	CFeatMgrSession* session=NULL;

	iSessionIter.SetToFirst();

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

	    {

		delete session;

	    }

    // Delete plugin handlers    

    if ( !iPluginsDeleted )

        {

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

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

        DeletePlugins();

        } 

    delete iTimer;

    iFs.Close();

    iPluginList.Close();

    // De register Backup and Restore and cleanup memory

    if( iBackupNotification ) 

    	{

		TFileName temp( iRegistry->GetFeaturesFilePathAndName() );

    	iBackupNotification->DeregisterFile( temp );

    	delete iBackupNotification;

    	iBackupNotification = NULL;

    	}

    delete iRegistry;

    }

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

// CFeatMgrServer::NewSessionL

// Creates a new CSession2

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

//

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

                                     const RMessage2& /*aMessage*/ ) const

    {

    FUNC_LOG

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

                                                 KServerVersionMinor, 

                                                 KServerVersionBuild ), 

                                                 aVersion ) )

        {

        User::Leave( KErrNotSupported );

        }

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

    return( session );

    }

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

// CFeatMgrServer::TimerFired

// Handles timer firing. 

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

//

void CFeatMgrServer::TimerFired()

    {

    FUNC_LOG

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

    if ( !iPluginsDeleted )

        {

        DeletePlugins();

        } 

    }

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

// CFeatMgrServer::HandleFeatureChange()

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

//

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

    {

    FUNC_LOG

    CFeatMgrSession* session=NULL;

	TDblQueIter<CSession2> local_iSessionIter = iSessionIter;

	local_iSessionIter.SetToFirst();

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

	    {

		session->ServiceNotifications( aFeature, aType );

	    }

    }

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

// CFeatMgrServer::ResetAndDestroyArray

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

// 

static void ResetAndDestroyArray( TAny* aPtr )

    {

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

    array->ResetAndDestroy();

    array->Close();

    }

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

// CFeatMgrServer::LoadPluginsL()

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

//

TBool CFeatMgrServer::LoadPluginsL()

    {

    FUNC_LOG

    RImplInfoPtrArray implInfoArray;

    TBool ret( EFalse );

    // Use ECom to read information about existing interface implementations

    _LIT8( KEmptyString, "" );

    TEComResolverParams resolverParams;

    resolverParams.SetDataType (KEmptyString);

    resolverParams.SetWildcardMatch (ETrue);

    TCleanupItem cleanupItem( ResetAndDestroyArray, &implInfoArray );

    CleanupStack::PushL( cleanupItem );

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

    REComSession::ListImplementationsL( KFeatureInfoPluginInterfaceUid,

#ifndef EXTENDED_FEATURE_MANAGER_TEST                                         

                                        resolverParams,

                                        KRomOnlyResolverUid, 

#endif                                        

                                        implInfoArray);

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

    // Check if any plugin was found. 

    TInt count = implInfoArray.Count();

    if ( count > 0 )

        {

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

            {

            CFeatMgrPluginHandler* pluginHandler = NULL;

            TInt err( KErrNone );

            // Create handler

            TRAP( err, pluginHandler = CFeatMgrPluginHandler::NewL( 

                  implInfoArray[i]->ImplementationUid(), *this) );

            LOG_IF_ERROR1( err, "CFeatMgrServer::LoadPluginsL() - pluginHandler creation err %d", err );

            // Apply first request for plugin to process

            if ( err == KErrNone )

                {

                TRAP( err, pluginHandler->SendCommandL( 

                    FeatureInfoCommand::ELoadFeatureInfoCmdId ) );

                }            

            // Panic if error sth else than not supported        

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

                {

                ERROR_LOG2( "CFeatMgrServer::LoadPluginsL() - implementationUid: 0x%x, error: %d - going to panic",

                                        implInfoArray[i]->ImplementationUid(), err );

                User::Panic( KPanicCategory, EPanicLoadPluginError );                           

                }

            // If simple features are not supported by the plugin search for enhanced ones

            else if ( err == KErrNotSupported )

            	{

            	// Reset error code

            	err = KErrNone;

                TRAP( err, pluginHandler->SendCommandL(

                    FeatureInfoCommand::ELoadEnhancedFeatureInfoCmdId ) );

                // Panic if error since in this case the plugin does not support any feature

            	if ( err != KErrNone )

	            	{

	                ERROR_LOG2( "CFeatMgrServer::LoadPluginsL() - implementationUid: 0x%x, error: %d - going to panic",

	                        implInfoArray[i]->ImplementationUid(), err );

	                User::Panic( KPanicCategory, EPanicLoadPluginError );

	            	}

	            }

            // If a simple or enhanced feature is supported by the plugin then append the plugin to the list

            if ( err == KErrNone )

            	{

                INFO_LOG1( "CFeatMgrServer::LoadPluginsL() - Add info of implementationUid: 0x%x",

                                        implInfoArray[i]->ImplementationUid() );

                // Add information of the plugin to the plugin list

                SFeatMgrPluginInfo plugin;

                plugin.iPluginHandler = pluginHandler;

                // Set all plugins as not ready initially

                plugin.iPluginReady = EFalse;

                TInt err = iPluginList.Append(plugin);

                if ( err != KErrNone )

                    {

                    ERROR_LOG2( "CFeatMgrServer::LoadPluginsL() - Saving plugin info of implementationUid: 0x%x, err %d",

                                                  implInfoArray[i]->ImplementationUid(), err );

                    User::Leave( err );

                    }

                }

            }

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

                           KFeatureInfoPluginInterfaceUid );

        ret = ETrue;

        }

    else

        {

        iPluginsReady = ETrue; // Plugins not found.

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

                           KFeatureInfoPluginInterfaceUid );

        ret = EFalse;

        }

    CleanupStack::PopAndDestroy(&implInfoArray);

    return ret;

    }

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

// CFeatMgrServer::PluginsReady()

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

TBool CFeatMgrServer::PluginsReady() const

    {

    FUNC_LOG

    return(iPluginsReady);

   	}

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

// CFeatMgrServer::ServicePendingRequests()

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

void CFeatMgrServer::ServicePendingRequests()

    {

    FUNC_LOG

    CFeatMgrSession* session=NULL;

	iSessionIter.SetToFirst();

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

	    {

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

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

	    }

   	iPendingRequests = EFalse;

   	}

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

// CFeatMgrServer::DeletePlugins()

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

void CFeatMgrServer::DeletePlugins()

    {

    FUNC_LOG

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

    iPluginsReady = ETrue;

    TInt err( KErrNone );

    // Load runtimefeatures.txt if not loaded yet.

    if ( !iFeaturesReady )

        { 

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

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

        }

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

    if ( iPendingRequests )

        {

        ServicePendingRequests();

        }

    // Delete plugin handlers

    TInt count = iPluginList.Count();

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

        {

        delete iPluginList[i].iPluginHandler;

        iPluginList[i].iPluginHandler = NULL;

        }

    // Reset list of plugins

    iPluginList.Reset();

    // Signal final closure of ecom session

	REComSession::FinalClose();

	// All plugin handlers deleted

	iPluginsDeleted = ETrue;

	}

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

// CFeatMgrServer::FeatureInfoL()

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

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

        CFeatMgrPluginHandler* aPluginHandler )

    {

    FUNC_LOG

    // Save feature info received from the plugin

    TInt pluginCount = iPluginList.Count();

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

        {

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

            {

            iRegistry->MergePluginFeatures( aFeatureList );

            // Send command to load enhanced feature info

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

                FeatureInfoCommand::ELoadEnhancedFeatureInfoCmdId ) );

            // Panic if error sth else than not supported