#include <aisystemuids.hrh>

#include <hscontentpublisher.h>

#include <hspublisherinfo.h>

#include <aiuicontroller.h>

#include "aiuicontrollermanager.h"

#include "debug.h"

// Constants

const TUid KDeviceStatusPluginUid = 

    { AI_UID_ECOM_IMPLEMENTATION_CONTENTPUBLISHER_DEVSTAPLUGIN };

_LIT( KDeviceStatusPluginName, "DeviceStatus" );

// IsDeviceStatus()

//

TBool IsDeviceStatus( const THsPublisherInfo& aInfo )

    return ( aInfo.Name() == KDeviceStatusPluginName && 

        aInfo.Uid() == KDeviceStatusPluginUid );

    }

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

// CleanupResetAndDestroy()

//

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

//

template< class T >

static void CleanupResetAndDestroy( TAny* aObj )

    {        

    static_cast< T* >( aObj )->ResetAndDestroy();    

//

template< class T >

static void CleanupResetAndDestroyPushL( T& aArray )

    CleanupStack::PushL( 

        TCleanupItem( &CleanupResetAndDestroy< T >, &aArray ) );

//

CAiPluginFactory::CAiPluginFactory( CAiUiControllerManager& aManager )

    : iUiControllerManager( aManager )

//

    {

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

    iPublishers.ResetAndDestroy();

    iEComPlugins.ResetAndDestroy();        

    REComSession::FinalClose();

//

CAiPluginFactory* CAiPluginFactory::NewL( CAiUiControllerManager& aManager )

        new ( ELeave ) CAiPluginFactory( aManager );

//

    {               

    REComSession::ListImplementationsL( 

        KInterfaceUidHsContentPlugin, iEComPlugins );    

// CAiPluginFactory::CreatePluginL()

TInt CAiPluginFactory::CreatePlugin( 

    const THsPublisherInfo& aPublisherInfo )                             

    {                                            

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

    if ( IsDeviceStatus( aPublisherInfo ) )

        {

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

        if ( plugin )

            {

            // Devicestatus plugin already exists, update its namespace

            THsPublisherInfo& info( 

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

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

            __PRINTS( "*** CAiPluginFactory::CreatePlugin: Done - DeviceStatus plugin updated ***" );

            return KErrNone;

            }

        }

        if( information->ImplementationUid().iUid == aPublisherInfo.Uid().iUid )

    if( aPublisherInfo.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( aPublisherInfo ) );

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

        return KErrAlreadyExists;

    TInt err( KErrNone );

    TRAP( err, CreatePluginL( aPublisherInfo ) );

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

    return err;    

// CAiPluginFactory::DestroyPlugin()

//

void CAiPluginFactory::DestroyPlugin( const THsPublisherInfo& aPublisherInfo )                             

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

    if ( IsDeviceStatus( aPublisherInfo ) )

        // Don't destroy device status plugin

        __PRINTS( "*** CAiPluginFactory::DestroyPlugin: Done - Keepind DeviceStatus Plug-in ***" );

    CHsContentPublisher* plugin( PluginByInfo( aPublisherInfo ) );

    if ( plugin )

        {

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

        plugin = NULL;            

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

// CAiPluginFactory::CreatePluginL()

//

void CAiPluginFactory::CreatePluginL(

    const THsPublisherInfo& aPublisherInfo )

    {       

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

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

    __TIME( "FW: Create plug-in:",

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

    CHsContentPublisher* plugin = 

        CHsContentPublisher::NewL( aPublisherInfo ) );            

    __TIME( "FW: Subscribe content observers",    

    SubscribeContentObserversL( *plugin, aPublisherInfo ) );             

    __TIME( "FW: Configure Plugin",

    ConfigurePluginL( *plugin, aPublisherInfo ) );

    // Take plugin's ownership

    iPublishers.Append( plugin );

    CleanupStack::Pop( plugin );

//

    CHsContentPublisher& aContentPublisher,        

    const THsPublisherInfo& aPublisherInfo )    

    {

    RPointerArray< CAiUiController >& 

        controllers( iUiControllerManager.UiControllers() );

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

            controllers[i]->GetContentObserver() );

//

void CAiPluginFactory::ConfigurePluginL(     

    CHsContentPublisher& aContentPublisher,

    const THsPublisherInfo& aPublisherInfo )

    RAiSettingsItemArray settings;

    CleanupResetAndDestroyPushL( settings );

    RPointerArray< CAiUiController >& 

        controllers( iUiControllerManager.UiControllers() );

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

        controllers[i]->GetSettingsL( aPublisherInfo, settings );

    aContentPublisher.ConfigureL( settings );

    CleanupStack::PopAndDestroy( &settings );    

// CAiPluginFactory::PluginByInfo()

// Gets plugin by publisher info. Only this overload returns the exact match

CHsContentPublisher* CAiPluginFactory::PluginByInfo( 

    const THsPublisherInfo& aPublisherInfo ) const

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

        const THsPublisherInfo& info( iPublishers[i]->PublisherInfo() ); 

        if( aPublisherInfo == info ) 

            return iPublishers[i];

// CAiPluginFactory::PluginByUid()

// Gets plugin by UID

CHsContentPublisher* CAiPluginFactory::PluginByUid( const TUid& aUid ) const

    {

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

        {

        const THsPublisherInfo& info( iPublishers[i]->PublisherInfo() );

        if( info.Uid() == aUid )

            {

            return iPublishers[i];            

            }

        }

    return NULL;        

    }

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

// CAiPluginFactory::PluginByName()

// Gets plugin by name

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

//

CHsContentPublisher* CAiPluginFactory::PluginByName( 

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

        const THsPublisherInfo& info( iPublishers[i]->PublisherInfo() );

        if( info.Name() == aName )

            return iPublishers[i];            

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

// CAiPluginFactory::Publishers()

//

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

//

RPointerArray< CHsContentPublisher >& CAiPluginFactory::Publishers() const

    {

    return iPublishers;

    }

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

// CAiPluginFactory::ResolvePluginsToUpgradeL()

//

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

//

void CAiPluginFactory::ResolvePluginsToUpgradeL( 

    RArray< THsPublisherInfo >& aArray )

    {

    RImplInfoPtrArray ecomPlugins;

    CleanupResetAndDestroyPushL( ecomPlugins );

    REComSession::ListImplementationsL( 

        KInterfaceUidHsContentPlugin, ecomPlugins );

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

        {

        CImplementationInformation* newInformation( ecomPlugins[i] );

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

            {            

            CImplementationInformation* oldInformation( iEComPlugins[j] );

            if( newInformation->ImplementationUid() == oldInformation->ImplementationUid() )

                {

                if( newInformation->Version() != oldInformation->Version() )

                    {                        

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

                        {

                        const THsPublisherInfo& info( 

                            iPublishers[k]->PublisherInfo() );

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

                            {                            

                            __PRINT( __DBG_FORMAT( "\t[I]\t Plug-in to update uid=%x name=%S namespace=%S, version update %d to %d"), 

                                info.Uid(), &(info.Name()), &(info.Namespace()), oldInformation->Version(), newInformation->Version()  );

                            aArray.Append( info );

                            }

                        }

                    break;

                    }

                }                

            }

        }

    CleanupStack::PopAndDestroy( &ecomPlugins );

    // Update ecom plugin array

    iEComPlugins.ResetAndDestroy();

    REComSession::ListImplementationsL( 

        KInterfaceUidHsContentPlugin, iEComPlugins );

    }