/*

* 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>

// User includes

#include <aisystemuids.hrh>

#include <aifwpublisherinfo.h>

#include <hscontentpublisher.h>

#include <hspublisherinfo.h>

#include <aicontentobserver.h>

#include <aiuicontroller.h>

#include "caicpscommandbuffer.h"

#include "aiuicontrollermanager.h"

#include "aistatemanager.h"

#include "aipluginfactory.h"

#include "debug.h"

// Constants

const TUid KDeviceStatusPluginUid = 

    { AI_UID_ECOM_IMPLEMENTATION_CONTENTPUBLISHER_DEVSTAPLUGIN };

const TUid KProfilePluginUid =

    { AI_UID_ECOM_IMPLEMENTATION_CONTENTPUBLISHER_PROFILEPLUGIN };

const TUid KSapiPluginImplUid = { 0x20019594 };                

const TUid KWrtPluginImplUid = { 0x200286DD };                          

_LIT( KDeviceStatusPluginName, "DeviceStatus" );

_LIT( KProfilePluginName, "Profile" );

const TInt KQueueStartInterval( 500000 );

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

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

// IsRecyclable()

//

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

//

TBool IsRecyclable( const THsPublisherInfo& aInfo )

    {

    if ( ( aInfo.Name() == KProfilePluginName && 

        aInfo.Uid() == KProfilePluginUid ) ||

        ( aInfo.Name() == KDeviceStatusPluginName &&

        aInfo.Uid() == KDeviceStatusPluginUid ) )

        {

        return ETrue;

        }

    return EFalse;

    }

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

// IsSapiOrWrt()

//

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

//

TBool IsSapiOrWrt( const THsPublisherInfo& aInfo )

    {

    return ( aInfo.Uid() == KSapiPluginImplUid || 

             aInfo.Uid() == KWrtPluginImplUid );             

    }

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

// CleanupResetAndDestroy()

//

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

//

template< class T >

static void CleanupResetAndDestroy( TAny* 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( CAiUiControllerManager& aManager )

    : CTimer( CActive::EPriorityUserInput - 1 ), 

      iUiControllerManager( aManager ), iAllowFlush( ETrue )

    {

    }

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

// CAiPluginFactory::~CAiPluginFactory()

//

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

//

CAiPluginFactory::~CAiPluginFactory()

    {

    Cancel();

    delete iStarter;

    delete iCommandBuffer;

    iLoadQueue.Reset();

    iDestroyQueue.Reset();

    // All publishers should be already deleted from CAiFw::HandleUiShutdown       

    iPublishers.ResetAndDestroy();

    iEComPlugins.ResetAndDestroy();        

    REComSession::FinalClose();

    }

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

// CAiPluginFactory::NewL()

//

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

//

CAiPluginFactory* CAiPluginFactory::NewL( CAiUiControllerManager& aManager )

    {

    return new ( ELeave ) CAiPluginFactory( aManager ); 

    }

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

// CAiPluginFactory::ConstructL()

//

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

//

void CAiPluginFactory::ConstructL()

    {             

    ListImplementationsL();

    iCommandBuffer = CAiCpsCommandBuffer::NewL();

    // Ensure interface is available

    iCommandBuffer->GetCPSInterfaceL();

    CActiveScheduler::Add( this );

    CTimer::ConstructL();

    iStarter = CPeriodic::NewL( CActive::EPriorityIdle );

    }

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

// CAiPluginFactory::ListImplementationsL()

//

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

//

void CAiPluginFactory::ListImplementationsL()

    {

    iEComPlugins.ResetAndDestroy();

    REComSession::ListImplementationsL( 

        KInterfaceUidHsContentPlugin, iEComPlugins );

    }

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

// CAiPluginFactory::LoadPlugin()

//

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

//

void CAiPluginFactory::LoadPlugin( const TAiFwPublisherInfo& aInfo )

    {    

    const THsPublisherInfo& info( aInfo.Info() );

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

        {

        if ( iDestroyQueue[i] == info )

            {

            iDestroyQueue.Remove( i );

            break;

            }

        }

    if ( IsSapiOrWrt( info ) || IsRecyclable( info ) || !PluginByInfo( info ) )

        {

        TBool append( ETrue );

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

            {

            if ( iLoadQueue[i] == info )

                {                

                append = EFalse;

                break;

                }

            }    

        // Plugin is not in load queue and is not currently loaded

        if( append )

            {                               

            iLoadQueue.Append( aInfo );

            HandleQueueChanged();

            }    

        }    

    }

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

// CAiPluginFactory::DestroyPlugin()

//

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

//

void CAiPluginFactory::DestroyPlugin( const TAiFwPublisherInfo& aInfo )

    {

    const THsPublisherInfo& info( aInfo.Info() );

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

        {

        if ( iLoadQueue[i] == info )

            {

            iLoadQueue[i].Callback( KErrCancel );

            iLoadQueue.Remove( i );                       

            break;

            }

        }

    if ( PluginByInfo( info ) )

        {

        TBool append( ETrue );

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

            {

            if ( iDestroyQueue[i] == info )

                {

                append = EFalse;

                break;

                }        

            }

        // Plugin is not in destroy queue and is currently loaded

        if ( append )

            {                       

            iDestroyQueue.Append( aInfo );

            HandleQueueChanged();

            }    

        } 

    }

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

// CAiPluginFactory::HandleQueueChanged()

// 

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

//

void CAiPluginFactory::HandleQueueChanged()

    {

    __PRINTS( "CAiPluginFactory::HandleQueueChanged" );

    if ( iLoadQueue.Count() == 0 && iDestroyQueue.Count() == 0 )

        {

        __PRINTS( "CAiPluginFactory::HandleQueueChanged - done, queues empty" );

        return;

        }

    Cancel();

    iStarter->Cancel();

    __PRINTS( "CAiPluginFactory::HandleQueueChanged, iStarter->Start()" );

    if ( iLoadQueue.Count() == 1 && iDestroyQueue.Count() == 0 &&

        iLoadQueue[0].Reason() == EAiFwPluginStartup )

        {

        ProcessQueue( this );

        }

    else

        {

        iStarter->Start( KQueueStartInterval, 0, 

            TCallBack( ProcessQueue, this ) );        

        }               

    __PRINTS( "CAiPluginFactory::HandleQueueChanged - done" );

    }

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

// CAiPluginFactory::DoCreatePlugin()

//

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

//

TInt CAiPluginFactory::DoCreatePlugin( 

    const TAiFwPublisherInfo& aPublisherInfo )

    {

    __PRINTS( "*** CAiPluginFactory::DoCreatePlugin: Start ***" );

    const THsPublisherInfo& info( aPublisherInfo.Info() );

    if ( IsRecyclable( info ) )

        {

        CHsContentPublisher* plugin( PluginByUid( info.Uid() ) );

        if ( plugin )

            {

            if ( info.Namespace() == KNullDesC8 )

                {

                // No namespace available

                __PRINTS( "*** CAiPluginFactory::CreatePlugin: Done -\

                               Failed to Load Plug-in: KErrNotSupported ***" );

                return KErrNotSupported;

                }

            // Plugin already exists, update its namespace

            THsPublisherInfo& pubinfo( 

                const_cast< THsPublisherInfo& >( plugin->PublisherInfo() ) );

            pubinfo.iNamespace.Copy( info.Namespace() );

            __PRINTS( "*** CAiPluginFactory::CreatePlugin: Done -\

                           Plugin recycled ***" );

            return KErrNone;

            }

        }

    TBool implFound( EFalse );

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

        {

        CImplementationInformation* information( iEComPlugins[i] );

        if( information->ImplementationUid() == info.Uid() )

            {

            implFound = ETrue;

            break;

            }

        }

    if( info.Namespace() == KNullDesC8 || !implFound )

        {

        // No namespace available or no ecom implementation available

        __PRINTS( "*** CAiPluginFactory::CreatePlugin: Done -\

                       Failed to Load Plug-in: KErrNotSupported ***" );

        return KErrNotSupported;

        }

    CHsContentPublisher* plugin( PluginByInfo( info ) );

    if( plugin )

        {

        __PRINTS( "*** CAiPluginFactory::CreatePlugin: Done -\

                       No need to Load Plug-in: KErrAlreadyExists ***" );

        return KErrAlreadyExists;

        }

    TInt err( KErrNone );

    TRAP( err, DoCreatePluginL( aPublisherInfo ) );

    __PRINTS( "*** CAiPluginFactory::CreatePlugin: Done - Load Plug-in ***" );

    return err;

    }

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

// CAiPluginFactory::DoDestroyPlugin()

//

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

//

void CAiPluginFactory::DoDestroyPlugin( 

    const TAiFwPublisherInfo& aPublisherInfo )                             

    {

    __PRINTS( "*** CAiPluginFactory::DoDestroyPlugin: Start ***" );

    const THsPublisherInfo& info( aPublisherInfo.Info() );

    if ( IsRecyclable( info ) )

        {

        // Don't destroy recyclable plugin

        __PRINTS( "*** CAiPluginFactory::DestroyPlugin: Done - Keeping recyclable Plug-in ***" );

        return;

        }

    if ( IsSapiOrWrt( info ) )

        {

        if ( aPublisherInfo.Reason() == EAiFwPageShutdown )

            {

            // Don't destroy sapi or wrt plugin when page is changed        

            __PRINTS( "*** CAiPluginFactory::DestroyPlugin: Done - Keeping SAPI/WRT plugin ***" );

            return;

            }

        }

    CHsContentPublisher* plugin( PluginByInfo( info ) );

    if ( plugin )

        {

        iPublishers.Remove( iPublishers.Find( plugin ) );

        delete plugin;

        plugin = NULL;            

        }

    __PRINTS( "*** CAiPluginFactory::DestroyPlugin: Done ***" );

    }

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

// CAiPluginFactory::DestroyPlugin()

//

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

//

void CAiPluginFactory::DestroyPlugin( const TUid& aUid )

    {

    __PRINTS( "*** CAiPluginFactory::DestroyPlugin: Start ***" );

    CHsContentPublisher* plugin( PluginByUid( aUid ) );

    if ( plugin )

        {                

        iPublishers.Remove( iPublishers.Find( plugin ) );

        __PRINT( __DBG_FORMAT( 

            "CAiPluginFactory::DestroyPlugin: name: %S" ), 

                &plugin->PublisherInfo().Name() ); 

        delete plugin;

        plugin = NULL;                

        }

    __PRINTS( "*** CAiPluginFactory::DestroyPlugin: Done ***" );

    }

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

// CAiPluginFactory::DestroyAllPlugins()

//

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

//

void CAiPluginFactory::DestroyAllPlugins()

    {       

    Cancel();

    iStarter->Cancel();

    iLoadQueue.Reset();

    iDestroyQueue.Reset();

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

        {

        CHsContentPublisher* plugin( iPublishers[i] );

        // Do shutdown state transition

        iStateManager->StopPlugin( *plugin, EAiFwSystemShutdown );        

        }    

    FlushCommandBuffer();

    // Finally get rid of all plugins

    iPublishers.ResetAndDestroy();

    }

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

// CAiPluginFactory::DoCreatePluginL()

//

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

//

void CAiPluginFactory::DoCreatePluginL(

    const TAiFwPublisherInfo& aPublisherInfo )

    {       

    const THsPublisherInfo& info( aPublisherInfo.Info() );

    __PRINT( __DBG_FORMAT( "\t[I]\t Loading plug-in uid=%x name=%S"), 

    info.Uid(), &(info.Name() ) );

    iPublishers.ReserveL( iPublishers.Count() + 1 );

    CHsContentPublisher* plugin( NULL );

    __TIME( "CAiPluginFactory::CreatePluginL Create plug-in:",                                  

    plugin = CHsContentPublisher::NewL( info ) );            

    CleanupStack::PushL( plugin );

    if ( IsSapiOrWrt( info ) )

        {

        plugin->SetProperty( CHsContentPublisher::ECpsCmdBuffer, 

            static_cast< MAiCpsCommandBuffer* >( iCommandBuffer ) );    

        }

    __TIME( "FW: Subscribe content observers",    

    SubscribePluginL( *plugin, info ) );             

    __TIME( "FW: Configure Plugin",

    ConfigurePluginL( *plugin, info ) );

    // Take plugin's ownership

    CleanupStack::Pop( plugin );

    }

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

// CAiPluginFactory::SubscribePluginL()

//

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

//

void CAiPluginFactory::SubscribePluginL(

    CHsContentPublisher& aContentPublisher,        

    const THsPublisherInfo& aPublisherInfo )    

    {

    RPointerArray< CAiUiController >&