/*

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

*

*/

// System includes

// User includes

#include <aiutility.h>

#include <aiplugintool.h>

#include <aicontentrequest.h>

#include "aipluginfactory.h"

#include "aiconsts.h"

#include "debug.h"

#include "aieventhandler.h"

// Constants

const TInt KAILenOfParenthesis( 2 );

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

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

// CAiEventHandler::NewL()

//

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

//

CAiEventHandler* CAiEventHandler::NewL( 

    CAiPluginFactory& aFactory )

    {

    CAiEventHandler* self = 

        new ( ELeave ) CAiEventHandler( aFactory );         

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CAiEventHandler::ConstructL()

//

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

//

void CAiEventHandler::ConstructL()

    {             

    iPluginTool = AiUtility::CreatePluginToolL();

    }

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

// CAiEventHandler::~CAiEventHandler()

//

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

//

CAiEventHandler::~CAiEventHandler()

    {                     

    Release( iPluginTool );

    }

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

// CAiEventHandler::CAiEventHandler()

//

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

//

CAiEventHandler::CAiEventHandler( CAiPluginFactory& aFactory ) 

    : iFactory( aFactory )

    {

    }

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

// CAiEventHandler::HandlePluginEvent()

//

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

//

void CAiEventHandler::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

    CHsContentPublisher* publisher( NULL );

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

        publisher = iFactory.PluginByName( pluginName );      

    );

    __PRINT( __DBG_FORMAT( 

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

    if( publisher )

        {

        // Resolve plugin specific event id

        TInt eventId( KErrNotFound );

        TRAP_IGNORE( GetIdL( *publisher, 

            CHsContentPublisher::EPublisherEvents, eventName, eventId ) );

        if( eventId != KErrNotFound )

            {

            publisher->HandleEvent( eventId, param );

            }

        else

            {

            publisher->HandleEvent( eventName, param );

            }

        }

    }

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

// CAiEventHandler::HandlePluginEventL()

//

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

//

void CAiEventHandler::HandlePluginEventL( 

    const THsPublisherInfo& aPublisherInfo, const TDesC& aParam )

    {

    // Resolve plugin

    CHsContentPublisher* publisher( 

        iFactory.PluginByInfo( aPublisherInfo ) );

    if( publisher )    

        {

        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( *publisher, 

            CHsContentPublisher::EPublisherEvents, eventName, eventId );

        if( eventId != KErrNotFound )

            {

            publisher->HandleEvent( eventId, param );

            }

        else

            {

            publisher->HandleEvent( eventName, param );

            }

        }

    }

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

// CAiEventHandler::HasMenuItemL()

//

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

//

TBool CAiEventHandler::HasMenuItemL( const THsPublisherInfo& aPublisherInfo,  

    const TDesC& aMenuItem )

    {          

    // Resolve plugin

    CHsContentPublisher* publisher( 

        iFactory.PluginByInfo( aPublisherInfo ) );

    if( publisher )    

        {

        return publisher->HasMenuItem( aMenuItem );            

        }

    return EFalse;

    }

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

// CAiEventHandler::RefreshContent()

//

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

//

TBool CAiEventHandler::RefreshContent( const TDesC& aContentCid )

    {

    TRAPD( error, RefreshContentL( aContentCid ) );

    return ( error == KErrNone );

    }

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

// CAiEventHandler::RefreshContent()

//

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

//

TBool CAiEventHandler::RefreshContent( const THsPublisherInfo& aPublisherInfo, 

    const TDesC& aContentCid )

    {

    // Resolve plugin

    CHsContentPublisher* publisher( 

        iFactory.PluginByInfo( aPublisherInfo ) );

    if( publisher )    

        {

        TInt id( KErrNotFound );

        TRAP_IGNORE( GetIdL( *publisher, 

            CHsContentPublisher::EPublisherContent, aContentCid, id ) ); 

        if ( id != KErrNotFound )

            {

            MAiContentRequest* handler = static_cast< MAiContentRequest* >(

                publisher->GetProperty( CHsContentPublisher::EContentRequest ) );

            if ( handler )

                {

                return handler->RefreshContent( id );

                }            

            }

        }

    return EFalse;

    }

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

// CAiEventHandler::SuspendContent()

//

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

//

TBool CAiEventHandler::SuspendContent( const THsPublisherInfo& aPublisherInfo,  

    const TDesC& aContentCid )

    {

    // Resolve plugin

    CHsContentPublisher* publisher( 

        iFactory.PluginByInfo( aPublisherInfo ) );

    if( publisher )    

        {

        TInt id( KErrNotFound );

        TRAP_IGNORE( GetIdL( *publisher, 

            CHsContentPublisher::EPublisherContent, aContentCid, id ) ); 

        if ( id != KErrNotFound )

            {

            MAiContentRequest* handler = static_cast< MAiContentRequest* >(

                publisher->GetProperty( CHsContentPublisher::EContentRequest ) );

            if ( handler )

                {

                return handler->SuspendContent( id );

                }            

            }

        }

    return EFalse;

    }

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

// CAiEventHandler::GetIdL()

//

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

//

void CAiEventHandler::GetIdL( CHsContentPublisher& aContentPublisher,         

    CHsContentPublisher::TProperty aProperty, const TDesC& aName, TInt& aId )                    

    {

    MAiContentItemIterator* iterator = 

        iPluginTool->ContentItemIterator( aContentPublisher, aProperty );

    if( iterator )

        {

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

        aId = ci.id;

        }

    else

        {

        aId = KErrNotFound;

        }

    }

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

// CAiEventHandler::RefreshContentL()

//

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

//

TInt CAiEventHandler::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 ) );

    CHsContentPublisher* publisher( iFactory.PluginByName( pluginName ) );

    if( !publisher )

        {

        return retval;

        }

    // Extract content id

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

    TInt id( 0 );

    MAiContentRequest* handler( NULL );

    TRAPD( error, GetIdL( *publisher, 

        CHsContentPublisher::EPublisherContent, cid, id ) );

    if ( !error )

        {

        handler = static_cast< MAiContentRequest* >( 

            publisher->GetProperty( CHsContentPublisher::EContentRequest ) );            

        }

    else

        {

        GetIdL( *publisher, 

            CHsContentPublisher::EPublisherResources, cid, id );

        handler = static_cast< MAiContentRequest* >( 

            publisher->GetProperty( CHsContentPublisher::EResourceRequest ) );           

        }

    // Forward event to plugin

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

        {               

        retval = KErrNone;        

        }

    return retval;

    }

// End of File.