/*
* Copyright (c) 2005-2006 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:  Content plugin manager class for Active idle framework.
*
*/

// System includes
#include <ecom/ecom.h>
#include <ecom/implementationinformation.h>
#include <AknGlobalNote.h>
#include <StringLoader.h>
#include <e32property.h>                    // For RProperty

// User includes
#include <aicontentobserver.h>
#include <aiutility.h>
#include <aiplugintool.h>
#include <activeidle2domainpskeys.h>        // PubSub category
#include <activeidle2internalpskeys.h>      // PubSub category key and values

#include "aipluginfactory.h"
#include "aicontentpluginmanager.h"
#include "aipluginlifecycleobserver.h"

#include "aiuicontroller.h"
#include "aifwpanic.h"
#include "debug.h"


// ======== LOCAL FUNCTIONS ========
// ----------------------------------------------------------------------------
// CleanupResetAndDestroy()
// ----------------------------------------------------------------------------
//
template<class T>
static void CleanupResetAndDestroy( TAny* aObj )
    {
    if( aObj )
        {
        static_cast<T*>( aObj )->ResetAndDestroy();
        }
    }

// ----------------------------------------------------------------------------
// CleanupResetAndDestroyPushL()
// ----------------------------------------------------------------------------
//
template<class T>
static void CleanupResetAndDestroyPushL(T& aArray)
    {
    CleanupStack::PushL( TCleanupItem( &CleanupResetAndDestroy<T>, &aArray ) );
    }
    
// ======== MEMBER FUNCTIONS ========    

// ----------------------------------------------------------------------------
// CAiPluginFactory::CAiPluginFactory()
// ----------------------------------------------------------------------------
//
CAiPluginFactory::CAiPluginFactory( 
    RPointerArray<CAiContentPublisher>& aPlugins,
    CAiContentPluginManager& aManager )
      : iPlugins( aPlugins ), iManager( aManager )    
    {
    }

// ----------------------------------------------------------------------------
// CAiPluginFactory::~CAiPluginFactory()
// ----------------------------------------------------------------------------
//
CAiPluginFactory::~CAiPluginFactory()
    {    
    Release( iPluginTool );
           
    iEComPlugins.ResetAndDestroy();
           
    iLifecycleObservers.Reset();
    }
    
// ----------------------------------------------------------------------------
// CAiPluginFactory::NewL()
// ----------------------------------------------------------------------------
//
CAiPluginFactory* CAiPluginFactory::NewL( 
    RPointerArray<CAiContentPublisher>& aPlugins,
    CAiContentPluginManager& aManager )
    {
    CAiPluginFactory* self = 
        new ( ELeave ) CAiPluginFactory( aPlugins, aManager );
                                                                      
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }

// ----------------------------------------------------------------------------
// CAiPluginFactory::ConstructL()
// ----------------------------------------------------------------------------
//
void CAiPluginFactory::ConstructL()
    {        
    iPluginTool = AiUtility::CreatePluginToolL();
    }
        
// ----------------------------------------------------------------------------
// CAiPluginFactory::AddLifecycleObserverL()
// ----------------------------------------------------------------------------
//
void CAiPluginFactory::AddLifecycleObserverL(
    MAiPluginLifecycleObserver& aObserver )
    {
    if( iLifecycleObservers.Find( &aObserver ) == KErrNotFound )
        {
        iLifecycleObservers.AppendL( &aObserver );
        }    
    }

// ----------------------------------------------------------------------------
// CAiPluginFactory::CreatePluginL()
// ----------------------------------------------------------------------------
//
void CAiPluginFactory::CreatePluginL(
    const TAiPublisherInfo& aPublisherInfo,
    RPointerArray<CAiUiController>& aControllerArray )                       
    {           
    iEComPlugins.ResetAndDestroy();
    
    // Discover Plugin implementations.
    __TIME_MARK( ecomOverhead );
    
    REComSession::ListImplementationsL( 
            KInterfaceUidContentPlugin, iEComPlugins );
    
    __TIME_ENDMARK( "FW: ECom Discover plug-ins", ecomOverhead );    
                          
    iPlugins.ReserveL( iPlugins.Count() + 1 );
                       
    TBool implFound( EFalse );
    
    for( TInt i = 0; i < iEComPlugins.Count(); i++ )
        {
        CImplementationInformation* information( iEComPlugins[i] );
                                                                 
        if( information->ImplementationUid().iUid == aPublisherInfo.iUid.iUid )
            {
            implFound = ETrue;
            break;
            }
        }
    
    if( aPublisherInfo.iNamespace == KNullDesC8 || !implFound )
        {
        // No namespace available or no ecom implementation available                               
        User::Leave( KErrNotSupported );
        }
           
    CAiContentPublisher* plugin( PluginByInfoL( aPublisherInfo ) );
    
    if( plugin )
        {                             
        User::Leave( KErrAlreadyExists );
        }
           
    __PRINT( __DBG_FORMAT( "\t[I]\t Loading plug-in uid=%x name=%S"), 
                            aPublisherInfo.iUid, &(aPublisherInfo.iName) );
           
    __TIME( "FW: Create plug-in:",
        plugin = CreatePluginLC( aPublisherInfo );
        ) // __TIME
       
    __TIME( "FW: Subscribe content observers",    
        SubscribeContentObserversL( *plugin, 
            aPublisherInfo, aControllerArray );
        ) // __TIME
                                              
    // Plug-in settings
    __TIME( "FW: Configure Plugin",
        ConfigurePluginL( aControllerArray, *plugin, aPublisherInfo );
        ) // __TIME
                                  
    __PRINTS( "*** FW: Done - Load Plug-in ***" );                          
    
    // This might fail and the plugin ends up destroyed
    for( TInt i = 0; i < iLifecycleObservers.Count(); ++i )
        {
        iLifecycleObservers[i]->PluginCreatedL( *plugin );
        }
                
    for( TInt i = 0; i < iLifecycleObservers.Count(); ++i )
        {
        iLifecycleObservers[i]->AllPluginsCreated();
        }
                   
    // Move plugins to manager
    iPlugins.Append( plugin );
    CleanupStack::Pop( plugin );
    
    iEComPlugins.ResetAndDestroy();       
    }
        
// ----------------------------------------------------------------------------
// CAiPluginFactory::DestroyPluginL()
// ----------------------------------------------------------------------------
//
void CAiPluginFactory::DestroyPluginL(
    const TAiPublisherInfo& aPublisherInfo,
    RPointerArray< CAiUiController >& /*aControllerArray*/ )                       
    {
    // TODO: check is there need to call 
    // iUiControllerManager->RemovePluginFromUI( aPlugin );
    // it will clean the published content.     
    
    if( iPlugins.Count() == 0 )
        {
        return;
        }
               
    CAiContentPublisher* plugin( PluginByInfoL( aPublisherInfo ) );
    
    TInt index( iPlugins.Find( plugin ) );
    
    if( plugin && index != KErrNotFound )
        {               
        for( TInt i = 0; i < iLifecycleObservers.Count(); i++ )
            {                
            iLifecycleObservers[i]->PluginDestroyed( *plugin );
            }
        
        iPlugins.Remove( index );
        
        delete plugin;
        plugin = NULL;
        }
        
    if( iPlugins.Count() == 0 )
        {
        for( TInt i = 0; i < iLifecycleObservers.Count(); i++ )
            {                
            iLifecycleObservers[i]->AllPluginsDestroyed();
            }        
        }
    }

// ----------------------------------------------------------------------------
// CAiPluginFactory::DestroyPlugins()
// ----------------------------------------------------------------------------
//
void CAiPluginFactory::DestroyPlugins()
    {
    for( TInt i = 0; i < iPlugins.Count(); i++ )
        {
        CAiContentPublisher* plugin( iPlugins[i] );
        
        for( TInt i = 0; i < iLifecycleObservers.Count(); i++ )
            {                
            iLifecycleObservers[i]->PluginDestroyed( *plugin );
            }        
        }

    iPlugins.ResetAndDestroy();
    
    for( TInt i = 0; i < iLifecycleObservers.Count(); i++ )
        {                
        iLifecycleObservers[i]->AllPluginsDestroyed();
        }           
    }
        
// ----------------------------------------------------------------------------
// CAiPluginFactory::CreatePluginLC()
// ----------------------------------------------------------------------------
//
CAiContentPublisher* CAiPluginFactory::CreatePluginLC(
    const TAiPublisherInfo& aPluginInfo )
    {
    CAiContentPublisher* plugin = 
            CAiContentPublisher::NewL( aPluginInfo.iUid );
    
    CleanupStack::PushL( plugin );
        
    MAiPropertyExtension* ext( iPluginTool->PropertyExt( *plugin ) );
    
    if( !ext )
        {
        User::Leave( KErrNotFound );
        }
    
    ext->SetPropertyL( EAiPublisherInfo, (TAny*)&aPluginInfo );
    
    const TAiPublisherInfo* info( ext->PublisherInfoL() );
    
    if( info->iNamespace != aPluginInfo.iNamespace )
        {
        // SetPropertyL is not implemented correctly
        User::Leave( KErrNotSupported );
        }
    
    return plugin;
    }

// ----------------------------------------------------------------------------
// CAiPluginFactory::SubscribeContentObserversL()
// ----------------------------------------------------------------------------
//
void CAiPluginFactory::SubscribeContentObserversL(
    CAiContentPublisher& aContentPublisher,        
    const TAiPublisherInfo& aPublisherInfo,
    RPointerArray<CAiUiController>& aControllerArray )
    {       
    
    for( TInt i = 0; i < aControllerArray.Count(); i++ )
        {
        MAiContentObserver& observer( 
            aControllerArray[i]->GetContentObserver() );
        
        if ( observer.RequiresSubscription( aPublisherInfo ) )
            {
			// Subscribe observer only if it understands the plugin
            aContentPublisher.SubscribeL( observer );
            }                   
        }
    }

// ----------------------------------------------------------------------------
// CAiPluginFactory::ConfigurePluginL()
// ----------------------------------------------------------------------------
//
void CAiPluginFactory::ConfigurePluginL( 
    RPointerArray<CAiUiController>& aControllerArray,
    CAiContentPublisher& aContentPublisher,
    const TAiPublisherInfo& aPubInfo )
    {    
    RAiSettingsItemArray pluginSettings;
    CleanupResetAndDestroyPushL( pluginSettings );
    
    for( TInt i = 0; i < aControllerArray.Count(); i++ )
        {
        // Get settings for plug-in        
        aControllerArray[i]->GetSettingsL( aPubInfo, pluginSettings );
        }
    
    // Configure plug-in with its settings
    aContentPublisher.ConfigureL( pluginSettings );
    
    CleanupStack::PopAndDestroy( &pluginSettings );    
    }
        
// ----------------------------------------------------------------------------
// CAiPluginFactory::PluginByInfoL()
// ----------------------------------------------------------------------------
//
CAiContentPublisher* CAiPluginFactory::PluginByInfoL( 
    const TAiPublisherInfo& aInfo ) const
    {       
    for( TInt i = 0; i < iPlugins.Count(); i++ )
        {         
        const TAiPublisherInfo* info( NULL );
                                                  
        info = iPluginTool->PublisherInfoL( *iPlugins[i] );
        
        if( info && ( aInfo == *info ) ) 
            {
            return iPlugins[i];
            }
        }
    
    return NULL;
    }

// ----------------------------------------------------------------------------
// CAiPluginFactory::PluginByNameL()
// ----------------------------------------------------------------------------
//
CAiContentPublisher* CAiPluginFactory::PluginByNameL( 
    const TDesC& aName ) const
    {
    for( TInt i = 0; i < iPlugins.Count(); i++ )
        {
        const TAiPublisherInfo* info( NULL );
        
        TRAP_IGNORE( info = iPluginTool->PublisherInfoL( *iPlugins[i] ) );
                        
        if( info && info->iName == aName )
            {
            return iPlugins[i];            
            }
        }
    
    return NULL;    
    }

// End of file