/*

* Copyright (c) 2008-2008 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:  CFContextSourceManager class implementation.

*

*/

#include <ecom/ecom.h>

#include <centralrepository.h>

#include <bautils.h>

#include "cfoperationpluginmanager.h"

#include "ContextFrameworkPrivateCRKeys.h"

#include "cfoperationplugin.h"

#include "cfoperationservices.h"

#include "cftrace.h"

#include "CFScriptEngineInterface.h"

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

/**

* Clenup operation for RImplInfoPtrArray

*/

LOCAL_C void CleanUpImplInfoArray( TAny* aParams )

    {

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

    array->ResetAndDestroy();

    }

/**

* Push operations

*/

LOCAL_C void CleanupResetAndDestroyPushL( RImplInfoPtrArray& aArray )

    {

    TCleanupItem item( CleanUpImplInfoArray, &aArray );

    CleanupStack::PushL( item );

    }

/**

* Operation plug-in information.

*/

NONSHARABLE_CLASS( TCFOperationPluginInfo )

    {

    public:

        TCFOperationPluginInfo( CImplementationInformation& aImplInfo,

            CCFOperationPlugIn* aPlugIn ):

            iImplUid( aImplInfo.ImplementationUid() ),

            iImplVersion( aImplInfo.Version() ),

            iMissing( EFalse ),

            iPlugIn( aPlugIn )

            {

            }

    public:

        TUid iImplUid;

        TInt iImplVersion;

        TBool iMissing;

        CCFOperationPlugIn* iPlugIn;

    };

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

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

// CCFOperationPluginManager::NewL

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

//

EXPORT_C CCFOperationPluginManager* CCFOperationPluginManager::NewL(

    MCFScriptEngineInterface& aScriptEngine )

    {

    FUNC_LOG;

    CCFOperationPluginManager* self =

        CCFOperationPluginManager::NewLC( aScriptEngine );

    CleanupStack::Pop( self );

    return self;

    }

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

// CCFOperationPluginManager::NewLC

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

//

EXPORT_C CCFOperationPluginManager* CCFOperationPluginManager::NewLC(

    MCFScriptEngineInterface& aScriptEngine )

    {

    FUNC_LOG;

    CCFOperationPluginManager* self =

        new( ELeave ) CCFOperationPluginManager( aScriptEngine );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CCFOperationPluginManager::~CCFOperationPluginManager

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

//

EXPORT_C CCFOperationPluginManager::~CCFOperationPluginManager()

    {

    FUNC_LOG;

    // Delete plug-ins

    TInt count = iPlugIns.Count();

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

        {

        delete iPlugIns[i].iPlugIn;

        }

    iPlugIns.Close();

    }

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

// CCFOperationPluginManager::CCFOperationPluginManager

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

//

CCFOperationPluginManager::CCFOperationPluginManager(

    MCFScriptEngineInterface& aScriptEngine ):

    iScriptEngine( aScriptEngine )

    {

    FUNC_LOG;

    // Nothing to do

    }

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

// CCFOperationPluginManager::ConstructL

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

//

void CCFOperationPluginManager::ConstructL()

    {

    FUNC_LOG;

    }

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

// CCFOperationPluginManager::InitializePhaseL

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

//

void CCFOperationPluginManager::InitializePhaseL(

    CCFPhaseBase::TCFPhaseId aPhase )

    {

    FUNC_LOG;

    switch( aPhase )

        {

        case CCFPhaseBase::ECFDeviceStarting:

            {

            InitDeviceStartingPhaseL();

            break;

            }

        case CCFPhaseBase::ECFLoadingPlugins:

            {

            InitLoadingPluginsPhaseL();

            break;

            }

        default:

            {

            break;

            }

        }

    }

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

// CCFOperationPluginManager::SetEventHandler

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

//

void CCFOperationPluginManager::SetEventHandler( MCFStarterEventHandler& /*aEventHandler*/ )

    {

    FUNC_LOG;	  

    }

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

// CCFOperationPluginManager::CreateAndInitializePlugInL

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

//

CCFOperationPlugIn* CCFOperationPluginManager::CreateAndInitializePlugInL(

    const TUid& aImplementationUid, TOperationPluginInitParams& aParams )

    {

    FUNC_LOG;

    // Create plug-in

    CCFOperationPlugIn* plugIn = CCFOperationPlugIn::NewL(

        aImplementationUid,

        &aParams );

    CleanupStack::PushL( plugIn );

    // Cleanup

    CleanupStack::Pop( plugIn );

    return plugIn;

    }

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

// CCFOperationPluginManager::InitDeviceStartingPhaseL

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

//

void CCFOperationPluginManager::InitDeviceStartingPhaseL()

    {

    FUNC_LOG;

    INFO( "Checking plug-ins in [Init Device Starting] phase." );

    UpdatePlugInsL();

    }

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

// CCFOperationPluginManager::InitLoadingPluginsPhaseL

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

//

void CCFOperationPluginManager::InitLoadingPluginsPhaseL()

    {

    FUNC_LOG;

    }

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

// CCFOperationPluginManager::LoadPluginL

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

//

void CCFOperationPluginManager::LoadPluginL(

	CImplementationInformation& aImplInfo )

    {

    FUNC_LOG;

    INFO_2( "Loading operation plug-in with UID [%x], version [%d]",

    		aImplInfo.ImplementationUid().iUid,	aImplInfo.Version() );

    HEAP_2( "Before loading operation plug-in with UID [%x], version [%d]",

            aImplInfo.ImplementationUid().iUid, aImplInfo.Version() );

    TOperationPluginInitParams initParams;

    CCFOperationPlugIn* plugIn = NULL;

    TRAPD( err, plugIn = CreateAndInitializePlugInL(

    		aImplInfo.ImplementationUid(),

    		initParams ) );

    if( err == KErrNone )

        {

        // Plug-in loaded succesfully, store it

        TCFOperationPluginInfo info( aImplInfo, plugIn );

        TInt err = iPlugIns.Append( info );

        if( err != KErrNone )

            {

            ERROR_1( err, "Operation plug-in: [%x] could not be appended in array",

            		aImplInfo.ImplementationUid().iUid );

            delete plugIn;

            plugIn = NULL;

            }

        else

            {

            INFO_1( "Operation plug-in: [%x] succesfully loaded",

            		aImplInfo.ImplementationUid().iUid );

            }

        }

    else

        {

        ERROR_2( err, "Operation plug-in [%x] load error: [%d]",

        		aImplInfo.ImplementationUid().iUid, err );

        err = AddToBlackList( aImplInfo.ImplementationUid() );

        ERROR( err, "Failed to add UID to blacklist" );

        }

    HEAP_2( "After loading operation plug-in with UID [%x], version [%d]",

            aImplInfo.ImplementationUid().iUid, aImplInfo.Version() );

    }

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

// CCFOperationPluginManager::UpdatePlugInsL

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

//

void CCFOperationPluginManager::UpdatePlugInsL()

	{

    FUNC_LOG;

    // List all plugins

    RImplInfoPtrArray implInfoArray;

    CleanupResetAndDestroyPushL( implInfoArray );

    REComSession::ListImplementationsL( KOperationPlugInInterface,

        implInfoArray );

    RemoveBlackListed( implInfoArray );

    // Check if the update is install or uninstall based

    TInt allCount = implInfoArray.Count();

    TInt loadedCount = iPlugIns.Count();

    INFO_1( "Found %d operation plug-in implementations from ecom", allCount );

    INFO_1( "%d operation plug-ins currently loaded", loadedCount );

    // Check if there were plugins installed

    if( allCount >= loadedCount )

        {

        for( TInt i = iPlugIns.Count() - 1; i >= 0; i-- )

            {

            TCFOperationPluginInfo& pluginInfo = iPlugIns[i];

            for( TInt ii = 0; ii < implInfoArray.Count(); ii++ )

                {

                CImplementationInformation* implInfo = implInfoArray[ii];

                if( implInfo->ImplementationUid() == pluginInfo.iImplUid )

                    {

                    TInt oldVer = pluginInfo.iImplVersion;

                    TInt newVer = implInfo->Version();

                    // Check if the version has increased

                    if( newVer > oldVer )

                        {

                        // Remove scripts which have a dependency to the provider

                        // which is being deleted

                        TInt err = iScriptEngine.RemoveScriptByProviderUid(

                            pluginInfo.iImplUid, ETrue );

                        INFO_2( "Remove script by provider [%x] completed with code [%d]",

                            pluginInfo.iImplUid.iUid, err );

                        // Delete old plugin

                        ReleasePlugIn( pluginInfo.iPlugIn );

                        iPlugIns.Remove( i );

                        // Clean up old implementation

                        REComSession::FinalClose();

                        // Load the new version

                        TRAP( err, LoadPluginL( *implInfo ) );

                        ERROR_3( err, "Upgrade of new version of operation plugin [%x], oldVer: [%d], newVer: [%d] failed",

                            implInfo->ImplementationUid().iUid, oldVer, newVer );

                        if( err == KErrNone )

                            {

                            INFO_3( "Upgraded new version of operation plugin [%x], oldVer: [%d], newVer: [%d]",

                                implInfo->ImplementationUid().iUid, oldVer, newVer );

                            // Rollback removed scripts

                            iScriptEngine.RollbackScripts();

                            }

                        }

                    delete implInfo;

                    implInfoArray.Remove( ii );

                    break;

                    }

                }

            }

        // Check if the installed plugin was not an updgrade but a new plugin

        for( TInt i = 0; i < implInfoArray.Count(); i++ )

            {

            CImplementationInformation* implInfo = implInfoArray[i];

            TRAPD( err, LoadPluginL( *implInfo ) );

            if( err == KErrNone )

                {

                INFO_2( "Loaded operation plugin [%x], ver: [%d]",

                    implInfo->ImplementationUid().iUid, implInfo->Version() );

                }

            else

                {

                ERROR_2( err, "Failed to load operation plugin [%x], ver: [%d]",

                    implInfo->ImplementationUid().iUid, implInfo->Version() );

                }

            }

        }

    // Check if there were plugins unistalled

    else

        {

        for( TInt i = 0; i < iPlugIns.Count(); i++ )

            {

            TCFOperationPluginInfo& pluginInfo = iPlugIns[i];

            pluginInfo.iMissing = ETrue;

            }

        // Check that which plugins are missing

        for( TInt i = 0; i < implInfoArray.Count(); i++ )

            {

            CImplementationInformation* implInfo = implInfoArray[i];

            for( TInt i = 0; i < iPlugIns.Count(); i++ )

                {

                TCFOperationPluginInfo& pluginInfo = iPlugIns[i];

                if( pluginInfo.iImplUid == implInfo->ImplementationUid() )

                    {

                    pluginInfo.iMissing = EFalse;

                    break;

                    }

                }

            }

        // Delete missing plugins

        for( TInt i = iPlugIns.Count() - 1; i >= 0; i-- )

            {

            TCFOperationPluginInfo& pluginInfo = iPlugIns[i];

            if( pluginInfo.iMissing )

                {

                // Remove scripts which have a dependency to the provider

                // which is being deleted

                TInt err = iScriptEngine.RemoveScriptByProviderUid(

                    pluginInfo.iImplUid, ETrue );

                INFO_2( "Remove script by provider [%x] completed with code [%d]",

                    pluginInfo.iImplUid.iUid, err );

                // Release plug-in

                ReleasePlugIn( pluginInfo.iPlugIn );

                INFO_2( "Removed uninstalled operation plugin [%x], ver: [%d]",

                    pluginInfo.iImplUid.iUid, pluginInfo.iImplVersion );

                iPlugIns.Remove( i );

                // Clean up old implementation

                REComSession::FinalClose();

                // Rollback removed scripts since we might have uninstalled

                // plug-in which original version is in rom

                iScriptEngine.RollbackScripts();

                }

            }

        }

    // Cleanup

    CleanupStack::PopAndDestroy( &implInfoArray );

	}

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

// CCFOperationPluginManager::ParseScriptRootL

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

//

CCFScriptRoot* CCFOperationPluginManager::ParseScriptRootL(

    CCFOperationNode* aParent,

    CMDXMLNode& aNode,

    MCFOperationServices& aOperationServices,

    TUid& aUid )

    {

    CCFScriptRoot* root = DoParseScriptRootL(

        aParent, aNode, aOperationServices, aUid );

    if ( root )

        {

        return root;

        }

    // Operation not found, check new plugins.

    UpdatePlugInsL();

    root = DoParseScriptRootL(

        aParent, aNode, aOperationServices, aUid );

    if ( root )

        {

        return root;

        }

    // Generate error info to log.

    return NULL;

    }

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

// CCFOperationPluginManager::ParseL

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

//

CCFOperationNode* CCFOperationPluginManager::ParseL( CCFOperationNode* aParent,

    CMDXMLNode& aDOMNode,

    MCFOperationServices& aOperationServices,

    TUid& aUid )

    {

    CCFOperationNode* node = DoParseL(

        aParent, aDOMNode, aOperationServices, aUid );

	if ( node )

		{

		return node;

		}

    // Operation not found, check new plugins.

    UpdatePlugInsL();

    node = DoParseL(

        aParent, aDOMNode, aOperationServices, aUid );

    if ( node )

        {

        return node;

        }

    // Generate error info to log.

    return NULL;

    }

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

// CCFOperationPluginManager::ReleasePlugIn

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

//

void CCFOperationPluginManager::ReleasePlugIn( CCFOperationPlugIn*& aPlugIn )

    {

    FUNC_LOG;

    delete aPlugIn;

    aPlugIn = NULL;

    }

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

// CCFOperationPluginManager::DoParseL

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

//

CCFOperationNode* CCFOperationPluginManager::DoParseL( CCFOperationNode* aParent,

    CMDXMLNode& aDOMNode,

    MCFOperationServices& aOperationServices,

    TUid& aUid )

    {

    FUNC_LOG;

    CCFOperationNode* node = NULL;

    for ( TInt i = 0; i < iPlugIns.Count(); i++ )

        {

        CCFOperationPlugIn* plugin = iPlugIns[ i ].iPlugIn;

        node = plugin->ParseL(

            aParent, aDOMNode, aOperationServices );

        if( node )

            {

            // Node found - break

            aUid = iPlugIns[i].iImplUid;

            break;

            }

        }