/*
* Copyright (c) 2010 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:  CPS Execute parameter object
*
*/


// System includes

// User includes
#include <debug.h>
#include <liwvariant.h>
#include <liwgenericparam.h>
#include "aicpsexecuteparam.h"

// Constants
_LIT8( KPublisherId, "publisher" );
_LIT8( KContentType,   "content_type" );
_LIT8( KContentId,   "content_id" );
_LIT8( KPluginId, "plugin_id");
_LIT8( KType,          "type");
_LIT8( KFilter, "filter" );
_LIT8( KActionTrigger, "action_trigger" );

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

// ======== MEMBER FUNCTIONS ========
// ---------------------------------------------------------------------------
// CAiCpsExecuteParam::CAiCpsExecuteParam
//
// ---------------------------------------------------------------------------
//  
CAiCpsExecuteParam::CAiCpsExecuteParam()
    {
    
    }

// ---------------------------------------------------------------------------
// CAiCpsExecuteParam::ConstructL
//
// ---------------------------------------------------------------------------
//
void CAiCpsExecuteParam::ConstructL( ) 
    { 
    }

// ---------------------------------------------------------------------------
// CAiCpsExecuteParam::NewL
//
// ---------------------------------------------------------------------------
//
CAiCpsExecuteParam* CAiCpsExecuteParam::NewL()
    {
    CAiCpsExecuteParam* self = CAiCpsExecuteParam::NewLC();
    CleanupStack::Pop( self );
    return self;
    }

// ---------------------------------------------------------------------------
// CAiCpsExecuteParam::NewLC
//
// ---------------------------------------------------------------------------
//
CAiCpsExecuteParam* CAiCpsExecuteParam::NewLC()
    {
    CAiCpsExecuteParam* self = new ( ELeave ) CAiCpsExecuteParam;
    CleanupStack::PushL( self );
    self->ConstructL();
    return self;
    }
// ---------------------------------------------------------------------------
// CAiCpsExecuteParam::~CAiCpsExecuteParam
//
// ---------------------------------------------------------------------------
//  
CAiCpsExecuteParam::~CAiCpsExecuteParam()
    {
    delete iPluginId;
    delete iRegistryType;
    delete iPublisher;
    delete iContentType;
    delete iContentId;
    iActions.ResetAndDestroy();
    }

// ---------------------------------------------------------------------------
// CAiCpsExecuteParam::PluginId
//
// ---------------------------------------------------------------------------
//
const TDesC& CAiCpsExecuteParam::PluginId() const
    {
    return *iPluginId;
    }

// ---------------------------------------------------------------------------
// CAiCpsExecuteParam::InParamMapLC
//
// ---------------------------------------------------------------------------
//  
CLiwDefaultMap* CAiCpsExecuteParam::InParamMapLC() 
    {
    CLiwDefaultMap* inParamMap = CLiwDefaultMap::NewLC();
    inParamMap->InsertL( KType, TLiwVariant( *iRegistryType ));
    
    CLiwDefaultMap* filter = CLiwDefaultMap::NewLC();
    filter->InsertL( KPublisherId, TLiwVariant(iPublisher ));
    filter->InsertL( KContentId, TLiwVariant(iContentId ));
    filter->InsertL( KContentType, TLiwVariant(iContentType ));
    
    CLiwDefaultList* actionsToLaunch = CLiwDefaultList::NewLC();
    for ( TInt i=0; i< iActions.Count(); i++)
        {
        actionsToLaunch->AppendL( TLiwVariant( *iActions[i]));
        }
    filter->InsertL(KActionTrigger, TLiwVariant(actionsToLaunch) );
    inParamMap->InsertL( KFilter, TLiwVariant( filter ));

    CleanupStack::PopAndDestroy( actionsToLaunch );
    CleanupStack::PopAndDestroy( filter );
    return inParamMap;
    }

// ---------------------------------------------------------------------------
// CAiCpsExecuteParam::SetFilterL
//
// ---------------------------------------------------------------------------
//  
void CAiCpsExecuteParam::SetFilterL(CLiwDefaultMap* aMap)
    {
    delete iPublisher;
    delete iContentType;
    delete iContentId;
    iPublisher = NULL;
    iContentType = NULL;
    iContentId = NULL;
    
    TLiwVariant variant;
    variant.PushL();

    if ( aMap->FindL(KPublisherId, variant ))
        {
        iPublisher = variant.AsDes().AllocL();
        }
    
    variant.Reset();
    if ( aMap->FindL(KContentType, variant ))
        {
        iContentType= variant.AsDes().AllocL();
        }
    
    variant.Reset();
    if ( aMap->FindL(KContentId, variant ))
        {
        iContentId= variant.AsDes().AllocL();
        }
    
    variant.Reset();
    CleanupStack::PopAndDestroy( &variant );
    }

// ---------------------------------------------------------------------------
// CAiCpsExecuteParam::SetRegistryTypeL
//
// ---------------------------------------------------------------------------
//  
void CAiCpsExecuteParam::SetRegistryTypeL(const TDesC& aRegistryType)
    {
    delete iRegistryType;
    iRegistryType = NULL;
    iRegistryType = aRegistryType.AllocL();
    }

// ---------------------------------------------------------------------------
// CAiCpsExecuteParam::SetPluginIdL
//
// ---------------------------------------------------------------------------
// 
void CAiCpsExecuteParam::SetPluginIdL(const TDesC& aPluginId)
    {
    delete iPluginId;
    iPluginId = NULL;
    iPluginId = aPluginId.AllocL();
    }
 
// ---------------------------------------------------------------------------
// CAiCpsExecuteParam::AddActionL
//
// ---------------------------------------------------------------------------
//
void CAiCpsExecuteParam::AddActionL(const TDesC8& aAction)
    {
    iActions.Append(aAction.AllocL());
    }

// End of file