// 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:

//

/**

 @file 

 @internalComponent

*/

#include <cflog.h>

#include <commschan.h>

#include <cfshared.h>

using namespace CommsFW;

#include "bm_defs.h"

#ifdef _DEBUG

// Panic category for "absolutely impossible!" vanilla ASSERT()-type panics from this module

// (if it could happen through user error then you should give it an explicit, documented, category + code)

_LIT(KSpecAssert_ElemRootServerbm, "ElemRootServerbm");

#endif

CCommsChannelSendQueue* CCommsChannelSendQueue::NewL(RCFChannel& aChannel)

/**

Generates a new CCommsChannelSendQueue object

@param aChannel the send channel on which to send messages

@return A ptr to the new CCommsChannelSendQueue

@leave KErrNoMemory

*/

	{

	CCommsChannelSendQueue* This = 

		new(ELeave) CCommsChannelSendQueue(aChannel);

	CActiveScheduler::Add(This);

	return This;

	}

TInt CCommsChannelSendQueue::Send(const TCFMessage& aMsg)

/**

 Send method either sends the requested message immediately or stores it 

internally to send when space is available

param aMsg the message to be sent

@return A standard error code indicating success or failure

*/

	{ 

	TInt ret = KErrNone;

	if (IsActive())

		{

		// currently busy waiting for space

		ret = iMsgQueue.Append(aMsg);

		}

	else

		{

		__ASSERT_DEBUG(iMsgQueue.Count() == 0, User::Panic(KBindMgrPanic, EMsgQueueFault));

		ret = iChannel.Send(aMsg);

		if (KErrOverflow == ret)

			{

			ret = iMsgQueue.Append(aMsg);

			if (KErrNone == ret)

				{

				iChannel.NotifySpaceAvailable(iStatus);

				SetActive();

				}

			}

		}

	return ret;

	}

TInt CCommsChannelSendQueue::ReserveSpace()

/**

Called to make sure a message can be put on the queue at this time in 

this context. For the purpose it is used it would be a nice optimization

to also check whether there is actually room in the output channel first

as well, as the space then wouldn't be needed.

*/

	{

	// Add dummy message to the queue, to make sure there is space

	TCFMessage msg;

	TInt ret = iMsgQueue.Append(msg);

	if(KErrNone!=ret)

		{

		return ret;

		}

	iMsgQueue.Remove(iMsgQueue.Count()-1);

	return KErrNone;

	}

void CCommsChannelSendQueue::RunL()

/**

Active object RunL method is called when space becomes available on the send

queue. Attempts to send the first message in the queue.

@leave any code from RCFChannel.Send() except KErrOverflow

*/

	{

    __CFLOG_1(KLogSubSysRS, KLogCode, 

		_L8("CCommsChannelSendQueue::RunL &iStatus %08X"), &iStatus);

	switch(iStatus.Int())

		{

	case KErrNone:

			{

			while (iMsgQueue.Count() > 0)

				{

				TInt ret = iChannel.Send(iMsgQueue[0]);

				if (KErrNone == ret)

					{

					iMsgQueue.Remove(0);

					}

				else if (KErrOverflow == ret)

					{

					iChannel.NotifySpaceAvailable(iStatus);

					SetActive();

					break;

					}

				else

					{

					User::Leave(ret);

					}

				}

			}

		break;

	default:

		break;

		}

	}

void CCommsChannelSendQueue::DoCancel()

/** Cancel CCommsChannelSendQueue NotifySpaceAvailable().

*/

	{

	iChannel.CancelSpaceAvailable();

	}

CCommsChannelSendQueue::CCommsChannelSendQueue(RCFChannel &aChannel)

	: CActive(EPriorityStandard),

	  iChannel(aChannel)

/** Constructor for CCommsChannelSendQueue

*/

	{

	}

CCommsChannelSendQueue::~CCommsChannelSendQueue()

/** Destructor for CCommsChannelSendQueue

*/

	{

	Cancel();

	iMsgQueue.Close();

	}

CModule* CModule::NewL(MBindManagerNotify *aNotifier,

					   const TCFModuleNameF &aModule,

					   TransactionId &aTransactionId,

					   const RCFChannel::TMsgQueues& aInputQueues, 

					   const RCFChannel::TMsgQueues& aOutputQueues)

/** Generates a new CModule object

@param aNotifier bindmanager object to report events to

@param aModule name of module

@param aTransactionId xx

@param aInputQueues queues on which messages should sent to the module

@param aOutputQueues queues on which messages will be received from the module

@return A ptr to the new CModule

@leave KErrNoMemory

*/

	{

    CModule* pM = new (ELeave) CModule(aNotifier, aTransactionId, aModule);

    CleanupStack::PushL(pM);

	pM->ConstructL(aInputQueues, aOutputQueues);

    CleanupStack::Pop(pM);

	__CFLOG_STMT(TBuf8<KCFMaxModuleName> buf1;);

	__CFLOG_STMT(buf1.Copy(aModule););

    __CFLOG_2(KLogSubSysRS, KLogCode, 

		_L8("CModule::NewL module %S, &iStatus %08X"), &buf1, &(pM->iStatus));

    return pM;

	}

void CModule::ConstructL(const RCFChannel::TMsgQueues& aInputQueues, 

						 const RCFChannel::TMsgQueues& aOutputQueues)

/** Second phase constructor for CModule

@param aInputQueues queues on which messages should sent to the module

@param aOutputQueues queues on which messages will be received from the module

@leave KErrNoMemory

*/

	{

	User::LeaveIfError(iSendChannel.Create(aInputQueues, EOwnerProcess));

	User::LeaveIfError(iRecvChannel.Create(aOutputQueues, EOwnerProcess));

	iDiscoveryArray = new(ELeave) TCFSubModuleNameF[KDefaultSubmoduleArraySize];

	iSendQueue = CCommsChannelSendQueue::NewL(iSendChannel);

	// make us active

	CActiveScheduler::Add(this);

	iRecvChannel.NotifyDataAvailable(iStatus);

	SetActive();

	}

void CModule::DoCancel()

/** Cancel CModule NotifyDataAvailable

*/

	{

	iRecvChannel.CancelDataAvailable();

	}

TInt CModule::ReserveSpaceInSendQueue()

	{

	return iSendQueue->ReserveSpace();

	}

void CModule::RunL()

/** Active object RunL method, called when data becomes available on the receive

queue

@leave 

*/

	{

	__CFLOG_2(KLogSubSysRS, KLogCode, 

		_L8("CModule::RunL &iStatus %08X, status %d"), &iStatus, iStatus.Int());

	switch(iStatus.Int())

			{

	case KErrNone:

			{

		TCFMessage newMsg;

		TInt ret = iRecvChannel.Receive(newMsg);

		__CFLOG_1(KLogSubSysRS, KLogEvent, 

			_L8("CModule::RunL recv returned %d"), ret);

		if (ret == KErrUnderflow)

			{

			break;

			}

		TDblQueIter<CTask> taskIter(iTaskList);

		CTask *pTask;

		while ((pTask = taskIter++) != NULL)

			{

			if (pTask->ReplyMatches(newMsg))

				{

				break;

				}

			}

		if (pTask)

			{

			__CFLOG_2(KLogSubSysRS, KLogCode, _L8("CModule::RunL task found (code %d, id %d)"), newMsg.Code(), *((TId*)newMsg.ParamBlock()) );

			TBool finished = ETrue;

			TRAPD(result, finished = CheckDiscoveryMsgFinishedL( newMsg ) );

			if (result<KErrNone)

				{

			// it left, probably KErrNoMemory

			// so complete the message with this

				iNotifier->TaskCompleted(*this, *pTask, result);

				delete pTask;

				}

			else if (finished)

				{

				TInt status;

				CTask::GetMsgReturnCode(newMsg, status);

				// discovery messages overload the return code, to return

				// the number of submodulenames they wrote into the message

				// therefore a status retrieved that is greater than 0, implies

				// we should complete the request with KErrNone.

				if(status >= 0)

					{

					iNotifier->TaskCompleted(*this, *pTask, KErrNone);

					}

				else

					iNotifier->TaskCompleted(*this, *pTask, status);

				delete pTask;

				}

			}

		else

			{

			__CFLOG_2(KLogSubSysRS, KLogCode, 

				_L8("CModule::RunL matching task NOT found (code %d, id %d)"), newMsg.Code(), *((TId*)newMsg.ParamBlock()) );

			iNotifier->ReceivedMessage(Name(), newMsg);

			}

		}

		break;

	default:

		break;

		}

	iRecvChannel.NotifyDataAvailable(iStatus);

	SetActive();

	}

void CModule::Dequeue()

/** Remove this from the linked list

*/

	{

	iLink.Deque();

	}

const TCFModuleNameF& CModule::Name() const

/** Accessor method for the module name

@return The name

*/

	{

	return iName;

	}

const TBool& CModule::Initialising() const

/** Accessor method for the module initialisation state

@return True if module is still initialising

*/

	{

	return iInitialising;

	}

void CModule::SetInitialising(const TBool aInitialising)

/** Set method for the module initialisation state

@param aInitialising set true if module is initialising

*/

	{

	iInitialising = aInitialising;

	}

CModule::CModule(MBindManagerNotify *aNotifier, 

				 TransactionId &aTransactionId,

				 const TCFModuleNameF &aModule) :

	CActive(EPriorityStandard),

	iNotifier(aNotifier),

	iName(aModule),

	iInitialising(ETrue),

	iTaskList(_FOFF(CTask, iLink)),

	iTransactionId(aTransactionId)

/** Constructor for CModule

@param aNotifier bindmanager object to report events to

@param aTransactionId Generator of unique transaction ids

@param aModule the name of the module

*/

	{

	RS_DETLOG((KLogSubSysRS, KLogEvent, _L8("CModule::CModule(%X %S)"), this, &iName));

	}

void CModule::SendL(const TCFMessage &aMessage)

/** Public method to send a message to a comms server or CPM

@param aMessage the message to be sent

@leave KErrNoMemory

*/

	{

	// put msg on send queue

	User::LeaveIfError(iSendQueue->Send(aMessage));

	}

void CModule::DoDiscoverL(TUint &aTaskId)

/** Creates a task to send a discovery request to the module and sends the

message itself

@param aTaskId filled in with the id of the new task

@leave KErrNoMemory

*/

	{

	TCFDiscoverMsg discoverMsg(GetNextTransactionId(), ETrue, KDefaultSubmoduleArraySize, iDiscoveryArray);

	CTask* pTask = CTask::NewL(discoverMsg, discoverMsg.Identifier());

    CleanupStack::PushL(pTask);

	aTaskId = pTask->TaskId();

	// put msg on send queue

	SendL(discoverMsg);

    CleanupStack::Pop(pTask);

	iTaskList.AddLast(*pTask);

	}

TBool CModule::GetBindTaskL(const RCFChannel::TMsgQueues& aInputQueues, 

						    const RCFChannel::TMsgQueues& aOutputQueues,

						    const TCFSubModuleAddress& aSubModule1,

						    const TCFSubModuleAddress& aSubModule2,

						    const TCFBindType aType,

						    CTask*& aTask)

/** Either creates a task to send a bind request or returns an existing task

if a matching one already exists

@param aInputQueues queues for comms between the modules being bound

@param aOutputQueues queues for comms between the modules being bound

@param aSubModule1 first submodule being bound

@param aSubModule2 second submodule being bound

@param aType the type of binding

@param aTask set to point to the task

@return Etrue if a new task was created

@leave KErrNoMemory

*/

	{

	TBool newTask = EFalse;

	// see if this task already exists

	TCFBindMsg bindtest(0, aInputQueues, aOutputQueues, &aSubModule1, &aSubModule2, aType);

    TDblQueIter<CTask> taskIter(iTaskList);

	CTask *pTask;

	while ((pTask = taskIter++) != NULL)

		{

		if (pTask->CheckIfSame(bindtest))

			{

			break;

			}

		}

	// need to create a new one

	if (!pTask)

		{

		TCFBindMsg bindmsg(GetNextTransactionId(), aInputQueues, aOutputQueues, &aSubModule1, &aSubModule2, aType);

		pTask = CTask::NewL(bindmsg, bindmsg.Identifier());

		newTask = ETrue;

		}

	aTask = pTask;

	return newTask;

	}

TBool CModule::GetUnbindTaskL(const TCFSubModuleAddress& aSubModule1,

							  const TCFSubModuleAddress& aSubModule2,

							  const TBool aPeerIsDead,

							  CTask*& aTask)

/** Either creates a task to send an unbind request or returns an existing task

if a matching one already exists

@param aSubModule1 first submodule being unbound

@param aSubModule2 second submodule being unbound

@param aPeerIsDead indicates whether the second module is dead or not

@param aTask the task

@return Etrue if a new task was created

@leave KErrNoMemory

*/

	{

	TBool newTask = EFalse;

	// see if this task already exists

	TCFUnbindMsg unbindtest(0, &aSubModule1, &aSubModule2, aPeerIsDead);

    TDblQueIter<CTask> taskIter(iTaskList);

	CTask *pTask;

	while ((pTask = taskIter++) != NULL)

		{

		if (pTask->CheckIfSame(unbindtest))

			{

			break;

			}

		}

	if (!pTask)

		{

		TCFUnbindMsg unbindmsg(GetNextTransactionId(), &aSubModule1, &aSubModule2, aPeerIsDead);

		pTask = CTask::NewL(unbindmsg, unbindmsg.Identifier());

		newTask = ETrue;

		}

	aTask = pTask;

	return newTask;

	}

void CModule::DoStartTaskL(CTask* aTask)

/** Sends the task's message and adds it the the task in progress list

@param aTask the task to process

@leave KErrNoMemory

*/

	{

	__ASSERT_DEBUG(aTask, User::Panic(KSpecAssert_ElemRootServerbm, 1));	// Reassures LINT's ptr tracking

	SendL(aTask->Message());

	iTaskList.AddLast(*aTask);

	}

TInt CModule::EnumerateSubModules(const TInt& aPosition, TCFSubModuleNameF& aModuleName)

/** Enumerate all known submodules.

@param aPosition The position in the array of submodulenames.

@param aModuleName The name to be returned

@return Error code.

*/

    {

    if(aPosition>=iSubModuleNames.Count())

    	return KErrEof;

   	aModuleName = iSubModuleNames[aPosition];

    return KErrNone;

    }

TInt CModule::NumSubModules() const

/** Returns the number of submodules within this module

@return Number of submodules within this module

*/	

	{

	return iSubModuleNames.Count();

	}

TBool CModule::HasSubModule(const TCFSubModuleNameF &aSubModule) const

/** Searches for a specified submodule name within this module

@param aSubModule the name of the submodule to search for

@return Etrue if the submodule is found

*/

	{

	TInt i;

	TBool found = EFalse;

	for (i=0; i<iSubModuleNames.Count(); i++)

		{

		if (iSubModuleNames[i] == aSubModule)

			{

			found =  ETrue;

			break;

			}

		}

	return found;

	}

const TCFSubModuleAddress& CModule::SubModuleNameRefL(const TCFSubModuleAddress& aSubModule)

/** Provides a reference to a local copy of the submodule name passed as a 

parameter which is guaranteed to last the lifetime of the cmodule

@param aSubModule the name of the submodule

@return Reference to the internal submodule address

@leave KErrNoMemory

*/

	{

	TInt i;