/*

* 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:  

*

*/

#include <liwcommon.h>

#include <liwservicehandler.h>

#include <s32mem.h>

#include "cpserveractionmanager.h"

#include "cpdebug.h"

#include "cpglobals.h"

using namespace LIW;

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

// C++ destructor

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

//

CCPActionManager::~CCPActionManager()

    {

    if ( iInterface )

        {

        iInterface->Close( );

        }

    delete iServiceHandler;

    }

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

// 

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

//

CCPActionManager* CCPActionManager::NewL()

    {

    CCPActionManager* self = CCPActionManager::NewLC( );

    CleanupStack::Pop( self );

    return self;

    }

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

// 

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

//

CCPActionManager* CCPActionManager::NewLC()

    {

    CCPActionManager* self = new( ELeave ) CCPActionManager;

    CleanupStack::PushL( self );

    self->ConstructL( );

    return self;

    }

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

// C++ constructor.

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

//

CCPActionManager::CCPActionManager()

    {

    }

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

// Standard 2nd phase constructor.

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

//

void CCPActionManager::ConstructL()

    {

    CP_DEBUG( _L8("CCPActionManager::ConstructL()") );

    iServiceHandler = CLiwServiceHandler::NewL( );

    }

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

// CCPActionManager::ExecuteL

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

//  

void CCPActionManager::ExecuteL( const CLiwGenericParamList& aList )

    {

    CP_DEBUG( _L8("CCPActionManager::ExecuteL()") );

    if ( !iInterface )

        {

        PrepareServiceL( iInterface );

        }

    CLiwGenericParamList* inparam = CLiwGenericParamList::NewLC( );

    CLiwGenericParamList* outparam = CLiwGenericParamList::NewLC( );

    PrepareInputListL( aList, *inparam );

    iInterface->ExecuteCmdL( KCmdExecute, *inparam, *outparam ) ;

    TInt pos(0);

    outparam->FindFirst( pos, EGenericParamError );

    if ( pos != KErrNotFound )

        {

        User::LeaveIfError( ( *outparam )[pos].Value().AsTInt32( ) );

        }

    else

        {

        User::Leave( KErrNotFound );

        }

    CleanupStack::PopAndDestroy( outparam );

    CleanupStack::PopAndDestroy( inparam );

    }

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

// CCPActionManager::ExecuteL

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

//  

void CCPActionManager::PrepareServiceL( MLiwInterface*& aInterface )

    {

    CP_DEBUG( _L8("CCPActionManager::PrepareServiceL()") );

    CLiwGenericParamList* inparam = &(iServiceHandler->InParamListL( ) );

    CLiwGenericParamList* outparam = &(iServiceHandler->OutParamListL( ) );

    CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL( 1,

        KActionHandlerInterface, KActionHandlerService );

    CleanupStack::PushL( crit );

    crit->SetServiceClass( TUid::Uid( KLiwClassBase ) );

    RCriteriaArray array;

    CleanupClosePushL( array );

    array.AppendL( crit );

    iServiceHandler->AttachL( array );

    iServiceHandler->ExecuteServiceCmdL( *crit, *inparam, *outparam );

    CleanupStack::PopAndDestroy( &array );

    CleanupStack::PopAndDestroy( crit );

    TInt pos = 0;

    outparam->FindFirst( pos, KActionHandlerInterface );

    if ( pos != KErrNotFound )

        {

        aInterface = ( *outparam )[pos].Value().AsInterface( );

        }

    else

        {

        User::Leave( KErrNotFound );

        }

    }

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

// CCPActionManager::PrepareInputListL

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

//

void CCPActionManager::PrepareInputListL( const CLiwGenericParamList& aList,

    CLiwGenericParamList& aTarget )

    {

    CP_DEBUG( _L8("CCPActionManager::PrepareInputListL()") );

    const TLiwGenericParam* param= NULL;

    TInt pos( 0);

    param = aList.FindFirst( pos, KListMap, EVariantTypeMap );

    if ( param && pos !=KErrNotFound )

        {

        CLiwDefaultMap* map = CLiwDefaultMap::NewLC( );

        param->Value().Get( *map );

        ExtractUidAndMapL( *map, aTarget );

        CleanupStack::PopAndDestroy( map );

        }

    else

        {

        User::Leave( KErrNotFound );

        }

    }

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

// CCPActionManager::ExtractUidAndMapL

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

//

void CCPActionManager::ExtractUidAndMapL( const CLiwDefaultMap& aMap,

    CLiwGenericParamList& aTarget )

    {

    CP_DEBUG( _L8("CCPActionManager::ExtractUidAndMapL()") );

    TLiwVariant variant;

    variant.PushL( );

    if ( aMap.FindL( KActionMap, variant ) )

        {

        CLiwDefaultMap* map = CLiwDefaultMap::NewLC( );

        variant.Get( *map );

        if ( map->FindL( KDataForActionHandler, variant ) )

            {

            TLiwGenericParam param( KDataForActionHandler, variant);

            aTarget.AppendL( param );

            }

        if ( map->FindL( KPluginUid, variant ) )

            {

            TLiwGenericParam param( KPluginUid, variant);

            aTarget.AppendL( param );

            }

        CleanupStack::PopAndDestroy( map );

        }

    CleanupStack::PopAndDestroy( &variant );

    }