// Copyright (c) 2005-2009 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:

// Implement the AVCTP Muxer state classes.

// These are CAvctpMuxerStateFactory, TAvctpMuxerState (abstract) and its derived

// classes 

// Together, these classes and the Muxer implement the State pattern

// (GOF).  The states themselves are implemented using the Flyweight

// pattern.  Each state is a Flyweight object, and CAvctpMuxerStateFactory

// is manager of these objects.  As a result of being a flyweight, no

// state object may have state that can't be shared between all

// possible users of the state (i.e. no per-Muxer state)

// 

//

/**

 @file

 @internalComponent

*/

#include <bluetooth/logger.h>

#include <es_prot.h>

#include <es_mbuf.h>

#include "avctpmuxerstates.h" 

#include "bt_subconn_levels.h"

#include "Avctp.h"

#include "avctpmuxer.h"

#include "avctputils.h"

#include "avctpconstants.h"

#include "avctpPacketMgr.h"

#ifdef __FLOG_ACTIVE

_LIT8(KLogComponent, LOG_COMPONENT_AVCTP);

#endif

using namespace SymbianAvctp;

//

//                                                                                       //

// TAvctpMuxerState Implementation                                                       //

//                                                                                       //

//

/** 

Default constructor.

@internalComponent

@param aFactory The Muxer state factory

*/

TAvctpMuxerState::TAvctpMuxerState(CAvctpMuxerStateFactory& aFactory)

	: iFactory(aFactory)

	{

	LOG_FUNC

	}

/** 

Change a Muxer from one state to another.

We Exit() the first state and then Enter() the second

@internalComponent

@param aTransport The Muxer whose state is to be changed

@param aNewState The index for the new state the Muxer is to transition to

*/

void TAvctpMuxerState::ChangeState(CAvctpTransport& aTransport, CAvctpMuxerStateFactory::TAvctpMuxerStates aNewState) const

	{

	LOG_FUNC

	aTransport.iState->Exit(aTransport);

#ifdef __FLOG_ACTIVE

	TAvctpMuxerState& state = iFactory.GetState(aNewState);

#endif

	LOG3(_L("Muxer 0x%08x : State %S -> %S"), &aTransport, &(aTransport.iState->iName), &(state.iName));

	aTransport.iState = &iFactory.GetState(aNewState);

	aTransport.iState->Enter(aTransport);

	}

/**

Calls the appropriate panic function to encode the panic

code with the current state identifier.

@param aPanic The panic code that the state is panicking with.

*/

void TAvctpMuxerState::PanicInState(SymbianAvctp::TPanic aPanic) const

	{

	Panic(aPanic, iFactory.StateIndex(this));

	}

/**

 Close the secondary l2cap channel with or without notifying clients.

 @param aTransport the transport the state is related to

 @param aNotifyClient if it's ETrue clients are notified.

 */

void TAvctpMuxerState::ShutDownSecondarySap(CAvctpTransport& aTransport, TBool aNotifyClient) const

	{

	LOG_FUNC

	CServProviderBase* sap = aTransport.iChannelSAPs[KAvctpSecondaryChannel];

	if (sap)

		{

		sap->Shutdown(CServProviderBase::EImmediate);

		delete sap;

		sap = NULL;

		aTransport.iChannelSAPs[KAvctpSecondaryChannel] = NULL;

		if (aNotifyClient)

			{

			aTransport.NotifyLinkDown(aTransport.iRemoteAddr, KAvctpSecondaryChannel);

			}

		ChangeState(aTransport, CAvctpMuxerStateFactory::EOpen);

		}

	}

/**

Default state entry function.

@internalComponent

@param aTransport The Muxer whose state is changing

*/

void TAvctpMuxerState::Enter(CAvctpTransport& /*aTransport*/) const

	{

	LOG_FUNC

	}

/**

Default state exit function.

@internalComponent

@param aTransport The Muxer whose state is changing

*/

void TAvctpMuxerState::Exit(CAvctpTransport& /*aTransport*/) const

	{

	LOG_FUNC	

	}

/**

Default Muxer IsIdle

The muxer is asking its state to determine whether it's idle.

@internalComponent

@param aTransport The Muxer which is idle

*/

TBool TAvctpMuxerState::IsIdle(CAvctpTransport& aTransport) const

	{

	LOG_FUNC

	TBool hasData = aTransport.HasDataToSend();

	TBool pidCount = aTransport.ClientCount(); 

	LOG1(_L("Is Idle: %d"), (!hasData && pidCount == 0));

	return (!hasData && pidCount == 0);

	}

/**

Default Muxer IdleTimerExpired

This is a confirmation that the muxer isn't wanted and so should go

to the closed state and die.

  @internalComponent

  @param aTransport The Muxer which is idle

*/

void TAvctpMuxerState::IdleTimerExpired(CAvctpTransport& aTransport) const

	{

	LOG_FUNC

	ChangeState(aTransport, CAvctpMuxerStateFactory::EClosed);

	}

/**

  Default Muxer State Start (outgoing) function.

  We've been asked to start a connection to the specified address

  The default is to assume that nothing needs to be done.

  @internalComponent

  @param aTransport The Muxer which is to start up

  @param aAddr  The remote address to start up

  @return System wide error code

*/

TInt TAvctpMuxerState::Start(CAvctpTransport& aTransport, const TBTDevAddr& aAddr, TUint16 /*aClientId*/) const

	{

	LOG_FUNC

	__ASSERT_DEBUG(aAddr != TBTDevAddr(0) && aTransport.DevAddr() == aAddr, PanicInState(EWrongBTAddress));

	(void)aAddr;

	(void)aTransport;

	return KErrNone;

	}

/**

  Default Muxer State Start (incoming) function.

  We've been asked to start a connection using the given L2CAP sap

  However, this is only valid when we're in the Closed state so 

  panic

  @internalComponent

  @param aTransport The Muxer which is to start up

  @param aL2CAPConSAP The existing connection

  @return System wide error code

*/

TInt TAvctpMuxerState::StartIncoming(CAvctpTransport& /*aTransport*/, const TBTDevAddr& /*aAddr*/, CServProviderBase* /*aL2CAPConSAP*/) const

	{

	LOG_FUNC

	PanicInState(EUnexpectedMuxerEvent);

	return KErrNone;

	}

TInt TAvctpMuxerState::AddSecondChannel(CAvctpTransport& /*aTransport*/, CServProviderBase& /*aSAP*/) const

	{

	LOG_FUNC

	return KErrNotReady;

	}

void TAvctpMuxerState::RemoveSecondChannel(CAvctpTransport& /*aTransport*/) const

	{

	LOG_FUNC

	}

TInt TAvctpMuxerState::SecondChannelRemoved(CAvctpTransport& /*aTransport*/) const

	{

	LOG_FUNC

	return KErrNotReady;

	}

/**

  Default Muxer State CancelConnectRequest function.

  This is called when a control client wants to cancel a connection to a particular PID.

  The connection will actually only be cancelled if there are no remaining control

  clients for this connection.

  @internalComponent

  @param aTransport The Muxer which is affected

*/		

TInt TAvctpMuxerState::CancelConnectRequest(CAvctpTransport& /*aTransport*/, TUint16 /*aClientId*/) const

	{

	LOG_FUNC

	return KErrNotReady;

	}

/**

Default Muxer Shutdown function.

  @internalComponent

  @param aTransport The Muxer which is to shutdown

*/

void TAvctpMuxerState::Shutdown(CAvctpTransport& /*aTransport*/, TInt /*aError*/) const

	{

	LOG_FUNC

	PanicInState(EUnexpectedMuxerEvent);

	}

/**

Default Muxer Disconnect function.

  @internalComponent

  @param aTransport The Muxer whose L2CAP link has just gone down

*/

void TAvctpMuxerState::Disconnect(CAvctpTransport& /*aTransport*/) const

	{

	LOG_FUNC

	PanicInState(EUnexpectedMuxerEvent);

	}

/**

Default Muxer ConnectComplete function.

  @internalComponent

  @param aTransport The Muxer whose L2CAP connection has just come up

*/

void TAvctpMuxerState::ConnectComplete(CAvctpTransport& /*aTransport*/) const

	{

	LOG_FUNC

	PanicInState(EUnexpectedMuxerEvent);

	}

/**

Default Muxer Error function

  @internalComponent

  @param aTransport The Muxer which has just received an error from it's channel sap

  @param anError The error

  @param anOperationMask The effected operation

*/

void TAvctpMuxerState::Error(CAvctpTransport& /*aTransport*/, TInt /*aError*/,TUint /*aOperationMask*/, TInt /*aChannel*/) const

	{

	LOG_FUNC

	PanicInState(EUnexpectedMuxerEvent);

	}

/**

Default Muxer new data function

  @internalComponent

  @param aTransport The Muxer which has received the notification of new data.

*/

TInt TAvctpMuxerState::NewData(CAvctpTransport& /*aTransport*/, TUint /*aMtu*/, TInt /*aChannel*/) const

	{

	LOG_FUNC

	PanicInState(EUnexpectedMuxerEvent);

	return KErrNone;

	}

/**

Default Muxer can send function

  @internalComponent

  @param aTransport The Muxer which can now send

*/

void TAvctpMuxerState::CanSend(CAvctpTransport& /*aTransport*/,TInt /*aChannel*/) const

	{

	LOG_FUNC

	PanicInState(EUnexpectedMuxerEvent);

	}

//

//                                                                                       //

// Implementation of TAvctpStateClosed.                                                  //

//                                                                                       //

//

/**

Default constructor

  @internalComponent

  @param aFactory The Muxer state factory

*/

TAvctpStateClosed::TAvctpStateClosed(CAvctpMuxerStateFactory& aFactory)

	: TAvctpMuxerState(aFactory)

	{

	LOG_FUNC

	STATENAME("Closed");

	}

/**

Closed state entry function.

This is only called on re-entering the Closed state, so we're not needed so delete ourselves

@internalComponent

@param aTransport The Muxer whose state is changing

*/

void TAvctpStateClosed::Enter(CAvctpTransport& aTransport) const

	{

	LOG_FUNC

	delete &aTransport;

	}

/**

Closed state exit function.

@internalComponent

@param aTransport The Muxer whose state is changing

*/

void TAvctpStateClosed::Exit(CAvctpTransport& aTransport) const

	{

	LOG_FUNC

	__ASSERT_ALWAYS(aTransport.DevAddr() != TBTDevAddr(0), PanicInState(ENullTBTDevAddr));

	}

/**

Closed Muxer IdleTimerExpired

The idle timer should only expire in a non closed state so panic

if we get it in this state.

  @internalComponent

  @param aTransport The Muxer which is idle

*/

void TAvctpStateClosed::IdleTimerExpired(CAvctpTransport& /*aTransport*/) const

	{

	LOG_FUNC

	PanicInState(EUnexpectedMuxerEvent);

	}

/**

  Closed Muxer State Start (outgoing) function.

  This function asks us to start a connection to the specified address

  @internalComponent

  @param aTransport The Muxer which is to start up

  @param aAddr  The remote address to start up

  @return System wide error code

*/

TInt TAvctpStateClosed::Start(CAvctpTransport& aTransport, const TBTDevAddr& aAddr, TUint16 /*aClientId*/) const

	{

	LOG_FUNC

	__ASSERT_DEBUG(aTransport.DevAddr() == TBTDevAddr(0), PanicInState(ETBTDevAddrNotNull));

	TInt ret = KErrNone;

	if (aAddr != TBTDevAddr(0))

		{

		// New this up just in time.

		TRAP(ret, aTransport.iChannelSAPs[KAvctpPrimaryChannel] = aTransport.iProtocol.LowerProtocol()->NewSAPL(KSockSeqPacket));

		if (ret == KErrNone)

			{

			aTransport.AssignToDevice(aAddr);			

			ChangeState(aTransport, CAvctpMuxerStateFactory::ELinkPending);		

			}

		}

	else

		{

		// do nothing - stay closed

		ret = KErrNone;

		}

	if (ret != KErrNone)

		{

		delete &aTransport;

		}

	return ret;

	}

/**

  Closed Muxer State Start (incoming) function.

  We've been asked to start a connection using the given L2CAP sap

  @internalComponent

  @param aTransport The Muxer which is to start up

  @param aL2CAPConSAP The existing connection

  @return System wide error code

*/

TInt TAvctpStateClosed::StartIncoming(CAvctpTransport& aTransport, const TBTDevAddr& aAddr, CServProviderBase* aL2CAPConSAP) const

	{

	LOG_FUNC

	TInt ret = SymbianAvctp::KErrBadAddress;

	// If the following is not true we'll Kern-Exec 3 anyway so assert always

	__ASSERT_ALWAYS(aL2CAPConSAP, PanicInState(ENullLowerProtocolSap));

	__ASSERT_DEBUG(aTransport.DevAddr() == TBTDevAddr(0), PanicInState(ETBTDevAddrNotNull));

	if (aAddr != TBTDevAddr(0))

		{

		aTransport.AssignToDevice(aAddr);		

		aTransport.iChannelSAPs[KAvctpPrimaryChannel] = aL2CAPConSAP;

		aTransport.iChannelSAPs[KAvctpPrimaryChannel]->SetNotify(&aTransport);

		aTransport.iChannelSAPs[KAvctpPrimaryChannel]->Start();

		ChangeState(aTransport, CAvctpMuxerStateFactory::EOpen);		

		ret = KErrNone;

		}

	// else covered by ret

	if (ret != KErrNone)

		{

		delete &aTransport;

		}

	return ret;

	}

//

//                                                                                       //

// Implementation of void TAvctpStateLinkPending                                         //

//                                                                                       //

// Represents a muxer waiting for the L2CAP link to be created.                          //

//                                                                                       //

//

/**

Default constructor

  @internalComponent

  @param aFactory The Muxer state factory

*/

TAvctpStateLinkPending::TAvctpStateLinkPending(CAvctpMuxerStateFactory& aFactory)

	: TAvctpMuxerState(aFactory)

	{

	LOG_FUNC

	STATENAME("LinkPending");

	}

/**

Link Pending state entry function.

We request the lower protocol SAP to bring up the link.

@internalComponent

@param aTransport The Muxer which is waiting for a link

*/

void TAvctpStateLinkPending::Enter(CAvctpTransport& aTransport) const

	{

	LOG_FUNC

	__ASSERT_ALWAYS(aTransport.iChannelSAPs[KAvctpPrimaryChannel], PanicInState(ENullLowerProtocolSap));

	aTransport.DequeIdleTimer();

	// we become the socket for iChannelsSAPs[0]

	aTransport.iChannelSAPs[KAvctpPrimaryChannel]->SetNotify(&aTransport);

	TL2CAPSockAddr addr;

	addr.SetBTAddr(aTransport.DevAddr());

	addr.SetPort(KAVCTP);

	// the security settings are:	

	// (though see :Preauthorise() for the authentication exceptions due to avdtp authentication)

	TBTServiceSecurity sec;

	sec.SetAuthentication(KOutboundAuthenticationDefault);

	sec.SetAuthorisation(KOutboundAuthoristationDefault);

	sec.SetEncryption(KOutboundEncryptionDefault);

	sec.SetDenied(EFalse);

	sec.SetUid(KAvctpServiceUid);	

	addr.SetSecurity(sec);

	TInt err = aTransport.iChannelSAPs[KAvctpPrimaryChannel]->SetRemName(addr);

	__ASSERT_DEBUG(!err, PanicInState(EErrorSettingAddress));