/** @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:  Implements the CUpnpService class

*

*/

//  INCLUDE FILES

#include "upnpcommonstructs.h"

#include "upnpstring.h"

#include "upnphttpmessage.h"

#include "upnphttpmessagefactory.h"

#include "upnpserviceimplementation.h"

#include "upnpgenamessage.h"

#include "upnpdevice.h"

#include "upnpservice.h"

#include "upnpfileutils.h"

#include "upnpargument.h"

//for sax

#include "upnpcontenthandlerscontroller.h"

using namespace UpnpFileUtil;

static const TInt KMaxServiceDescriptionLength( 51200 );

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

CUpnpService* CUpnpService::NewL( CUpnpDevice* aDevice )

    {

    CUpnpService* self = new (ELeave) CUpnpService( *aDevice );

    return self;

    }

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

// CUpnpService::AddAction

// Add new action to action list

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

//        

void CUpnpService::AddActionL( CUpnpAction& aAction )

    {

    iActions.AppendL( &aAction );

    }

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

// CUpnpService::CUpnpService

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

EXPORT_C CUpnpService::CUpnpService( CUpnpDevice& aDevice )

: iParentDevice( aDevice )

    {

    }

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

// CUpnpService::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

EXPORT_C void CUpnpService::ConstructL( const TDesC8& aDescription,

        const TDesC8& /*aServiceType*/)

    {

    if ( aDescription.Length() > KMaxServiceDescriptionLength )

        {

        User::Leave( KErrTooBig );

        }

    CUpnpContentHandlersController* controller = 

        CUpnpContentHandlersController::NewLC();

    controller->ParseServiceL( aDescription, this );

    CleanupStack::PopAndDestroy( controller );

    }

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

// CUpnpService::NewL

// Two-phased constructor.

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

//

EXPORT_C CUpnpService* CUpnpService::NewL( const TDesC8& aDescription,

        const TDesC8& aServiceType,

        CUpnpDevice& aDevice )

    {

    CUpnpService* self = new (ELeave) CUpnpService( aDevice );

    CleanupStack::PushL( self );

    self->ConstructL( aDescription, aServiceType );

    CleanupStack::Pop( self );

    return self;

    }

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

// CUpnpService::~CUpnpService

// Destructor

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

//

EXPORT_C CUpnpService::~CUpnpService()

    {

    iActions.ResetAndDestroy();

    iActions.Close();

    iStateVariables.ResetAndDestroy();

    iStateVariables.Close();

    delete iType;

    delete iPath;

    delete iSubscriptionUrl;

    delete iControlUrl;

    delete iUrl;

    }

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

// CUpnpService::CreateActionLC

// Creating an action by Control Point

// (other items were commented in a header).

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

//

EXPORT_C CUpnpAction* CUpnpService::CreateActionLC( const TDesC8& aActionName )

    {

    TInt index( 0 );

    while ( index < iActions.Count() )

        {

        CUpnpAction& action = *iActions[index];

        if ( aActionName.Compare( action.Name() ) == KErrNone )

            {

            CUpnpAction* act = CUpnpAction::NewLC( action, *this );

            act->SetDestinationAddr( iParentDevice.Address() );

            act->SetDestinationPathL( ControlUrl() );

            return act;

            }

        index++;

        }

    return NULL;

    }

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

// CUpnpService::GetActionList

// Build a list of actions provided by the CUpnpService.

// (other items were commented in a header).

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

//

EXPORT_C void CUpnpService::GetActionList( RPointerArray<CUpnpAction>& aActionList )

    {

    aActionList = iActions;

    }

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

// CUpnpService::GetAction

// Returns an Action with the given name

// (other items were commented in a header).

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

//

EXPORT_C TBool CUpnpService::GetAction( CUpnpAction*& aAction, 

    const TDesC8& aActionName )

    {

    TBool result = EFalse;

    aAction = NULL;

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

        {

        if ( iActions[i]->Name().Compare( aActionName ) == 0 )

            {

            result = ETrue;

            aAction = iActions[i];

            break;

            }

        }

    return result;

    }

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

// CUpnpService::StateVariableList

//

// (other items were commented in a header).

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

//

EXPORT_C RPointerArray<CUpnpStateVariable> CUpnpService::StateVariableList() const

    {

    return iStateVariables;

    }

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

// CUpnpService::AddStateVariableL

// Add new state to state list

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

//

EXPORT_C void CUpnpService::AddStateVariableL( CUpnpStateVariable* aStateVariable )

    {

    iStateVariables.AppendL( aStateVariable );

    }

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

// CUpnpService::SetStateVariableL

//

// (other items were commented in a header).

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

//

EXPORT_C void CUpnpService::SetStateVariableL( const TDesC8& aName,

        const TDesC8& aValue )

    {

    TInt i( 0 );

    for ( i=0; i < iStateVariables.Count() &&

            iStateVariables[i]->Name() != aName; i++ )

        {

        }

    if ( i != iStateVariables.Count() )

        { 

        iStateVariables[i]->SetValueL( aValue );

        }

    }

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

// CUpnpService::StateVariable

//

// (other items were commented in a header).

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

//

EXPORT_C CUpnpStateVariable* CUpnpService::StateVariable( const TDesC8& aName )

    {

    TInt index = 0;

    while ( index < iStateVariables.Count() )

        {

        CUpnpStateVariable* var = iStateVariables[index];

        if ( aName.Compare( var->Name() ) == KErrNone )

            {

            return var;

            }

        index++;

        }

    return NULL;

    }

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

// CUpnpService::ServiceType

//

// (other items were commented in a header).

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

//

EXPORT_C const TDesC8& CUpnpService::ServiceType()

    {

    if (iType)

        {

        return *iType;

        }

    else

        {

        return KNullDesC8;

        }

    }

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

// CUpnpService::SetServiceTypeL

// Get service type of this (local or remote) service

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

//

void CUpnpService::SetServiceTypeL( const TDesC8& aServiceType )

    {

    HBufC8* tmp = aServiceType.AllocL();

    delete iType;

    iType = tmp;

    }

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

// CUpnpService::Path

//

// (other items were commented in a header).

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

//

EXPORT_C const TDesC8& CUpnpService::Path()

    {

    return *iPath;

    }

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

// CUpnpService::SetPathL

// Get message dispatching path. For internal use only

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

//

void CUpnpService::SetPathL( const TDesC8& aPath )

    {

    HBufC8* tmp = aPath.AllocL();

    delete iPath;

    iPath = tmp;

    }

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

// CUpnpService::Address

//

// (other items were commented in a header).

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

//

EXPORT_C TInetAddr CUpnpService::Address()

    {

    return iParentDevice.Address();

    }

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

// CUpnpService::SubscriptionUrl

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

//

EXPORT_C const TPtrC8 CUpnpService::SubscriptionUrl()

    {

    if ( iSubscriptionUrl )

        {

        return *iSubscriptionUrl;

        }

    else

        {

        return KNullDesC8();

        }

    }

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

// CUpnpService::SetSubscriptionUrl

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

//

EXPORT_C void CUpnpService::SetSubscriptionUrl( HBufC8* aUrl )

    {

    iSubscriptionUrl = aUrl;

    }

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

// CUpnpService::ControlUrl

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

//

EXPORT_C const TPtrC8 CUpnpService::ControlUrl()

    {

    if (iControlUrl)

        {

        return *iControlUrl;

        }

    else

        {

        return KNullDesC8();

        }

    }

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

// CUpnpService::SetControlUrl

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

//

EXPORT_C void CUpnpService::SetControlUrl( HBufC8* aUrl )

    {

    iControlUrl = aUrl;

    }

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

// CUpnpService::SetServiceUrl

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

//

EXPORT_C void CUpnpService::SetServiceDescriptionUrl( HBufC8* aUrl )

    {

    iUrl = aUrl;

    }

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

// CUpnpService::ControlUrl

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

//

EXPORT_C const TPtrC8 CUpnpService::ServiceDescriptionUrl()

    {

    if ( iUrl )

        {

        return *iUrl;

        }

    else

        {

        return KNullDesC8();

        }

    }

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

// CUpnpService::Device

// Gets parent device

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

//

EXPORT_C CUpnpDevice& CUpnpService::Device()

    {

    return iParentDevice;

    }

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

// CUpnpService::SetArgumentTypes

// Sets argument types 

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

//

void CUpnpService::SetArgumentTypes()

    {

    for ( TInt actionIndex(0); actionIndex < iActions.Count() ; actionIndex++ )

        {

        CUpnpAction* action = iActions[ actionIndex ];

        TInt actCount = action->ArgumentList().Count();

        for ( TInt argumentIndex(0); argumentIndex < actCount; argumentIndex++ )

            {

            CUpnpArgument* argument = action->ArgumentList()[ argumentIndex ];

            CUpnpStateVariable* stateVariable =

                    StateVariable( argument->RelatedStateVariable() );

            if ( stateVariable )

                {

                argument->SetType( stateVariable->Type() );

                }

            else

                argument->SetType( EUnknown );

            }

        }

    }

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

// CUpnpService::Added

// Set true value

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

//

void CUpnpService::Added()

    {

    iIsAdded = ETrue;

    }

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

// CUpnpService::IsAdded

// Get boolean value if added

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

//    

EXPORT_C TBool CUpnpService::IsAdded()

    {

    return iIsAdded;

    }

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

// CUpnpService::IsComplete

// Get boolean value if complete

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

// 

TBool CUpnpService::IsComplete()

    {

    return iComplete;

    }

//  End of File