/** @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:  Declares ConnectionManager class

*

*/

// INCLUDE FILES

#include <upnpdlnaprotocolinfo.h>

#include "upnpprotocolinfolocal.h"

#include <e32std.h>

#include "upnpcm.h"

#include "upnperrors.h"

#include "upnpargument.h"

#include "upnpcommonupnplits.h"

#include "upnpdeviceimplementationbase.h"

#include "upnpsecuritymanager.h"

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

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

// CUpnpCM::CUpnpCM

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

// might leave.

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

//

CUpnpCM::CUpnpCM( CUpnpDevice& aDevice ) : CUpnpServiceImplementation(aDevice)

	{

	}

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

// CUpnpCM::~CUpnpCM

// Destructor.

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

//

CUpnpCM::~CUpnpCM()

	{

	delete iSecurityManager;

	}

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

// CUpnpCM::ConstructL

// Two-phased constructor.

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

//

EXPORT_C CUpnpCM* CUpnpCM::NewL( CUpnpDevice& aDevice, 

                                 const TDesC8& aMediaTypes,

                                 const TDesC& aDescriptionPath )

	{

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

	CleanupStack::PushL( self );

	self->ConstructL( aMediaTypes, aDescriptionPath );

	CleanupStack::Pop( self );

	return self;

	}

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

// CUpnpCM::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CUpnpCM::ConstructL( const TDesC8& aMediaTypes, const TDesC& aDescriptionPath )

	{

	BaseConstructL( aDescriptionPath, KConnectionManagerType() );	

	// create ptocolInfos string

	HBufC8* protInfs = CreateProtocolInfosL(aMediaTypes);

	CleanupStack::PushL(protInfs);

	// set variable	

	SetStateVariableL( KProtInf, KEmptyString);

	SetStateVariableL( KSourceInf, *protInfs );

	SetStateVariableL( KSinkInf, KEmptyString );

	// clean up

	CleanupStack::PopAndDestroy(protInfs);

	SetStateVariableL( KCurConId,KZero );

	SetStateVariableL( KRcsId, UpnpCD::KMinusOne );

	SetStateVariableL( KAvtransId, UpnpCD::KMinusOne );

	SetStateVariableL( KConMan, KEmptyString );

    SetStateVariableL( KConId, UpnpCD::KMinusOne );

	SetStateVariableL( KDirection, KOutput );

	SetStateVariableL( KConStat, KOk );

	iSecurityManager = CUpnpSecurityManager::NewInstanceFromUpnpSettingsL();

	}

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

// CUpnpCM::CreateProtocolInfosL

// Handle action received from ServiceFramework

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

//

HBufC8* CUpnpCM::CreateProtocolInfosL(const TDesC8& aMediaTypes )

    {

	// parse comma separated media types

	CPtrC8Array* pairs = new(ELeave) CPtrC8Array(KGranularity);

	CleanupStack::PushL(pairs);

	GetMediaListFromStringL(pairs, aMediaTypes);

	// buffer

	CBufFlat* buf = CBufFlat::NewL(KBufExpandSize);

	CleanupStack::PushL(buf);

	// for each media element

	for (TInt i = 0; i < pairs->Count(); i++ )

	    {

		// create protocolInfo

		TInt pos(KErrNotFound);

		User::LeaveIfError(pos = (*pairs)[i].Find(KColon));

		TPtrC8 a((*pairs)[i].Left(pos));

		CUpnpProtocolInfoLocal* protInfo = 

				CUpnpProtocolInfoLocal::NewL( (*pairs)[i].Left(pos), (*pairs)[i].Mid(pos+1) );

		CleanupStack::PushL(protInfo);

		// get protocolInfo string

		TPtrC8 protocolInfo = protInfo->ProtocolInfoL();

		HBufC8* protStr = protocolInfo.Alloc();

		CleanupStack::PushL(protStr);

		// add to the buffer

		buf->InsertL(buf->Size(), *protStr);

		// add separator

		buf->InsertL(buf->Size(), KComma);

		CleanupStack::PopAndDestroy(protStr);

		CleanupStack::PopAndDestroy(protInfo);

	    }

	// delete last separator

	buf->Delete(buf->Size() - 1,KComma().Length());

	// alloc heap descriptor

	HBufC8* ret = buf->Ptr(0).AllocL();	

	// clean up

	CleanupStack::PopAndDestroy(buf);

	CleanupStack::PopAndDestroy(pairs);

	// return descritpor

	return ret;

    }

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

// CUpnpCM::GetMediaListFromStringL

// Handle action received from ServiceFramework

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

//

void CUpnpCM::GetMediaListFromStringL(CPtrC8Array* aList, const TDesC8& aMediaTypes)

    {

	TPtrC8 ml(aMediaTypes);

	TInt pos = KErrNotFound;

	while ((pos = ml.Find(KComma)) != KErrNotFound)

	    {

		aList->AppendL(ml.Left(pos));

		ml.Set(ml.Mid(pos+1));

	    }

	aList->AppendL(ml);

    }

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

// CUpnpCM::ActionReceivedLD

// Handle action received from ServiceFramework

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

//

void CUpnpCM::ActionReceivedLD( CUpnpAction* aAction )

	{

	CleanupStack::PushL( aAction );

        //check security

    if ( iSecurityManager &&

            KErrNone != iSecurityManager->AuthorizeAction( aAction ) )

        {

        //server returns upnp error action failed when not authorized

        User::Leave(EActionFailed);

        }

	TUpnpErrorCode eCode = EHttpOk;

    if ( !aAction )

        {

        User::Leave( KErrNotFound );

        }

	if ( aAction->Name().Compare( KGetProtInfo ) == 0 )

		{

		//Get supported Protocols

		eCode = GetProtocolInfoL( aAction );

		}

	else if ( aAction->Name().Compare( KGetCurConIds ) == 0 ) 

		{

		//Get Current Connection IDs 

		eCode = GetCurrentConnectionIDsL( aAction );

		}

	else if ( aAction->Name().Compare( KGetCurConInfo ) == 0 )

		{

		//Get Current Connection Info

		eCode = GetCurrentConnectionInfoL( aAction );

		}

	else if ( aAction->Name().Compare( KPrepareForConnection ) == 0 ) 

		{

		eCode = PrepareForConnection( aAction );

		}

	else if ( aAction->Name().Compare( KConnectionComplete ) == 0 )

		{

		eCode = ConnectionComplete( aAction );

		}

    else

        {

        // Action not defined

		eCode = EInvalidAction;

        }

	SendL( aAction, eCode );

	CleanupStack::PopAndDestroy( aAction );

	}

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

// CUpnpCM::GetProtocolInfoL

// Checks current stateVariables from stateVariableList returns Protocol-related

// info

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

//

TUpnpErrorCode CUpnpCM::GetProtocolInfoL( CUpnpAction* aAction )

	{			

	if ( aAction->SetArgumentL( KSource, 

				StateVariableValue( KSourceInf )) == KErrNone && 

 		aAction->SetArgumentL( KSink, 

				StateVariableValue( KSinkInf )) == KErrNone) 

		{

		return EHttpOk;

		}

	else 	

		{

		return EInvalidArgs;

		}					

	}

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

// CUpnpCM::PrepareForConnection

// Gets source and sink protocol info

// source = iSourceProtocolInfo

// sink = iSinkProtocolInfo

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

//

TUpnpErrorCode CUpnpCM::PrepareForConnection( CUpnpAction* /*aAction*/ )

	{

    // Not implemented in Media Server side.

	return ENotImplemented;

	}

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

// CUpnpCM::ConnectionComplete

// Fetch the AVTransport ID by giving ConnectionID

// iAVTransport->GetAVTransportID(ConnectionID)

// remove this ID from ConnectionIDs

// release network resources

// Cleanup

// Update source & sink devices information in stateVariableList

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

//

TUpnpErrorCode CUpnpCM::ConnectionComplete( CUpnpAction* /*aAction*/ )

	{

    // Not implemented in Media Server side.

	return ENotImplemented;

	}

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

// CUpnpCM::GetCurrentConnectionIDsL

// Check the current connections and insert a CSV list of them into the aAction

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

//

TUpnpErrorCode CUpnpCM::GetCurrentConnectionIDsL( CUpnpAction* aAction )

	{

	if ( aAction->SetArgumentL( KConnectionIDs, 

				StateVariableValue( KCurConId )) == KErrNone) 

		{

		return EHttpOk;

		}

	else 	

		{

		return EInvalidArgs;

		}	

	}

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

// CUpnpCM::GetCurrentConnectionInfoL

// Checks the ConnectionInfo of the connection specified in the aAction and sets

// the data to aAction

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

//

TUpnpErrorCode CUpnpCM::GetCurrentConnectionInfoL( CUpnpAction* aAction )

	{

	/**

	*Check the given connection is set up by PrepareForConnection()

	*if(connectionID == 0){

	*iRcsID=-1;

	*iAVTransportID = -1;

	*iProtocolInfo = NULL;

	*iPeerConnectionManager = NULL;

	*iPeerConnectionID = -1;

	*iDirection = input (or output);

	*iStatus = OK (or Unknown);

	* Gets the connection information by given connection ID.. 

	*

	*Acceptable Error Codes

	*	EInvalidArgs	=	402

	*	EParameterMismatch = 706

	**/	

	const TDesC8& connectionID = aAction->ArgumentValue( KArgument() ); 

	TLex8 string( connectionID );

	TInt testInt;

	TInt error = string.Val( testInt );

	if ( error != KErrNone )

		{

		return EInvalidArgs;

		}

	if ( connectionID.CompareC( KZero() ) == 0 )

		{

		if ( aAction->SetArgumentL( KTypeRcsID, 

				StateVariableValue( KRcsId )) == KErrNone && 

 			aAction->SetArgumentL( KTypeAVTransportID, 

				StateVariableValue( KAvtransId )) == KErrNone && 

 			aAction->SetArgumentL( KTypeProtocolInfo, 

				StateVariableValue( KArgTypeProtocolInfo )) == KErrNone && 

 			aAction->SetArgumentL( KTypePeerConnectionManager, 

				StateVariableValue( KConMan )) == KErrNone && 

 			aAction->SetArgumentL( KTypePeerConnectionID, 

				StateVariableValue( KConId )) == KErrNone && 

 			aAction->SetArgumentL( KTypeDirection, 

				StateVariableValue( KDirection )) == KErrNone && 	

 			aAction->SetArgumentL( KTypeStatus, 

				StateVariableValue( KConStat )) == KErrNone ) 

			{

			return EHttpOk;

			}

		else 	

			{

			return EInvalidArgs;

			}

		} 

	return EParameterMismatch;

	}

//  End of File