/*

* Copyright (c) 2005 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:  Implementation of VoiceUIPluginHandler

*

*/

// INCLUDE FILES

#include <ecom.h>

#include <nssvuipf.hrh>

#include "nssvoiceuipluginhandler.h" 

#include "rubydebug.h"

#include <nssvoicestatus.h>

// CONSTANTS

const TUid KEventPluginUid =  { KVuipfEventInterfaceUid };

const TUid KActionPluginUid = { KVuipfExecutionInterfaceUid };

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

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

// CNssVoiceUIPluginHandler::CNssVoiceUIPluginHandler

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CNssVoiceUIPluginHandler::CNssVoiceUIPluginHandler()

    {

    // nothing

    }

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

// CNssVoiceUIPluginHandler::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CNssVoiceUIPluginHandler::ConstructL()

    {

    LoadPluginsL();

    }

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

// CNssVoiceUIPluginHandler::NewL

// Two-phased constructor.

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

//

EXPORT_C CNssVoiceUIPluginHandler* CNssVoiceUIPluginHandler::NewL()

    {

    RUBY_DEBUG_BLOCK( "CNssVoiceUIPluginHandler::NewL()" );

    CNssVoiceUIPluginHandler* self = new( ELeave ) CNssVoiceUIPluginHandler;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CNssVoiceUIPluginHandler::~CNssVoiceUIPluginHandler

// Destructor.

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

//

EXPORT_C CNssVoiceUIPluginHandler::~CNssVoiceUIPluginHandler()

    {

    UnloadPlugins();

    RUBY_DEBUG0( "CNssVoiceUIPluginHandler::~CNssVoiceUIPluginHandler() end" );

    }

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

// CNssVoiceUIPluginHandler::VoiceEvent

// Handle voice event

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

//

TInt CNssVoiceUIPluginHandler::VoiceEvent( TUid aEventUid ) 

    {

    RUBY_DEBUG1( "CNssVoiceUIPluginHandler::VoiceEvent(0x%x)", aEventUid.iUid );

    CVoiceUiPluginBase* plugin = NULL;

    CVoiceUiPluginBase* previousPlugin = NULL;

    TInt highestPriority( KMinTInt );

    RPointerArray<CVoiceUiPluginBase> usedPlugins;

    // Select the suitable plug-in with highest priority

    // In case of multiple plug-ins with same priority the first one is selected. 

    TInt status( KErrNoneEventNotConsumed );

    // execute plug-ins until the event has been successfully processed

    while ( status != KErrNone )

        {

        // Loop all plugins

        for( TInt i( 0 ); i < iActionPlugins.Count(); i++ ) 

            {

            CVoiceUiPluginBase* tmpPlugin = iActionPlugins[i];

            // Loop all supported events in the plugin

            for ( TInt j( 0 ); j < tmpPlugin->EventUids().Count(); j++ ) 

                {

                RUBY_DEBUG2( "VoiceEvent Comparing event uid [0x%x] against plugin's [0x%x]", 

                             aEventUid.iUid, tmpPlugin->EventUids()[j].iUid );

                TVuipPriority priority = tmpPlugin->Priority();

                if ( tmpPlugin->EventUids()[j] == aEventUid 

                    && priority > highestPriority )

                    {

                    // find the next plug-in in the order of priority

                    TBool alreadyUsed( EFalse );

                    TInt k( 0 );

                    while( k < usedPlugins.Count() && !alreadyUsed )

                        {

                        if ( usedPlugins[k] == tmpPlugin )

                            {

                            alreadyUsed = ETrue;

                            }

                        k++;

                        }

                    if ( !alreadyUsed )

                        {

                        plugin = tmpPlugin;

                        highestPriority = priority; 

                        }

                    }

                }

            }

        if ( plugin && plugin != previousPlugin )

            {

            // execute a plug-in

            status = plugin->Execute( aEventUid );

            previousPlugin = plugin;

            }

        else

            {

            // all plug-ins checked -> exit loop

            RUBY_DEBUG0( "No plugin for the event");

            break;    

            }

        }

    if ( status == KErrNoneForwardEvent )

        {

        status = KErrNoneEventNotConsumed;

        }

    usedPlugins.Reset();

    usedPlugins.Close();

    return status;

    }

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

// CNssVoiceUIPluginHandler::LoadPluginsL

// Loads plug-ins

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

//

void CNssVoiceUIPluginHandler::LoadPluginsL() 

    {

    RUBY_DEBUG_BLOCK( "CNssVoiceUIPluginHandler::LoadPluginsL()" );

    TInt i( 0 );

    RImplInfoPtrArray eventPluginArray;

    CleanupClosePushL( eventPluginArray );

    REComSession::ListImplementationsL( KEventPluginUid, eventPluginArray );

    RUBY_DEBUG1( "CNssVoiceUIPluginHandler::LoadPluginsL() found %i event plugins", 

                 eventPluginArray.Count() );

    // load event plug-ins

    for ( i = 0; i < eventPluginArray.Count(); i++ )

        {

        // Get Uid of plug-in

        TUid id = eventPluginArray[i]->ImplementationUid();

        // create plug-in

        TUid dtorID;

        CVoiceEventObserverPluginBase* tmpPlugin = NULL;

        TRAPD( error, 

            tmpPlugin = 

                reinterpret_cast<CVoiceEventObserverPluginBase*> 

                ( REComSession::CreateImplementationL( id, dtorID ) ) );

        if ( error == KErrNone )

            {           

            // initialize plug-in

            TRAP( error, tmpPlugin->InitializeL( *this ) );

            }

        if ( error == KErrNone )

            {

            error = iEventPlugins.Append( tmpPlugin );   

            }

        if ( error == KErrNone )

            {

            error = iEventPluginDtorIds.Append( dtorID );

            }

        if ( error != KErrNone )

            {

            REComSession::DestroyedImplementation( dtorID );

            delete tmpPlugin;

            tmpPlugin = NULL;

            }

        }

    eventPluginArray.ResetAndDestroy();

    CleanupStack::PopAndDestroy( &eventPluginArray );

    RImplInfoPtrArray actionPluginArray;

    CleanupClosePushL( actionPluginArray );    

    REComSession::ListImplementationsL( KActionPluginUid, actionPluginArray );

    RUBY_DEBUG1( "CNssVoiceUIPluginHandler::LoadPluginsL() found %i VUI plugins", 

                 actionPluginArray.Count() );

    // load action plug-ins

    for ( i = 0; i < actionPluginArray.Count(); i++ )

        {

        // Get Uid of plug-in

        TUid id = actionPluginArray[i]->ImplementationUid();

        // create plug-in

        TUid dtorID;

        CVoiceUiPluginBase* tmpPlugin = NULL;

        TRAPD( error, 

            tmpPlugin = 

                reinterpret_cast<CVoiceUiPluginBase*> 

                ( REComSession::CreateImplementationL( id,dtorID ) ) );

        if ( error == KErrNone )

            {

            // initialize plug-in

            TRAP( error, tmpPlugin->InitializeL() );

            }

        if ( error == KErrNone )

            {

            error = iActionPlugins.Append( tmpPlugin );

            }

        if ( error == KErrNone )

            {    

            error = iActionPluginDtorIds.Append( dtorID );

            }

        if ( error != KErrNone )

            {

            REComSession::DestroyedImplementation( dtorID );

            delete tmpPlugin;

            tmpPlugin = NULL;

            }

        }

    actionPluginArray.ResetAndDestroy();

    CleanupStack::PopAndDestroy( &actionPluginArray );

    }

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

// CNssVoiceUIPluginHandler::UnloadPlugins

// Unloads plug-ins

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

//

void CNssVoiceUIPluginHandler::UnloadPlugins() 

    {

    TInt i( 0 );

    iEventPlugins.ResetAndDestroy();

    iEventPlugins.Close();

    // notify ecom

    for ( i = 0; i < iEventPluginDtorIds.Count(); i++ )

        {

        REComSession::DestroyedImplementation( iEventPluginDtorIds[i] );

        }

    iEventPluginDtorIds.Close();

    iActionPlugins.ResetAndDestroy();

    iActionPlugins.Close();

    // notify ecom

    for ( i = 0; i < iActionPluginDtorIds.Count(); i++ )

        {

        REComSession::DestroyedImplementation( iActionPluginDtorIds[i] );

        }

    iActionPluginDtorIds.Close();

    // Release REComSession allocations.

    REComSession::FinalClose(); 

    }

// ========================== OTHER EXPORTED FUNCTIONS =========================

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

// For DLL goodness.

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

//

#ifndef EKA2

GLDEF_C TInt E32Dll( TDllReason /*aReason*/ )

    {

    return KErrNone;

    }

#endif

// End of File