/*
* Copyright (c) 2007-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:  action presentation model
*
*/


#include <liwcommon.h>
#include "hnsuitemodelcontainer.h"
#include "hnactionmodel.h"
#include "hnmdbasekey.h"
#include "hnmdmodel.h"
#include "hneventhandler.h"
#include "hnhelper.inl"

using namespace LIW;

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

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
EXPORT_C CHnActionModel* CHnActionModel::NewL()
    {
    CHnActionModel* self = new( ELeave ) CHnActionModel();
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }
    
// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
CHnActionModel::~CHnActionModel()
    {
    delete iConstructor;
    delete iCommand;
    
    iService.Close();
    iInterface.Close();
    iCommandName.Close();
    
    }
    
// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//  
void CHnActionModel::ConstructL()
    {
    
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
EXPORT_C CLiwGenericParamList*  CHnActionModel::ConstructorLC()
    {
    CLiwGenericParamList* constructor = CLiwGenericParamList::NewL();
    CleanupStack::PushL( constructor );
    if ( iConstructor )
        {
        iConstructor->ToGenericParamListL( *constructor );
        }
    return constructor;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
EXPORT_C const TDesC8& CHnActionModel::Service() const
    {
    return iService;
    }
        
// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
EXPORT_C CLiwGenericParamList* CHnActionModel::CommandLC() const
    {
    CLiwGenericParamList* command = CLiwGenericParamList::NewL();
    CleanupStack::PushL( command );
    if ( iCommand )
        {
        iCommand->ToGenericParamListL( *command );        
        }
    return command;
    }


        
// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
EXPORT_C const TDesC8& CHnActionModel::Interface() const
    {
    return iInterface;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
EXPORT_C void CHnActionModel::SetConstructorL( CHnMdBaseKey* aData )
    {
    delete iConstructor;
    iConstructor = aData;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
EXPORT_C void CHnActionModel::SetServiceL( const TDesC8& aSrevice )
    {
    iService.Close();
    iService.CreateL( aSrevice );
    }
        
// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
EXPORT_C void CHnActionModel::SetCommand( CHnMdBaseKey* aCommand )
    {
    delete iCommand;
    iCommand = aCommand;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
EXPORT_C void CHnActionModel::SetInterfaceL( const TDesC8& aInterface )
    {
    iInterface.Close();
    iInterface.CreateL( aInterface );
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
EXPORT_C void CHnActionModel::SetCommandNameL( const TDesC8& aCommandName )
    {
    iCommandName.Close();
    iCommandName.CreateL( aCommandName );
    }


// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
EXPORT_C void CHnActionModel::SetServiceModeL( const TServiceMode aMode )
    {
    iMode = aMode;
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
EXPORT_C const TDesC8& CHnActionModel::CommandName() const
{
    return iCommandName;
}

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
EXPORT_C TServiceMode CHnActionModel::ServiceMode() const
{
    return iMode;
}

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
CHnActionModel::CHnActionModel()
    {
    
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
CHnActionModel* CHnActionModel::ConcretizeL( const CHnActionModel & aActionModel,
        CLiwGenericParamList* aGenericParamList )
    {
    CHnActionModel* newInstance = CHnActionModel::NewL();
    CleanupStack::PushL( newInstance );
    
    newInstance->iService.CreateL( aActionModel.Service() );
    newInstance->iInterface.CreateL( aActionModel.Interface() );
    newInstance->iCommandName.CreateL( aActionModel.CommandName() );
    newInstance->iMode = aActionModel.iMode;
    
    if ( aActionModel.iCommand )
        {
        if ( aGenericParamList )
            {
            newInstance->iCommand = aActionModel.iCommand->EvaluateLC( *aGenericParamList );
            }
        else
            {
            newInstance->iCommand = aActionModel.iCommand->CopyLC();
            }
        CleanupStack::Pop( newInstance->iCommand );
        }
    
    if (  aActionModel.iConstructor )
        {
        if ( aGenericParamList )
            {
            newInstance->iConstructor = aActionModel.iConstructor->EvaluateLC( *aGenericParamList );
            }
        else
            {
            newInstance->iConstructor = aActionModel.iConstructor->CopyLC();
            }
        CleanupStack::Pop( newInstance->iConstructor );
        }

    CleanupStack::Pop( newInstance );
    return newInstance;
    }

// ---------------------------------------------------------------------------
// 
// ------------------ ---------------------------------------------------------
//
TInt CHnActionModel::ExecuteL( CHnEventHandler & aEventHandler, 
        CLiwGenericParamList *aExecutionParams )
{
    CHnActionModel* actionModel = ConcretizeL( *this, aExecutionParams );
    CleanupStack::PushL( actionModel );
    TRAPD( err, aEventHandler.ExecuteActionL( actionModel ) );
    // forward KErrNoMemory error to most outer TRAP.
    if ( KErrNoMemory == err || KErrDiskFull == err )
        {
        User::Leave( err );
        }
    CleanupStack::PopAndDestroy( actionModel );
    return err;
}