/*

* 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:  Handles Mediator pluging resolving and loading to new thread.

*

*/

// INCLUDE FILES

#include    <e32base.h>

#include    "MediatorServerPluginHandler.h"

#include    "MediatorPluginBase.h"

#include    "MediatorUids.hrh"

#include    "MediatorDebug.h"

#include    "Debug.h"

// CONSTANTS

_LIT( KMediatorThreadName, "MediatorThread - " );

const TInt KMediatorHeapSize = 0x80000;

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

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

// CMediatorServerPluginHandler::CMediatorServerPluginHandler

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

//

CMediatorServerPluginHandler::CMediatorServerPluginHandler()

    {

    }

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

// CMediatorServerPluginHandler::ConstructL

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

//

void CMediatorServerPluginHandler::ConstructL()

    {

    iIdle = CIdle::NewL( CActive::EPriorityIdle );

   	iIdle->Start( TCallBack( LoadPlugins, this ) ); 

    }

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

// CMediatorServerPluginHandler::NewL

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

//

CMediatorServerPluginHandler* CMediatorServerPluginHandler::NewL()

    {

    CMediatorServerPluginHandler* self = new( ELeave ) CMediatorServerPluginHandler;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CMediatorServerPluginHandler::~CMediatorServerPluginHandler

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

//    

CMediatorServerPluginHandler::~CMediatorServerPluginHandler()

    {

    iPluginImplInfoArray.ResetAndDestroy();

    delete iIdle;

    }

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

// CMediatorEventConsumer::LoadPlugins

//  

// (other items were commented in a header).

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

//

TInt CMediatorServerPluginHandler::LoadPlugins( TAny* aPtr )

    {

    CMediatorServerPluginHandler* me = (CMediatorServerPluginHandler*) aPtr;

    TRAPD( error, me->LoadPluginsL() );

    if ( error != KErrNone )

        {

        ERROR_TRACE(Print(_L("CMediatorServerPluginHandler::LoadPlugins: error=%d\n"), error ) );    

        }

    return error;

    }

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

// CMediatorEventConsumer::LoadPluginsL

//  

// (other items were commented in a header).

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

//

void CMediatorServerPluginHandler::LoadPluginsL()

    {

    FindImplementationsL();

    for ( TInt index = 0; index < iPluginImplInfoArray.Count(); index ++ )

        {

        RMediatorDebug::LogPlugin(iPluginImplInfoArray[index]);

        StartThreadL( iPluginImplInfoArray[index]->ImplementationUid() );

        } 

    }

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

// CMediatorServerPluginHandler::FindImplementationsL

//  

// (other items were commented in a header).

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

//

void CMediatorServerPluginHandler::FindImplementationsL()

    {

    LOG(_L("[Mediator Server]\t CMediatorServerPluginHandler::FindImplementationsL"));

     // Mediator interface uid as argument

    TUid pluginInterfaceUid;

    pluginInterfaceUid.iUid = KMediatorPluginInterfaceUid;

    TEComResolverParams emptyParams;

    // List the plugins to array. Note ROM-only plugins are accepted!

    REComSession::ListImplementationsL( pluginInterfaceUid,

                                        emptyParams,

                                        KRomOnlyResolverUid,

                                        iPluginImplInfoArray );

    }

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

// CMediatorServerPluginHandler::ThreadEntryPoint

//  

// (other items were commented in a header).

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

//

TInt CMediatorServerPluginHandler::ThreadEntryPoint( TAny* aParameter )

    {

    TRACE(Print( _L("[Mediator Server]\t CMediatorServerPluginHandler::ThreadEntryPoint(0x%x)" ), &aParameter ) );

    TInt err = KErrNone;

    //create cleanupstack

    CTrapCleanup* cleanup = CTrapCleanup::New(); // get clean-up stack

    if ( !cleanup )

        {

        ERROR_LOG(_L("CMediatorServerPluginHandler::ThreadEntryPoint: KErrNoMemory\n"));

        err = KErrNoMemory;

        }

    if ( !err )

        {

        // Read the parameters from started

        TMediatorThreadParam* parameters = ( TMediatorThreadParam* ) aParameter;     

        TUid pluginUid = parameters->iMediatorPluginUid;

        // Just trap the leave in construction phase

        TRAP( err, DoStartThreadL( pluginUid ) );

        if ( err != KErrNone )

            {

            ERROR_TRACE(Print(_L("CMediatorServerPluginHandler::ThreadEntryPoint: pluginUid=0x%x, err=%d\n"), pluginUid.iUid, err ) );    

            }

        }

    delete cleanup;

    return KErrNone;

    }

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

// CMediatorServerPluginHandler::StartThreadL

//  

// (other items were commented in a header).

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

//

void CMediatorServerPluginHandler::StartThreadL( TUid aMediatorPluginUid )

    {

    TRACE(Print( _L("[Mediator Server]\t CMediatorServerPluginHandler::StartThreadL(0x%x)" ), aMediatorPluginUid ) );

    // Then create start parameters

    TMediatorThreadParam param;

    param.iMediatorPluginUid = aMediatorPluginUid;

    // Generate unique thread name

    HBufC* bufThreadName = HBufC::NewLC( KMediatorThreadName().Length() + KMaxUidName );

    TPtr ptrThreadName = bufThreadName->Des();

    ptrThreadName = KMediatorThreadName;

    ptrThreadName.Append( aMediatorPluginUid.Name() );

    TRACE(Print( _L("[Mediator Server]\t CMediatorServerPluginHandler::StartThreadL(%S)" ), &ptrThreadName ) );

    RThread newThread;

    User::LeaveIfError( newThread.Create(

                        ptrThreadName,

                        CMediatorServerPluginHandler::ThreadEntryPoint,

                        KDefaultStackSize,

                        KMinHeapSize,

                        KMediatorHeapSize,

                        &param ) );

    CleanupStack::PopAndDestroy( bufThreadName );

    // Rendezvous

    TRequestStatus status = KRequestPending;

    newThread.Rendezvous( status );

    newThread.Resume();

    User::WaitForRequest( status );

    TRACE(Print( _L("[Mediator Server]\t Thread resumed with status %d" ), status.Int() ) );

    newThread.Close();

    }

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

// CMediatorServerPluginHandler::DoStartThreadL

//  

// (other items were commented in a header).

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

//

void CMediatorServerPluginHandler::DoStartThreadL( TUid aMediatorPluginUid )

    {

    TRACE(Print( _L("[Mediator Server]\t CMediatorServerPluginHandler::DoStartThreadL(0x%x)" ), aMediatorPluginUid ) );

    CActiveScheduler* scheduler = new (ELeave) CActiveScheduler;

    CleanupStack::PushL( scheduler );

    CActiveScheduler::Install( scheduler );

    CMediatorPluginBase* newPlugin = CMediatorPluginBase::NewL( aMediatorPluginUid );

    CleanupStack::PushL( newPlugin );

    RThread::Rendezvous( KErrNone );

    CActiveScheduler::Start();

    CleanupStack::PopAndDestroy( newPlugin );

    CleanupStack::PopAndDestroy( scheduler );

    }

//  End of File