/** @file
 * Copyright (c) 2005-2006 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:  CUpnpAction
 *
 */

// INCLUDE FILES
#include "upnpaction.h"
#include "upnpargument.h"
#include "upnpstring.h"
#include "upnpsoapmessage.h"
#include "upnpservice.h"
#define KLogFile _L("UPnPStack.txt")
#include "upnpcustomlog.h"

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

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

// -----------------------------------------------------------------------------
// CUpnpAction::CUpnpAction
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//

CUpnpAction::CUpnpAction( CUpnpService& aParentService ) :
    iParentService( aParentService )
    {
    iError = KErrNone;
    }

// -----------------------------------------------------------------------------
// CUpnpAction::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CUpnpAction::ConstructL( CUpnpAction& aAction )
    {
    RPointerArray<CUpnpArgument>& argumentList = aAction.ArgumentList();

    for ( TInt index = 0; index < argumentList.Count(); index++ )
        {
        CUpnpArgument* arg = CUpnpArgument::NewL( *argumentList[index],
            iParentService );
        CleanupStack::PushL( arg );
        iArguments.AppendL( arg );
        CleanupStack::Pop( arg );
        }

    iName = aAction.Name().AllocL();
    iDestinationPath = HBufC8::NewL( 0 );

    iSessionId = CUpnpHttpMessage::NewSessionIdL();
    }

// -----------------------------------------------------------------------------
// CUpnpAction::NewLC
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
EXPORT_C CUpnpAction* CUpnpAction::NewLC( CUpnpAction& aAction,
    CUpnpService& aParentService )
    {
    CUpnpAction* self = new (ELeave) CUpnpAction( aParentService );

    CleanupStack::PushL( self );
    self->ConstructL( aAction );

    return self;
    }

// -----------------------------------------------------------------------------
// CUpnpAction::~CUpnpAction
// Destructor
// -----------------------------------------------------------------------------
//
EXPORT_C CUpnpAction::~CUpnpAction()
    {
    iArguments.ResetAndDestroy();
    iArguments.Close();

    delete iName;
    delete iDestinationPath;
    }

// -----------------------------------------------------------------------------
// CUpnpAction::SetArgumentL
//
// -----------------------------------------------------------------------------
//
EXPORT_C TInt CUpnpAction::SetArgumentL( const TDesC8& aName,
    const TDesC8& aValue )
    {
    for ( TInt i = 0; i < iArguments.Count(); i++ )
        {
        CUpnpArgument* arg = iArguments[i];

        if ( aName.Compare( arg->Name() ) == 0 )
            {
            arg->SetValueL( aValue );
            return KErrNone;
            }
        }
    return KErrBadName;
    }

// -----------------------------------------------------------------------------
// CUpnpAction::ArgumentValue
//
// -----------------------------------------------------------------------------
//
EXPORT_C const TDesC8& CUpnpAction::ArgumentValue( const TDesC8& aName )
    {
    for ( TInt i = 0; i < iArguments.Count(); i++ )
        {
        CUpnpArgument* arg = iArguments[i];

        if ( aName.Compare( arg->Name() ) == 0 )
            {
            return arg->Value();
            }
        }
    return KNullDesC8();
    }

// -----------------------------------------------------------------------------
// CUpnpAction::Argument
//
// -----------------------------------------------------------------------------
//
EXPORT_C CUpnpArgument* CUpnpAction::Argument( const TDesC8& aName )
    {
    for ( TInt i = 0; i < iArguments.Count(); i++ )
        {
        CUpnpArgument* arg = iArguments[i];

        if ( aName.Compare( arg->Name() ) == 0 )
            {
            return arg;
            }
        }
    return NULL;
    }

// -----------------------------------------------------------------------------
// CUpnpAction::SetDestinationPathL
//
// -----------------------------------------------------------------------------
//
EXPORT_C void CUpnpAction::SetDestinationPathL( const TDesC8& aDestination )
    {
    delete iDestinationPath;
    iDestinationPath = NULL;
    iDestinationPath = aDestination.AllocL();
    }

// -----------------------------------------------------------------------------
// CUpnpAction::DestinationPath
//
// -----------------------------------------------------------------------------
//
EXPORT_C const TDesC8& CUpnpAction::DestinationPath()
    {
    return *iDestinationPath;
    }

// -----------------------------------------------------------------------------
// CUpnpAction::SetSender
//
// -----------------------------------------------------------------------------
//
EXPORT_C void CUpnpAction::SetSender( const TInetAddr & aSender )
    {
    iSender = aSender;
    }

// -----------------------------------------------------------------------------
// CUpnpAction::Sender
//
// -----------------------------------------------------------------------------
//
EXPORT_C TInetAddr& CUpnpAction::Sender()
    {
    return iSender;
    }

// -----------------------------------------------------------------------------
// CUpnpAction::Name
//
// -----------------------------------------------------------------------------
//
EXPORT_C TDesC8& CUpnpAction::Name()
    {
    return *iName;
    }

// -----------------------------------------------------------------------------
// CUpnpAction::ArgumentList
//
// -----------------------------------------------------------------------------
//
EXPORT_C RPointerArray<CUpnpArgument>& CUpnpAction::ArgumentList()
    {
    return iArguments;
    }

// -----------------------------------------------------------------------------
// CUpnpAction::DestinationAddr
//
// -----------------------------------------------------------------------------
//
EXPORT_C TInetAddr CUpnpAction::DestinationAddr() const
    {
    return iDestinationAddr;
    }

// -----------------------------------------------------------------------------
// CUpnpAction::ArgumentType
//
// -----------------------------------------------------------------------------
//
EXPORT_C TInt CUpnpAction::ArgumentType( const TDesC8 &aArgumentName )
    {
    for ( TInt i = 0; i < iArguments.Count(); i++ )
        {
        CUpnpArgument* arg = iArguments[i];

        if ( aArgumentName.Compare( arg->Name() ) == 0 )
            {
            return arg->Type();
            }
        }

    return EUndefined;
    }

// -----------------------------------------------------------------------------
// CUpnpAction::ServiceType
//
// -----------------------------------------------------------------------------
//
EXPORT_C TDesC8& CUpnpAction::ServiceType()
    {
    return const_cast<TDesC8&>( iParentService.ServiceType() );
    }

// -----------------------------------------------------------------------------
// CUpnpAction::SessionId
//
// -----------------------------------------------------------------------------
//
EXPORT_C TInt CUpnpAction::SessionId() const
    {
    return iSessionId;
    }

// -----------------------------------------------------------------------------
// CUpnpAction::SessionId
//
// -----------------------------------------------------------------------------
//
void CUpnpAction::SetSessionId( TInt aId )
    {
    iSessionId = aId;
    }

// -----------------------------------------------------------------------------
// CUpnpAction::SetDestinationAddr
//
// -----------------------------------------------------------------------------
//
EXPORT_C void CUpnpAction::SetDestinationAddr( const TInetAddr & aAddr )
    {
    iDestinationAddr = aAddr;
    }

// -----------------------------------------------------------------------------
// CUpnpAction::Error
//
// -----------------------------------------------------------------------------
//
EXPORT_C TInt CUpnpAction::Error() const
    {
    return iError;
    }

// -----------------------------------------------------------------------------
// CUpnpAction::Service
//
// -----------------------------------------------------------------------------
//
EXPORT_C CUpnpService& CUpnpAction::Service()
    {
    return iParentService;
    }

// -----------------------------------------------------------------------------
// CUpnpAction::SetError
//
// -----------------------------------------------------------------------------
//
EXPORT_C void CUpnpAction::SetError( TInt aError )
    {
    iError = aError;
    }

// -----------------------------------------------------------------------------
// CUpnpAction::Local
//
// -----------------------------------------------------------------------------
//
EXPORT_C TBool CUpnpAction::Local() const
    {
    return iLocal;
    }

// -----------------------------------------------------------------------------
// CUpnpAction::SetLocal
//
// -----------------------------------------------------------------------------
//
EXPORT_C void CUpnpAction::SetLocal( TBool aLocal )
    {
    iLocal = aLocal;
    }

// -----------------------------------------------------------------------------
// CUpnpAction::NewL
// for TESTS only
// -----------------------------------------------------------------------------
//
EXPORT_C CUpnpAction* CUpnpAction::NewL( const TDesC8& aActionName )
    {
    CUpnpAction* self = new (ELeave) CUpnpAction();
    CleanupStack::PushL( self );
    self->SetNameL( aActionName );
    CleanupStack::Pop( self );
    return self;
    }

// -----------------------------------------------------------------------------
// CUpnpAction::NewL
// -----------------------------------------------------------------------------
//
CUpnpAction* CUpnpAction::NewL( CUpnpService& aParentService )
    {
    CUpnpAction* self = new (ELeave) CUpnpAction( aParentService );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }

// -----------------------------------------------------------------------------
// CUpnpAction::NewL
// -----------------------------------------------------------------------------
//
void CUpnpAction::SetNameL( const TDesC8& aName )
    {
    HBufC8* tmp = aName.AllocL();
    delete iName;
    iName = tmp;
    }

// -----------------------------------------------------------------------------
// CUpnpAction::NewL
// -----------------------------------------------------------------------------
//
void CUpnpAction::AddArgumentL( CUpnpArgument& aAction )
    {
    iArguments.AppendL( &aAction );
    }

// -----------------------------------------------------------------------------
// ConstructL
// -----------------------------------------------------------------------------
//
void CUpnpAction::ConstructL()
    {
    iSessionId = CUpnpHttpMessage::NewSessionIdL();
    iDestinationPath = HBufC8::NewL( 0 );
    iName = HBufC8::NewL( 0 );
    }

// -----------------------------------------------------------------------------
// CUpnpAction::CUpnpAction
// for TESTS only. Object isn't completely valid. 
// -----------------------------------------------------------------------------
//
CUpnpAction::CUpnpAction() 
: iParentService(*(CUpnpService*)1)//tests only iParentService shouldn't be used
    {
    }

// End of File