/*

 * Copyright (c) 2008 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:  ?Description

 *

 */

#include "cahandlerengine.h"

#include "cahandler.h"

#include "cahandlerplugin.h"

#include "cahandlerplugin.hrh"

#include "cadef.h"

#include "cainnerentry.h"

// ======== LOCAL FUNCTIONS ========

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

// Cleanupstack support method, calls RImplInfoPtrArray::ResetAndDestroy()

// of the passed argument (array).

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

//

LOCAL_C void ResetAndDestroyArray( TAny* aArray )

    {

    ( (RImplInfoPtrArray* ) aArray )->ResetAndDestroy();

    }

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

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

//

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

//

EXPORT_C CCaHandlerEngine::~CCaHandlerEngine()

    {

    iHandlers.ResetAndDestroy();

    }

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

//

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

//

EXPORT_C CCaHandlerEngine* CCaHandlerEngine::NewL()

    {

    CCaHandlerEngine* self = NewLC();

    CleanupStack::Pop( self );

    return self;

    }

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

//

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

//

EXPORT_C CCaHandlerEngine* CCaHandlerEngine::NewLC()

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

//

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

//

void CCaHandlerEngine::ConstructL()

    {

    }

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

//

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

//

CCaHandlerEngine::CCaHandlerEngine()

    {

    }

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

//

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

//

EXPORT_C void CCaHandlerEngine::HandleCommandL( CCaInnerEntry& aEntry,

        const TDesC8& aCommand )

    {

    // Currently, we load handlers on demand and never unload them.

    // As there aren't many types of items, this seems appropriate.

    CCaHandler* handler = FindHandler( aEntry.GetEntryTypeName() );

    if( !handler )

        {

        //TODO: need to change this

        if( aEntry.GetEntryTypeName() == KCaTypeApp()

                || aEntry.GetEntryTypeName() == KCaTypeWidget() )

            {

            handler = LoadHandlerL( KCaTypeApp() );

            }

        else

            {

            handler = LoadHandlerL( aEntry.GetEntryTypeName() );

            }

        }

    if( handler )

        {

        handler->HandleCommandL( aEntry, aCommand );

        }

    else

        {

        User::Leave( KErrNotFound );

        }

    }

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

//

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

//

CCaHandler* CCaHandlerEngine::FindHandler( const TDesC& aType )

    {

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

        {

        CCaHandler* handler = iHandlers[i];

        if( handler->SupportsType( aType ) )

            {

            return handler;

            }

        }

    return NULL;

    }

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

//

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

//

CCaHandler* CCaHandlerEngine::LoadHandlerL( const TDesC& aType )

    {

    CCaHandlerPlugin* handler = NULL;

    TBuf8<KCaMaxTypeLen> type;

    type.Copy( aType );

    TEComResolverParams resolverParams;

    resolverParams.SetDataType( type );

    RImplInfoPtrArray implInfoArray;

    CleanupStack::PushL(

            TCleanupItem( ResetAndDestroyArray, &implInfoArray ) );

    REComSession::ListImplementationsL( TUid::Uid( HANDLER_IF_UID ),

            resolverParams, implInfoArray );

    __ASSERT_DEBUG( implInfoArray.Count() <= 1, User::Invariant() );

    if( implInfoArray.Count() != 0 )

        {

        TUid implUid = implInfoArray[0]->ImplementationUid();

        handler = CCaHandlerPlugin::NewL( implUid );

        CleanupStack::PushL( handler );

        // Here we check if this is the handler we need. Currently we only do

        // a sanity check for the handler (it should support the registered

        // types!), but later this can be extended with better support query.

        // E.g. support for type AND command, etc.

        if( handler->SupportsType( aType ) )

            {

            iHandlers.AppendL( handler );

            CleanupStack::Pop( handler );

            }

        else

            {

            CleanupStack::PopAndDestroy( handler );

            handler = NULL;

            }

        }

    CleanupStack::PopAndDestroy( &implInfoArray );

    return handler;

    }