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

// Implements the avdtp stream statemachine

// 

//

/**

 @file

 @internalComponent

*/

#include <bluetooth/logger.h>

#include "avdtpStream.h"

#include "avdtp.h"

#include "avdtpSignallingChannel.h"

#include "avdtpSignallingSession.h"

#ifdef __FLOG_ACTIVE

_LIT8(KLogComponent, LOG_COMPONENT_AVDTP);

#endif

#ifdef _DEBUG

#define DEBUGPANICINSTATE(aPanic) PanicInState(aPanic)

#else

#define DEBUGPANICINSTATE(aPanic)

#endif

// state ctors

TAVStreamState::TAVStreamState(CAVStreamStateFactory& aFactory)

: iFactory(aFactory)

	{

	STATENAME("BASE");

	}

TAVStreamStateIdle::TAVStreamStateIdle(CAVStreamStateFactory& aFactory)

: TAVStreamState(aFactory)

	{

	STATENAME("Idle");

	}

TAVStreamStateOpen::TAVStreamStateOpen(CAVStreamStateFactory& aFactory)

: TAVStreamStateIdle(aFactory)

	{

	STATENAME("Open");

	}

TAVStreamStateReady::TAVStreamStateReady(CAVStreamStateFactory& aFactory)

: TAVStreamStateOpen(aFactory)

	{

	STATENAME("Ready");

	}

TAVStreamStateWaitForSessions::TAVStreamStateWaitForSessions(CAVStreamStateFactory& aFactory)

: TAVStreamStateIdle(aFactory)

	{

	STATENAME("WaitForSessions");

	}

TAVStreamStateWaitForSessionsStartReceived::TAVStreamStateWaitForSessionsStartReceived(CAVStreamStateFactory& aFactory)

: TAVStreamStateWaitForSessions(aFactory)

	{

	STATENAME("WaitForSessionsStartReceived");

	}

TAVStreamStateConfiguring::TAVStreamStateConfiguring(CAVStreamStateFactory& aFactory)

: TAVStreamStateIdle(aFactory)

	{

	STATENAME("Configuring");

	}

TAVStreamStateConfigured::TAVStreamStateConfigured(CAVStreamStateFactory& aFactory)

: TAVStreamStateIdle(aFactory)

	{

	STATENAME("**Abstract** Configure");

	}

TAVStreamStateINTConfigured::TAVStreamStateINTConfigured(CAVStreamStateFactory& aFactory)

: TAVStreamStateConfigured(aFactory)

	{

	STATENAME("INTConfigured");

	}

TAVStreamStateACPConfigured::TAVStreamStateACPConfigured(CAVStreamStateFactory& aFactory)

: TAVStreamStateConfigured(aFactory)

	{

	STATENAME("ACPConfigured");

	}	

TAVStreamStateOpening::TAVStreamStateOpening(CAVStreamStateFactory& aFactory)

: TAVStreamStateIdle(aFactory)

	{

	STATENAME("Opening");

	}

TAVStreamStateCreatingLogicalChannels::TAVStreamStateCreatingLogicalChannels(CAVStreamStateFactory& aFactory)

: TAVStreamStateOpen(aFactory)

	{

	STATENAME("CreatingLogicalChannels");

	}

TAVStreamStateReleasing::TAVStreamStateReleasing(CAVStreamStateFactory& aFactory)

: TAVStreamStateReady(aFactory)

	{

	STATENAME("Releasing");

	}

TAVStreamStateAborting::TAVStreamStateAborting(CAVStreamStateFactory& aFactory)

: TAVStreamStateReady(aFactory)

	{

	STATENAME("Aborting");

	}

TAVStreamStateStreaming::TAVStreamStateStreaming(CAVStreamStateFactory& aFactory)

: TAVStreamStateReady(aFactory)

	{

	STATENAME("Streaming");

	}

TAVStreamStateStarting::TAVStreamStateStarting(CAVStreamStateFactory& aFactory)

: TAVStreamStateReady(aFactory)

	{

	STATENAME("Starting");

	}

TAVStreamStateSuspending::TAVStreamStateSuspending(CAVStreamStateFactory& aFactory)

: TAVStreamStateReady(aFactory)

	{

	STATENAME("Suspending");

	}

TAVStreamStateWaitingForLogicalChannels::TAVStreamStateWaitingForLogicalChannels(CAVStreamStateFactory& aFactory)

: TAVStreamStateOpen(aFactory)

	{

	STATENAME("WaitingForLogicalChannels");

	}

TAVStreamStateReconfiguring::TAVStreamStateReconfiguring(CAVStreamStateFactory& aFactory)

: TAVStreamStateReady(aFactory)

	{

	STATENAME("Reconfiguring");

	}

// default state actions

void TAVStreamState::Enter(CAVStream& /*aStream*/) const

	{

	LOG_FUNC

	// do nothing by default

	}

void TAVStreamState::Exit(CAVStream& /*aStream*/) const

	{

	LOG_FUNC

	// do nothing by default

	}

void TAVStreamState::Release(CAVStream& aStream) const

	{

	LOG_FUNC

	// it already has been Released

	aStream.Released();

	}

void TAVStreamState::AwaitLogicalChannelsL(CAVStream& /*aStream*/) const

	{

	LOG_FUNC

	DEBUGPANICINSTATE(EAvdtpUnexpectedAwaitLogicalChannelsEvent);

	}

void TAVStreamState::LogicalChannelsAvailable(CAVStream& /*aStream*/, TLogicalChannelFactoryTicket /*aTicket*/, TInt /*aError*/) const

	{

	LOG_FUNC

	DEBUGPANICINSTATE(EAvdtpUnexpectedLogicalChannelsAvailableEvent);

	}

void TAVStreamState::WatchdogFired(CAVStream& /*aStream*/) const

	{

	LOG_FUNC

	DEBUGPANICINSTATE(EAvdtpUnexpectedWatchdogFiredEvent);

	}

void TAVStreamState::Configured(CAVStream& /*aStream*/) const

	{

	LOG_FUNC

	DEBUGPANICINSTATE(EAvdtpUnexpectedConfiguredEvent);

	}

void TAVStreamState::SetConfigurationL(CAVStream& /*aStream*/, 

										RBuf8& /*aPacketBuffer*/, CSignallingChannel& /*aSignallingChannel*/,

										TBool /*aReportingConfigured*/,

								  		TBool /*aRecoveryConfigured*/) const

	{

	LOG_FUNC

	DEBUGPANICINSTATE(EAvdtpUnexpectedSetConfigurationEvent);

	User::Leave(KErrNotReady);

	}

void TAVStreamState::SetConfigConfirm(CAVStream& /*aStream*/, TInt /*aResult*/, 

									TSEID /*aRemoteSEID*/, TAvdtpServiceCategory /*aFailedCategory*/) const

	{

	// throw away

	}

void TAVStreamState::ReconfigConfirm(CAVStream& /*aStream*/, TInt /*aResult*/, 

									TSEID /*aRemoteSEID*/, TAvdtpServiceCategory /*aFailedCategory*/) const

	{

	LOG_FUNC

	// throw away

	}

void TAVStreamState::StartConfirm(CAVStream& /*aStream*/, TInt /*aResult*/, TSEID /*aSEID*/) const

	{

	LOG_FUNC

	// throw away

	}

void TAVStreamState::AbortConfirm(CAVStream& /*aStream*/, TSEID /*aSEID*/) const

	{

	LOG_FUNC

	// throw away

	}

void TAVStreamState::OpenConfirm(CAVStream& /*aStream*/, TInt /*aResult*/, TSEID /*aSEID*/) const

	{

	LOG_FUNC

	// default, throw away weirdo response from remote

	}

void TAVStreamState::ReleaseConfirm(CAVStream& /*aStream*/, TInt /*aResult*/, TSEID /*aSEID*/) const

	{

	LOG_FUNC

	// throw away

	}

void TAVStreamState::SuspendConfirm(CAVStream& /*aStream*/, TInt /*aResult*/, TSEID /*aSEID*/) const

	{

	LOG_FUNC

	// throw away

	}	

TInt TAVStreamState::AddSession(CAVStream& /*aStream*/, 

							TAvdtpTransportSessionType /*aType*/,

							CUserPlaneTransportSession& /*aSession*/,

							CTransportChannel*& /*aTransportChannel*/) const

	{

	LOG_FUNC

	DEBUGPANICINSTATE(EAvdtpUnexpectedAddSessionEvent);

	return KErrNotReady;

	}

void TAVStreamState::DropSession(CAVStream& /*aStream*/, TAvdtpTransportSessionType /*aType*/,

							 CUserPlaneTransportSession& /*aSession*/) const

	{

	LOG_FUNC

	DEBUGPANICINSTATE(EAvdtpUnexpectedDropSession);

	}

TInt TAVStreamState::StartReceived(CAVStream& /*aStream*/) const

	{

	LOG_FUNC

	return KErrNotReady;

	}

TBool TAVStreamState::IsStreaming(const CAVStream& /*aStream*/) const

	{

	LOG_FUNC

	return EFalse;

	}

TInt TAVStreamState::Start(CAVStream& /*aStream*/) const

	{

	LOG_FUNC

	return KErrNotReady;

	}

TInt TAVStreamState::Suspend(CAVStream& /*aStream*/) const

	{

	LOG_FUNC

	return KErrNotReady;

	}

void TAVStreamState::Started(CAVStream& /*aStream*/) const

	{

	LOG_FUNC

	// signalling session should have sanity checked with previous StartReceived()

	DEBUGPANICINSTATE(EAvdtpUnexpectedStartedEvent);

	}

void TAVStreamState::Suspended(CAVStream& /*aStream*/) const

	{

	LOG_FUNC

	// signalling session should have sanity checked with previous IsStreaming

	DEBUGPANICINSTATE(EAvdtpUnexpectedSuspendedEvent);

	}

void TAVStreamState::ChangeState(CAVStream& aContext, CAVStreamStateFactory::TAVStreamStates aState) const

	{

	LOG_FUNC

	aContext.iState->Exit(aContext);

#ifdef __FLOG_ACTIVE

	const TAVStreamState* const newState=&iFactory.GetState(aState);

	LOG2(_L("Stream: State %S -> %S"), &aContext.iState->iName, &newState->iName);

#endif //__FLOG_ACTIVE

	aContext.iState=&iFactory.GetState(aState);

	aContext.iState->Enter(aContext);

	}

void TAVStreamState::PanicInState(TAvdtpPanic aPanic) const

	{

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

	}

// derived states and state changes

void TAVStreamStateIdle::Configured(CAVStream& aStream) const

	{

	// ah - going ACP

	ChangeState(aStream, CAVStreamStateFactory::EStreamStateACPConfigured);

	}

void TAVStreamStateIdle::SetConfigurationL(CAVStream& aStream, 

											RBuf8& aPacketBuffer,

											CSignallingChannel& aSignallingChannel,

										  	TBool aReportingConfigured,

								  			TBool aRecoveryConfigured) const

	{

	LOG_FUNC

// An INT procedure to add in extra options the stack wishes to do, regardless of client

// At present this is limited to mux&frag - which we do if local and remote have

// the *capability* to do so, even if the proposed *configuration* doesnt mention it

// AVDTP is daft, so have to arrange for IDs before objects exist if muxing used

// we also need to base this on the number of sessions we know we're going to run	

// see 8.19.8

// 5.4.6 allow fors no reporting session so it's not *obvious* when the 2nd element is

// bit like not obvious what the 2nd L2cap channel will bear

// further, if we're muxing, we need to see what optional sessions are proposed

// in the configuration to see what to configure in the mux capability

	TBool canMux;

	TBool canFrag;

	aStream.CanMuxFrag(canMux, canFrag);

	TInt err = KErrNone;

	if (canMux)

		{

		// muxing is awkward - must identify the TCs and TSs that are going to be used NOW

		TAvdtpMultiplexingCapability* mux = aStream.CreateMuxCapabilityL(aReportingConfigured, aRecoveryConfigured, aSignallingChannel);

		// ok to create packetstructure - only exchange IDs if do mux

		err = mux->AsProtocol(aPacketBuffer);

		}

	if (!err)

		{

		// First check that we are in a state to send a set configuration command as

		// we don't want to send one unless we can commit the pending configuration

		err = aStream.iLocalSEP->CheckConfigurationState(EFalse);

 		if (!err)

			{

			err = aSignallingChannel.SendSetConfiguration(aStream, 

								aStream.LocalSEID(), aStream.RemoteSEID(), aPacketBuffer);

			if (!err)

				{

				// tell SEP

				err = aStream.iLocalSEP->SetPendingConfiguration(aPacketBuffer, EFalse); //takes ownership of RBuf

				// we should not get an error here as we called CheckConfigurationState above

				__ASSERT_DEBUG(!err, PanicInState(EAvdtpInconsistentPendingConfigurationState));

				if (!err)

					{

					aPacketBuffer.Assign(NULL); // since ownership transfer succeeded

					ChangeState(aStream, CAVStreamStateFactory::EStreamStateConfiguring);

					}

				}

			}

		}

	if (err)

		{

		// clean up and don't bother proceeding

		aStream.DeallocateUnclaimedTransportSessionIDs();

		User::Leave(err);

		}

	}

void TAVStreamStateIdle::Enter(CAVStream& __DEBUG_ONLY(aStream)) const

	{

	LOG_FUNC

	//We should not be preventing the encryption key refresh in this state. Asserting this condition. 

	__ASSERT_DEBUG(!aStream.IsHostEncryptionKeyRefreshPrevented(),Panic(EUnexpectedEncryptionKeyRefreshPrevent));

	}

void TAVStreamStateConfiguring::SetConfigConfirm(CAVStream& aStream, TInt aResult, 

												TSEID /*aRemoteSEID*/, TAvdtpServiceCategory aFailedCategory) const

	{

	LOG_FUNC

	//update our state before telling others

	TRAPD(res, aStream.iLocalSEP->CommitPendingConfigurationL(aResult==KErrNone, EFalse));

	if (res!=KErrNone)

		{

		aResult = res;

		}

	if (aResult==KErrNone)

		{

		TBool rp = aStream.CheckConfigured(EServiceCategoryReporting);

		TBool rc = aStream.CheckConfigured(EServiceCategoryRecovery);

		aStream.iNumSessionsRequired = AvdtpInternalUtils::NumberOfTransportObjects(rp, rc);

		ChangeState(aStream, CAVStreamStateFactory::EStreamStateINTConfigured);			

		}

	aStream.iStreamNotify.StreamConfigured(aStream.LocalSEID(), aResult, aFailedCategory);

	if (aResult!=KErrNone)

		{

		// remove the stream as the configure failed the stream is invalid

		aStream.Released();	// deletes stream

		}

	}

void TAVStreamStateConfiguring::Enter(CAVStream& __DEBUG_ONLY(aStream)) const

	{

	LOG_FUNC

	//We should not be preventing the encryption key refresh in this state. Asserting this condition. 

	__ASSERT_DEBUG(!aStream.IsHostEncryptionKeyRefreshPrevented(),Panic(EUnexpectedEncryptionKeyRefreshPrevent));

	}

void TAVStreamStateConfigured::Release(CAVStream& aStream) const

	{

	// in this state to Release a stream object (cos it errored say)

	// needs us to send an Abort rather than a Close to remote

	// this is because the remote will need to mark its SEP as not in use,

	// but we haven't yet sent an Open.

	LOG_FUNC

	CSignallingChannel* sigch = aStream.iProtocol.FindSignallingChannel(aStream.iRemoteAddress.BTAddr());

	if (sigch)

		{

		TInt err = sigch->SendAbort(aStream, aStream.RemoteSEID());

		if (err==KErrNone)

			{

			ChangeState(aStream, CAVStreamStateFactory::EStreamStateAborting);

			}

		else

			{

			// just have to die

			aStream.Released();

			}

		}	

	}

void TAVStreamStateConfigured::Enter(CAVStream& __DEBUG_ONLY(aStream)) const

	{

	LOG_FUNC

	//We should not be preventing the encryption key refresh in this state. Asserting this condition. 

	__ASSERT_DEBUG(!aStream.IsHostEncryptionKeyRefreshPrevented(),Panic(EUnexpectedEncryptionKeyRefreshPrevent));

	}

/**

An INT primitive

A session is adding itself to the stream.

Record its details and find a channel for it to use.

Record the binding between session and channel.

Once all the required sessions are added the stream tries to open the remote

*/

TInt TAVStreamStateINTConfigured::AddSession(CAVStream& aStream,

									TAvdtpTransportSessionType aType,

						   			CUserPlaneTransportSession& aSession,

						   			CTransportChannel*& aChannel) const

	{

	LOG_FUNC

	TInt ret = KErrNone;

	// check GAVDP isn't being naughty and asking for an unconfigured session

	if ((aType==EReporting && !aStream.CheckConfigured(EServiceCategoryReporting))

		|| (aType==ERecovery && !aStream.CheckConfigured(EServiceCategoryRecovery)))

		{

		// gavdp is trying to use a session it has never configured

		ret = KErrNotSupported;

		}

	if (ret == KErrNone)

		{

		TBool useMux;

		TBool useFrag;	//ignored

		aStream.CanMuxFrag(useMux, useFrag);

		aChannel = aStream.iProtocol.GetTransportChannel(aStream.iRemoteAddress, useMux);

		if (aChannel)

			{

			// bind session to channel

			ret = aChannel->AttachTransportSession(aSession, aType);

			if (ret==KErrNone)

				{

				// keep a copy of this binding

				TTransportBinding binding;

				binding.iSession = &aSession;

				binding.iChannel = aChannel;

				// keep object bindings

				TTransportBinding* b = NULL;

				switch (aType)

					{