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

//

#include <cflog.h>

#include <cfshared.h>

using namespace CommsFW;

#include <cfmsgs.h>

#include <rsshared.h>

#include "RootServerTest.h"

__CFLOG_STMT(_LIT8(KLogTestCPM, "TestCPM");) // subsystem name

_LIT( KTestCpmPanic, "TestCpm" );

const TText8* const KSubModules[] = { _S8("Test Protocol1"), _S8("Test Protocol2"), _S8("Test Protocol3") };

class CDeathTimer : public CTimer

	{

public:

	static CDeathTimer* NewL(TInt aAfter)

		{

		CDeathTimer* self = new(ELeave) CDeathTimer;

		CleanupStack::PushL(self);

		self->ConstructL();

		CleanupStack::Pop(self);

		CActiveScheduler::Add(self);

		self->After(aAfter);

		return self;

		}

protected:

	CDeathTimer() : CTimer(EPriorityStandard)

		{

		}

	void RunL()

		{

		// Go not gracefully into that good night

		User::Invariant();

		}

	};

class CChannelHandler;

class CTestModule : public CBase

	{

public:

	enum {EPriority=1000}; ///< priority of this Active Object

public:

	~CTestModule();

	void CFMessageReceived(TCFMessage& aMsg);

	static CTestModule* NewL(TCFModuleInfo* aStartupArgs);

	void ConstructL(TCFModuleInfo* aStartupArgs);

	void LoggedAfter(TInt aAfterMS, const TDesC8& aDescription);

private:

	CChannelHandler* iChannelHandler;

	TTestModuleIniDataContainer iDelayTimes;

	TInt iDiscoverPos;

	CDeathTimer* iDeathTimer;

	};

class CChannelHandler:public CActive

	{

public:

	static CChannelHandler* NewL(RCFChannel::TMsgQueues aRxQueues, 

									RCFChannel::TMsgQueues aTxQueues, CTestModule* aModule);

	void RunL();

	TInt Send(TCFMessage);

	~CChannelHandler();

protected:

	virtual void DoCancel();

private:

	void ConstructL(RCFChannel::TMsgQueues aRxQueues, 

					RCFChannel::TMsgQueues aTxQueues, CTestModule* aModule);

	CChannelHandler();

private:

	CTestModule* iModule;

	RCFChannelPair iChannelPair;

	};

//

// CChannelHandler class definitions

//

CChannelHandler::CChannelHandler():CActive(CActive::EPriorityStandard)

	{

	CActiveScheduler::Add(this);

	}

CChannelHandler* CChannelHandler::NewL(RCFChannel::TMsgQueues aRxQueues, 

									RCFChannel::TMsgQueues aTxQueues, CTestModule* aModule)

	{

	CChannelHandler* pHandler = new (ELeave) CChannelHandler;

	pHandler->ConstructL(aRxQueues, aTxQueues, aModule);

	return pHandler;

	}

void CChannelHandler::ConstructL(RCFChannel::TMsgQueues aRxQueues, 

									RCFChannel::TMsgQueues aTxQueues, CTestModule* aModule)

	{

	iModule = aModule;

	iChannelPair.CreateSend(aTxQueues);

	iChannelPair.CreateRecv(aRxQueues);

	SetActive();

	iChannelPair.NotifyDataAvailable(*this);

	}

void CChannelHandler::DoCancel(void)

	{

	iChannelPair.CancelDataAvailable();

	}

TInt CChannelHandler::Send(TCFMessage aMsg)

	{

	TRequestStatus status;

	iChannelPair.NotifySpaceAvailable(*this);

	User::WaitForRequest(status);

	return iChannelPair.Send(aMsg);

	}

void CChannelHandler::RunL()

	{

	if (iStatus != KErrNone)

		{

		User::Invariant();

		}

	// No error. Take the message from the channel.

	TCFMessage msg;

	TInt err = iChannelPair.Receive(msg);

	if (KErrNone == err)

		{

		//Pass the message

		iModule->CFMessageReceived(msg);

		//Pend again

		SetActive();

		iChannelPair.NotifyDataAvailable(*this);

		}

	else

		{

		User::Invariant();

		}

	}

CChannelHandler::~CChannelHandler()

	{

	if(IsActive())

		Cancel();

	iChannelPair.CloseNonGracefully();

	}	

//

// implementation of CTestServer

//

CTestModule* CTestModule::NewL(TCFModuleInfo* aStartupArgs)

/**

 * Create a new CCommServer.

 *

 * This is not a normal 2 phase contruction. If the allocation of the object

 * fails we will panic with -4 which means that something is very wrong.

 */

	{

	CTestModule* pS;

	CleanupStack::PushL(pS = new CTestModule);

	__ASSERT_ALWAYS(pS!=NULL, User::Panic( KTestCpmPanic, KErrNoMemory));

#ifdef SYMBIAN_C32ROOT_API_V3

	pS->ConstructL(aStartupArgs);

#else

	TRAPD(r, pS->ConstructL(aStartupArgs));

	__ASSERT_ALWAYS(r==KErrNone, User::Panic( KTestCpmPanic, KErrNoMemory));

#endif

	CleanupStack::Pop(pS);

	return pS;

	}

void CTestModule::ConstructL(TCFModuleInfo* aStartupArgs)

	{

	if (aStartupArgs->iIniData != NULL)

		{

		if (aStartupArgs->iIniData->Length() == sizeof(iDelayTimes))

			{

			TTestModuleIniData pkg;

			pkg.Copy(*(aStartupArgs->iIniData));

#if defined(SYMBIAN_C32ROOT_API_V3)

			delete aStartupArgs->iIniData;

#endif

			iDelayTimes = pkg.iParams;

			if(iDelayTimes.iInitDelay == EXIT_BEFORE_RENDEZVOUS)

				User::Leave(KErrGeneral);

			else if(iDelayTimes.iInitDelay > 0)

				LoggedAfter(iDelayTimes.iInitDelay, _L8("Init"));

			else if(iDelayTimes.iInitDelay == PANIC_BEFORE_RENDEZVOUS)

				User::Panic(_L("TESTCPM"), 1);

			__CFLOG_5( KLogTestCPM, KLogCode, 

				_L8("TestCpm[%LU] - iIniData delays (msec): discoveryDelay %d bindDelay %d unbindDelay %d shutdownDelay %d"), 

						 RThread().Id().Id(), iDelayTimes.iDiscoveryDelay, iDelayTimes.iBindDelay,

						 iDelayTimes.iUnbindDelay, iDelayTimes.iShutdownDelay);

			iChannelHandler = CChannelHandler::NewL(aStartupArgs->iRxQueues, aStartupArgs->iTxQueues, this);

			RThread::Rendezvous(KErrNone);

			if(iDelayTimes.iInitDelay == PANIC_AFTER_RENDEZVOUS)

				User::Panic(_L("TESTCPM"), 1);

			}

		else

			{

			__CFLOG_1( KLogTestCPM, KLogCode, _L("TestCpm[%LU] - iIniData mismatched"), RThread().Id().Id() );

#if defined(SYMBIAN_C32ROOT_API_V3)

			delete aStartupArgs->iIniData;

#endif

			ASSERT(0);

			}

		}

	else

		{

		__CFLOG_1( KLogTestCPM, KLogCode, _L("TestCpm[%LU] - No iIniData"), RThread().Id().Id() );

		ASSERT(0);

		}

	}

void CTestModule::CFMessageReceived(TCFMessage& aMsg)

	{

	//It is called when a new message arrives from incomming channel

	switch (aMsg.Code())

		{

		case TCFCommsMessage::ECodeDiscover:

			{

			// now wait for delay

			__CFLOG(KLogTestCPM, KLogCode, _L("TestCpm Discover message received"));

			LoggedAfter(iDelayTimes.iDiscoveryDelay, _L8("Discovery"));

			const TCFDiscoverMsg& msg = reinterpret_cast<const TCFDiscoverMsg&>(aMsg);

			// we return our sub-modules one at a time to make sure the RootServer copes with iterative discovery

			const TInt numSubModules = sizeof(KSubModules) / sizeof(KSubModules[0]);

			ASSERT(msg.Size() > 0);

			ASSERT(iDiscoverPos < numSubModules);

			if(msg.Reset())

				iDiscoverPos = 0;

			TCFSubModuleName name;

			const TText8* subMod = KSubModules[iDiscoverPos++];

			name.Copy(subMod);

			msg.SubModuleNames()[0] = name;

			TBool discoveryEnded = (iDiscoverPos == numSubModules);

			TCFDiscoverRespMsg diskresp(msg.Identifier(), 1, !discoveryEnded);

			TInt err = iChannelHandler->Send(diskresp);

			if(KErrNone != err)

				{

       		    User::Invariant();

				}

			if(discoveryEnded && iDelayTimes.iDeathDelay != NO_PREMATURE_DEATH)

				{

				TRAP(err, iDeathTimer = CDeathTimer::NewL(iDelayTimes.iDeathDelay * 1000));

				ASSERT(iDeathTimer);

				}

			}

			break;

		case TCFCommsMessage::ECodeBind:

			{

			__CFLOG(KLogTestCPM, KLogCode, _L("TestCpm Bind message received"));

			// now wait for delay

			LoggedAfter(iDelayTimes.iBindDelay, _L8("Bind"));

			const TCFBindMsg& msg = reinterpret_cast<const TCFBindMsg&>(aMsg);

			TCFBindCompleteMsg resp(msg.Identifier(), KErrNone);

			TInt err = iChannelHandler->Send(resp);

			if(KErrNone != err)

				{

				User::Invariant();

				}

			}

			break;

		case TCFCommsMessage::ECodeUnbind: 

			{

			__CFLOG(KLogTestCPM, KLogCode, _L("TestCpm UnBind message received"));

			// now wait for delay

			LoggedAfter(iDelayTimes.iUnbindDelay, _L8("Unbind"));

			const TCFUnbindMsg& msg = reinterpret_cast<const TCFUnbindMsg&>(aMsg);

			TCFUnbindCompleteMsg resp(msg.Identifier(), KErrNone);

			TInt err = iChannelHandler->Send(resp);

			if(KErrNone != err)

				{

				User::Invariant();

				}

			}

			break;

		case TCFCommsMessage::ECodeShutdown:

			// now wait for delay

			__CFLOG(KLogTestCPM, KLogCode, _L("TestCpm Shutdown message received"));

			LoggedAfter(iDelayTimes.iShutdownDelay, _L8("Shutdown"));

			CActiveScheduler::Stop();

			break;

		default:;

			User::Invariant();

		}

	}

CTestModule::~CTestModule()

	{

	delete iChannelHandler;

	delete iDeathTimer;

	}

void CTestModule::LoggedAfter(TInt aAfterMS, const TDesC8& aDescription)

	{ 

	(void) aDescription;

	__CFLOG_2(KLogTestCPM, KLogCode, _L8("TestCpm: %d ms %S pause"), aAfterMS, &aDescription);

	User::After(aAfterMS * 1000);

	__CFLOG_1(KLogTestCPM, KLogCode, _L8("TestCpm: %S pause complete"), &aDescription);

	}

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

void DoModuleThreadL(TAny * aArg)

	{

	TCFModuleInfo* args = reinterpret_cast<TCFModuleInfo*>(aArg);

	CActiveScheduler*  scheduler = new (ELeave) CActiveScheduler;

	CleanupStack::PushL(scheduler);

	CActiveScheduler::Install(scheduler); 

	CTestModule *pTm = CTestModule::NewL(args);

    __CFLOG_1( KLogTestCPM, KLogCode, _L("TestCpm[%LU] - Completed rendezvous."), RThread().Id().Id() );

	CActiveScheduler::Start();

	__CFLOG_1( KLogTestCPM, KLogCode, _L("TestCpm[%LU] - Exiting thread function"), RThread().Id().Id() );

	delete pTm;

	CActiveScheduler::Install(NULL);

	CleanupStack::PopAndDestroy(scheduler);

	}

EXPORT_C TInt ModuleThread(TAny * aArg)

	{

	CTrapCleanup* cleanup = CTrapCleanup::New();

	if(!cleanup)

		return KErrNoMemory;	

	TRAPD(ret, DoModuleThreadL(aArg))

	if (ret!=KErrNone)

		{

		__CFLOG(KLogTestCPM, KLogCode, _L("ModuleThread failed to create TestCpm"));

		}

	delete cleanup;

	return ret;

	}