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

// SIP Connection Provider States/Transitions

// 

//

/**

 @file

 @internalComponent

*/

#include "sipcprstates.h"

#include <comms-infras/ss_subconnprov.h>

#include <elements/nm_messages_base.h>

#include <comms-infras/ss_nodemessages_dataclient.h>

#include <comms-infras/ss_nodemessages_factory.h>

using namespace SipCpr;

using namespace SipCprStates;

using namespace ESock;

using namespace NetStateMachine;

namespace SipCprStates

{

//=======================================================================================================================

//

// BinderRequest Activity

//

//==========================================================================================================================

DEFINE_SMELEMENT(TIntializeWaitForIncmgParams, NetStateMachine::MStateTransition, SipCprStates::TContext)

void TIntializeWaitForIncmgParams::DoL()

	{	

	TCFServiceProvider::TCommsBinderRequest* binderReq = Messages::message_cast<TCFServiceProvider::TCommsBinderRequest>(&iContext.iMessage);

	if (binderReq)

    	{

    	TSubConnOpen::TSubConnType subconType = (TSubConnOpen::TSubConnType)binderReq->iValue;

    	iContext.Node().iSubconType = subconType;

    	if (subconType == RSubConnection::EWaitIncoming)

    		{

    		iContext.Node().iConnStatus = SipCpr::EConnIncoming ;    		

	    	}

	    	else

	    	{

	    	iContext.Node().iConnStatus = SipCpr::EConnOutgoing ;    			

	    	}    		

    	}    	    

	}

//=====================================================

//

// Provision Activity

//

//=============================================================

DEFINE_SMELEMENT(TStoreProvision, NetStateMachine::MStateTransition, SipCprStates::TContext)

void TStoreProvision::DoL()

	{

	__CFLOG_VAR((KSipCprTag, KSipCprSubTag, _L8("AStoreProvision::DoL()")));

	PRStates::TStoreProvision storeProvision(iContext);

	storeProvision.DoL();

	//Retrieve profileId, appUid and ptr to TransitionEngineMgr;

	const TSipMcprProvisionInfo* ext = static_cast<const TSipMcprProvisionInfo*>(iContext.Node().AccessPointConfig().FindExtension(STypeId::CreateSTypeId(TSipMcprProvisionInfo::EUid, TSipMcprProvisionInfo::ETypeId)));

	if (ext)

    	{

    	iContext.Node().iProfileId = ext->iProfileId;

    	iContext.Node().iAppUid	= ext->iAppUid;

    	iContext.Node().iTransitionEngineMgr = ext->iTransitionEngineMgr;

    	// Create the transition engine here so that it can be sent in

    	// send provision to SCPR 

    	CTransitionEngineMgr* mgr = iContext.Node().iTransitionEngineMgr;

		TUint32 profileId = iContext.Node().iProfileId;

    	TUid appUid = iContext.Node().GetAppUid();

    	CSIPTransitionEngine* transitionEngine = NULL;

		TInt err;

		TRAP(err, transitionEngine = mgr->FindOrCreateL(appUid, profileId));

		if(KErrNone != err)

			{

			__CFLOG_VAR((KSipCprTag, KSipCprSubTag, _L8("ARegister::DoL: Error [%d] while executing CTransitionEngineMgr::FindOrCreate")));			

			User::Leave(err);

			}

			else

			{

			__CFLOG_VAR((KSipCprTag, KSipCprSubTag, _L8("ARegister::DoL: Transition Engine has created")));			

			iContext.Node().iTransitionEngine = transitionEngine;

			if (profileId == KSIPDefaultProfileId)

				{

				profileId = mgr->DefaultProfileId();	

				}					

			}		

         }	

	}

DEFINE_SMELEMENT(TSendProvision, NetStateMachine::MStateTransition, SipCprStates::TContext)

void SipCprStates::TSendProvision::DoL()

	{	 

	//Adds the extension to Access Config which will beretrieved in 

	// non-default SCPR and ignored in default SCPR. 	

	iContext.Node().SetConfigL();    		    

	PRStates::TSendProvision  cprSendProvision(iContext);

	cprSendProvision.DoL();

	}	

//============================================================================

//

// Start Activity

//

//===========================================================================

DEFINE_SMELEMENT(TRegisterCpr,NetStateMachine::MStateTransition, SipCprStates::TContext)

DEFINE_SMELEMENT(TAwaitingRegistrationComplete,NetStateMachine::MState, SipCprStates::TContext)

DEFINE_SMELEMENT(TAwaitingIncomingConnection,NetStateMachine::MState, SipCprStates::TContext)

DEFINE_SMELEMENT(TSetPostedToScpr,NetStateMachine::MStateTransition, SipCprStates::TContext)

void TSetPostedToScpr::DoL()

	{

	// Get the SCPR node ID and wait for the IncomingConneciton message from him

	Messages::RNodeInterface* client = iContext.iNode.FindClient(Messages::message_cast<TCFFactory::TPeerFoundOrCreated>(iContext.iMessage).iNodeId);

	if (client)

		{

		iContext.iNodeActivity->SetPostedTo(client->RecipientId());	

		}	

	}

void TRegisterCpr::DoL()

	{	

	//check if profile ID has been set by passed by MCPR

	//if no profile Id was paseed as part of conn preferences

	//profile id is set to KSIPDefaultProfileId (which is a filler because 0 wont work)

	if (iContext.Node().iProfileId == KSIPDefaultProfileId)

		{

		iContext.Node().iProfileId = iContext.Node().iTransitionEngineMgr->DefaultProfileId();	

		}

	// Call the SIP High-level API for the Registration

	if (iContext.Node().iTransitionEngine == NULL)

		{				

		iContext.iNodeActivity->SetError(KErrNotFound);

		const Messages::TNodeId& self = iContext.Node().Id();		

		// Post RegistrationComplete msg with error set

		Messages::RClientInterface::OpenPostMessageClose(self,self,TSipCprMessages::TRegistrationComplete(KErrNotFound).CRef());				

		}

		else

		{

		iContext.Node().iTransitionEngine->RegisterL(&(iContext.Node()));

		iContext.Node().iStage = SipCpr::EStarting;		

		}

	//Expect Response

    iContext.Node().iActivityAwaitingResponse = iContext.iNodeActivity->ActivityId();

    iContext.iNodeActivity->SetPostedTo(iContext.Node().Id());			

	}	

TBool TAwaitingIncomingConnection::Accept()

	{

	if(iContext.iMessage.IsMessage<TSipCprMessages::TIncomingConnection>())		

		{		

		// reset it to the initial value so that so that it is taken care in next time

		// around. That i.e after Rconn.Waitforincoming() if subcon open is called 

		// on Rcon like subcon.open(Rcon) then it run into problems. 

		iContext.Node().iConnStatus = SipCpr::EConnOutgoing ;		

		return ETrue;

		}

	return EFalse;					

	}

TBool TAwaitingRegistrationComplete::Accept()

	{	

	if(iContext.iMessage.IsMessage<TSipCprMessages::TRegistrationComplete>())	

		{

		TSipCprMessages::TRegistrationComplete* msg = Messages::message_cast<TSipCprMessages::TRegistrationComplete>(&iContext.iMessage);

		if (msg->iValue == KErrNone)

			{

			iContext.Node().iStage = SipCpr::EActive;			

			}

			else

			{

			//Set the error for activity and will be raised

			TInt error = msg->iValue;

			iContext.iNodeActivity->SetError(error);			

			}

		return ETrue;	

		}

	return EFalse;

	}

DEFINE_SMELEMENT(TNoTagOrRegistered,NetStateMachine::MStateFork, SipCprStates::TContext)

TInt TNoTagOrRegistered::TransitionTag()

	{

	if(iContext.Node().iStage == SipCpr::EActive)

		{

		return SipCprStates::KRegistered;

		}

	return MeshMachine::KNoTag;

	}

//===============================================================================

//

// Stop Activity

//

//===============================================================================  

DEFINE_SMELEMENT(TDeRegisterCpr,NetStateMachine::MStateTransition, SipCprStates::TContext)

DEFINE_SMELEMENT(TAwaitingDeRegistrationComplete,NetStateMachine::MState, SipCprStates::TContext)

void TDeRegisterCpr::DoL()

	{

	// Call the SIP high level API for de-registraiton

	iContext.Node().iTransitionEngine->Deregister(&(iContext.Node()));	

	if(iContext.Node().iStage <= SipCpr::EStopping)

		{

		//We haven't recieved a DeRegister Request yet

		iContext.Node().iStage = SipCpr::EStopping;

		}

	//Expect Response

    iContext.Node().iActivityAwaitingResponse = iContext.iNodeActivity->ActivityId();

    iContext.iNodeActivity->SetPostedTo(iContext.Node().NodeId());

	}

TBool TAwaitingDeRegistrationComplete::Accept()

	{

	//catch only messages generated by the SIPCPR 

	ASSERT(iContext.iSender == iContext.Node().Id());

	if(iContext.iMessage.IsMessage<TSipCprMessages::TDeRegistrationComplete>())

		{

		TSipCprMessages::TDeRegistrationComplete* msg = Messages::message_cast<TSipCprMessages::TDeRegistrationComplete>(&iContext.iMessage);

		if (msg->iValue == KErrNone)

			{

			iContext.Node().iStage = SipCpr::EStopped;

			}

			else

			{

			//Set the error for activity so that it can be forwarded to applicaiton

			TInt error = msg->iValue;

			iContext.iNodeActivity->SetError(error);				

			}

		return ETrue;	

		}

	return EFalse;	

	}

/*

DEFINE_SMELEMENT(TSendStopped,NetStateMachine::MStateTransition, SipCprStates::TContext)

void TSendStopped::DoL()

	{

	TInt stopCode = iContext.Node().iStashedStoppedCode;

		//the section below is reproduced intoto from the CoreStates::TSendStopped :-)

	TCFMessage::TStopped msg(iContext.iNode(), iContext.iCFMessageSig.ActivityId(), stopCode);

	if (iContext.iNodeActivity)

		{

		iContext.iNodeActivity->PostToOriginators(msg);

		}

	else

		{

		//This transition can also be used from a single tripple activity

		ASSERT(iContext.iCFMessageSig.iPeer); //Always a peer message

		iContext.iCFMessageSig.iPeer->PostMessage(msg);

		}

	if (iContext.Node().CountActivities(ECFActivityStart) == 0)

    	{

        TCFMessage::TGoneDown goneDown(iContext.iNode(), ECFActivityNull, stopCode);

        TClientIter<TDefaultClientMatchPolicy> iter = iContext.Node().GetClientIter<TDefaultClientMatchPolicy>(RNodeInterface::ECtrl);

       	for (TInt i = 0; iter[i]; i++)

           	{

           	//Send TGoneDown to every Ctrl client except the originator (who would be recieving TStopped)

           	if ((iContext.iNodeActivity && iContext.iNodeActivity->FindOriginator(*iter[i]) != KErrNone) ||

           	    (iContext.iNodeActivity == NULL && iter[i] != iContext.iCFMessageSig.iPeer))

               	{

               	iter[i]->PostMessage(goneDown);

               	}

           	}

    	}

	if (iContext.iNodeActivity)

    	{

        iContext.iNodeActivity->SetError(KErrNone);

    	}

	}

*/	

/**

Comms-binder activity will use this function. 

It returns KWaitForIncoming if the connection type is WaitForIncoming

otherwise returns KUseExisting

*/

DEFINE_SMELEMENT(TWaitForIncomingOrUseExisting,NetStateMachine::MStateFork, SipCprStates::TContext)

TInt TWaitForIncomingOrUseExisting::TransitionTag()

	{

	if(iContext.Node().iConnStatus == SipCpr::EConnIncoming)

		{

		return CoreNetStates::KWaitForIncoming;

		}

		else

		{		

		return CoreStates::KUseExisting;

		}

	}

DEFINE_SMELEMENT(TNoTagOrDeRegister,NetStateMachine::MStateFork, SipCprStates::TContext)

TInt TNoTagOrDeRegister::TransitionTag()

	{	

	MeshMachine::CNodeActivityBase* activity = iContext.iNodeActivity;

	Messages::TSignatureBase& message = iContext.iMessage;

	TInt code = KErrCancel;

	if (activity && activity->Error() != KErrNone)

        {

        code = activity->Error();

        }

	if (message.IsTypeOf(Messages::TSigNumber::TypeId()))

		{

   		code = static_cast<const Messages::TSigNumber&>(message).iValue;

   		}

    else if (message.IsTypeOf(Messages::TSigNumberNumber::TypeId()))

		{

   		code = static_cast<const Messages::TSigNumberNumber&>(message).iValue1;

   		}

	//stash the stop code to be used after we get DeRegistrationComplete

	iContext.Node().iStashedStoppedCode = code;

	//Now do the regular fork

	if(iContext.Node().iStage == SipCpr::EActive)

		{

		return SipCprStates::KDeRegister;

		}

	return MeshMachine::KNoTag;

	}	

}// namespace SipCprStates