/*

* 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 error manager class

*

*/

#include <ecom/ecom.h>

#include <ecom/implementationinformation.h>

#include <aiutility.h>

#include <aiplugintool.h>

#include <centralrepository.h>

#include <activeidle2domaincrkeys.h>

#include "aicontentpluginmanager.h"

#include "aipluginstatemanager.h"

#include "aifweventhandler.h"

#include "aicontentpublisher.h"

#include "aipropertyextension.h"

#include <aicontentrequest.h>

#include "aieventhandlerextension.h"

#include "aiuicontroller.h"

#include "aiconsts.h"

#include "debug.h"

// CONSTANTS

const TInt KAILenOfParenthesis( 2 );

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

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

// CAiContentPluginManager::NewL()

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

//

CAiContentPluginManager* CAiContentPluginManager::NewL()

    {

    CAiContentPluginManager* self = new ( ELeave ) CAiContentPluginManager();         

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CAiContentPluginManager::ConstructL()

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

//

void CAiContentPluginManager::ConstructL()

    {

    iPluginFactory = CAiPluginFactory::NewL( iPlugins, *this );

    iStateManager = CAiPluginStateManager::NewL();

    iPluginFactory->AddLifecycleObserverL( *iStateManager );

    iPluginTool = AiUtility::CreatePluginToolL();

    }

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

// CAiContentPluginManager::~CAiContentPluginManager()

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

//

CAiContentPluginManager::~CAiContentPluginManager()

    {               

    iPlugins.ResetAndDestroy();

    delete iPluginFactory;

    delete iStateManager;

    Release( iPluginTool );

    }

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

// CAiContentPluginManager::CAiContentPluginManager()

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

//

CAiContentPluginManager::CAiContentPluginManager() 

    {

    }

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

// CAiContentPluginManager::HandlePluginEvent()

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

//

void CAiContentPluginManager::HandlePluginEvent( const TDesC& aParam )    

    {

    const TInt separatorPos( aParam.Locate( KPluginEventSeparator ) );

    if( separatorPos == KErrNotFound )

        {

        return;

        }

    // Extract plugin name

    TPtrC pluginName( aParam.Left( separatorPos ) );

    // Extract event and parameter string

    TPtrC eventNameAndParams( aParam.Mid( separatorPos + 1 ) );

    // Find parameter string position

    const TInt paramsPos( 

            eventNameAndParams.Locate( KEventParameterSeparator  ) );

    // Extract event name

    TPtrC eventName( paramsPos < 0 ? eventNameAndParams : 

                                     eventNameAndParams.Left( paramsPos ) );

    // Calculate actual parameter string length by ignoring parenthesis 

    TInt paramsLength( 

            eventNameAndParams.Length() - paramsPos - KAILenOfParenthesis );

    // Extract paramenters

    TPtrC param( paramsPos < 0 ? KNullDesC()  :             

            eventNameAndParams.Mid( paramsPos + 1, Max( 0, paramsLength ) ) );

    // Resolve plugin

    CAiContentPublisher* target = NULL;

    __TIME( "FW: Lookup plug-in by name",

        TRAP_IGNORE( target = iPluginFactory->PluginByNameL( pluginName ) );  

    );

    __PRINT( __DBG_FORMAT( 

            "\t[I]\t Event: %S to plug-in by addr 0x%x" ), &aParam, target );

    if( target )

        {

        // Resolve plugin specific event id

        TInt eventId( KErrNotFound );

        TRAP_IGNORE( GetIdL( *target, EAiPublisherEvents, eventName, eventId ) );

        // Forward event to plugin

        MAiEventHandlerExtension* ext( 

                iPluginTool->EventHandlerExt( *target ) );

        if( ext )

            {

            if( eventId != KErrNotFound )

                {

                ext->HandleEvent( eventId, param );

                }

            else

                {

                ext->HandleEvent( eventName, param );

                }

            }

        }

    }

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

// CAiContentPluginManager::HandlePluginEventL()

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

//

void CAiContentPluginManager::HandlePluginEventL( 

    const TAiPublisherInfo& aPublisherInfo, const TDesC& aParam )

    {

    // Resolve plugin

    CAiContentPublisher* target( 

            iPluginFactory->PluginByInfoL( aPublisherInfo ) );

    if( target )    

        {

        const TInt separatorPos( aParam.Locate( KPluginEventSeparator ) );

        // Extract event and parameter string

        TPtrC eventNameAndParams( aParam.Mid( separatorPos + 1 ) );

        // Find parameter string position

        const TInt paramsPos( 

                eventNameAndParams.Locate( KEventParameterSeparator  ) );

        // Extract event name

        TPtrC eventName( paramsPos < 0 ? 

            eventNameAndParams : eventNameAndParams.Left( paramsPos ) );

        // Calculate actual parameter string length by ignoring parenthesis 

        TInt paramsLength( 

                eventNameAndParams.Length() - paramsPos - KAILenOfParenthesis );

        // Extract paramenters

        TPtrC param( paramsPos < 0 ? KNullDesC() :

            eventNameAndParams.Mid( paramsPos + 1, Max( 0, paramsLength ) ) );

        // Resolve plugin specific event id

        TInt eventId( KErrNotFound );

        GetIdL( *target, EAiPublisherEvents, eventName, eventId );

        // Forward event to plugin

        MAiEventHandlerExtension* ext( 

                iPluginTool->EventHandlerExt( *target ) );

        if( ext )

            {

            if( eventId != KErrNotFound )

                {

                ext->HandleEvent( eventId, param );

                }

            else

                {

                ext->HandleEvent( eventName, param );

                }

            }        

        }

    }

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

// CAiContentPluginManager::HasMenuItemL()

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

//

TBool CAiContentPluginManager::HasMenuItemL( 

    const TAiPublisherInfo& aPublisherInfo, const TDesC& aMenuItem )

    {          

    // Resolve plugin

    CAiContentPublisher* target( 

            iPluginFactory->PluginByInfoL( aPublisherInfo ) );

    if( target )    

        {

        // Forward query to plugin

        MAiEventHandlerExtension* ext( 

                iPluginTool->EventHandlerExt( *target ) );                 

        if ( ext )

            {

            return ext->HasMenuItem( aMenuItem );

            }

        }

    return EFalse;

    }

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

// CAiContentPluginManager::RefreshContentL()

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

//

TBool CAiContentPluginManager::RefreshContent( const TDesC& aContentCid )

    {

    TRAPD( error, RefreshContentL( aContentCid ) );

    return ( error == KErrNone );

    }

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

// CAiFw::ProcessOnlineState()

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

//

void CAiContentPluginManager::ProcessOnlineState( TBool aOnline )    

    {  

    _LIT( KOnlineOffline, "online_offline" );

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

        {               

        MAiEventHandlerExtension* ext( 

                iPluginTool->EventHandlerExt( *iPlugins[i] ) );

        // If plugin understands online/offline run state change

        if( ext && ext->HasMenuItem( KOnlineOffline ) )

            {            

            if( aOnline )

                {

                iStateManager->ProcessOnlineState( *iPlugins[i] );

                }

            else

                {

                iStateManager->ProcessOfflineState( *iPlugins[i] );                     

                }                                                           

            }

        }       

    }

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

// CAiContentPluginManager::StateManager()

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

//

CAiPluginStateManager& CAiContentPluginManager::StateManager() const

    {

    return *iStateManager;

    }

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

// CAiContentPluginManager::PluginFactory()

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

//

CAiPluginFactory& CAiContentPluginManager::PluginFactory() const

    {

    return *iPluginFactory;

    }

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

// CAiContentPluginManager::GetIdL()

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

//

void CAiContentPluginManager::GetIdL( CAiContentPublisher& aContentPublisher,         

    TAiPublisherProperty aProperty, const TDesC& aName, TInt& aId )                 

    {

    MAiContentItemIterator* iterator = 

        iPluginTool->ContentItemIteratorL( aContentPublisher, aProperty );

    if( iterator )

        {

        const TAiContentItem& ci( iterator->ItemL( aName ) );

        aId = ci.id;

        }

    else

        {

        aId = KErrNotFound;

        }

    }

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

// CAiContentPluginManager::RefreshContentL()

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

//

TInt CAiContentPluginManager::RefreshContentL( const TDesC& aContentCid )

    {

    TInt retval( KErrNotFound );

    // Look up plug-in and content item and delegate to plug-in's

    // MAiContentRequest implementation.

    // Find plugin name

    TInt pos( aContentCid.Locate( KPluginEventSeparator ) );

    if( pos == KErrNotFound )

        {

        return retval;        

        }

    TPtrC pluginName( aContentCid.Left( pos ) );

    CAiContentPublisher* plugin( iPluginFactory->PluginByNameL( pluginName ) );

    if( !plugin )

        {

        return retval;

        }

    MAiPropertyExtension* ext( iPluginTool->PropertyExt( *plugin ) );

    if( !ext )

        {

        return retval;

        }

    // Extract content id

    TPtrC cid( aContentCid.Mid( ++pos ) );

    TInt id( 0 );

    MAiContentRequest* handler( NULL );

    TRAPD( error, GetIdL( *plugin, EAiPublisherContent, cid, id ) );

    if ( !error )

        {

        handler = static_cast< MAiContentRequest* >( 

                    ext->GetPropertyL( EAiContentRequest ) );            

        }

    else

        {

        GetIdL( *plugin, EAiPublisherResources, cid, id );

        handler = static_cast< MAiContentRequest* >( 

                    ext->GetPropertyL( EAiResourceRequest ) );           

        }

    // Forward event to plugin

    if( handler && handler->RefreshContent( id ) )

        {               

        retval = KErrNone;        

        }

    return retval;

    }

// End of File.