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

*/

#ifndef SYMBIAN_DEN_MSGS_H

#define SYMBIAN_DEN_MSGS_H

#include <elements/cftransportmsg.h>

#include <elements/nm_interfaces.h>

#include <elements/sd_mintercept.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_ElemSvrDenMsgH, "ElemSvrDenMsgH");

#endif

namespace Den

{

/** Messages from Main Thread to Worker Threads (with Resp messages being responses

sent back from Worker)

*/

class TWorkerMsg : public CommsFW::TCFMessage

	{

public:

	enum

		{

		/** Number of messages reserved for ESock internal usage. Currently bigger than the actual

		number of messages to provide space for more in the future.

		@see TWorkerMsg::TCode::ELastWorkerMsgCode

		*/

		KWorkerMessageCodeReserveSize = 15

		};

	enum TCode

		{

		/** This is the first message sent on a binding by any worker thread. It identifies the basics

		about the worker

		*/

		EWorkerIntroduction = CommsFW::TCFCommsMessage::ECodePrivateFlag,

		/** This is the second message sent on a binding by a worker. It identifies a standard set of

		cookies. In the future it's expected that the legacy transport will only be used for the above

		initial intro message which will carry a boot-strapping cookie and all other cookies will

		be identified directly to that one

		*/

		EWorkerCookies,

		/** This is sent from the main thread to all workers when a significant configuration event

		happens, as indicated in the message (eg the boot of modules)

		*/

		EConfigurationComplete,

		/** This requests that the tier mappings are loaded from CommsDat. A worker can send it to the

		PitBoss and the PitBoss can send it to the tier resolver. In the latter case the tier resolver

		responds with TWorkerTierMappingsLoaded

		*/

		ELoadTierMappings,

		/** The tier resolver reports through this that the previously requested load of the tier mappings

		is complete

		*/

		ETierMappingsLoaded,

		/** This is sent from the PitBoss to a worker thread to notify that another worker has

		died and the receiver is expected to clean up any data structures/states related to that

		dead worker (if any).

		The receiver is expected to respond with a ECleanupDeadPeerResp message.

		@see TWorkerMsg::ECleanupDeadPeerResp

		*/

		ECleanupDeadPeer,

		/** Response from worker to main thread that cleanup after dead peer has been completed.

		@see TWorkerMsg::ECleanupDeadPeer

		*/

		ECleanupDeadPeerResp,

		/** Notification that a player role management responsibility has ended (eg a Player data

		flows signals the Player hosting subconnections when it unbinds, which can only happen when

		all flows have ceased dependency upon the sub-connections

		@see TWorkerMsg::TPlaneUnboundMsg

		*/

		EPlaneUnbound,

		/** Carries data that did not fit into EWorkerIntroduction

		*/

		EWorkerIntroduction2,

		/** Introduction message from main thread to workers to prompt objects to join their broker in the main thread

		*/

		EFactoryContainerIntroduction,

		/** Introduces a factory container object broker in the main thread to a worker thread

		*/

		EBrokerIntroduction,

		/** Dummy trailer code to give reference point for starting a following sequence of message codes. */

		ELastWorkerMsgCode = CommsFW::TCFCommsMessage::ECodePrivateFlag + KWorkerMessageCodeReserveSize

		};

	inline TWorkerMsg(TInt aCode)

		{

		Code(aCode);

		}

	};

/**

class TWorkerIntroductionMsg

*/

class TWorkerIntroductionMsg : public TWorkerMsg

	{

public:

	enum {KCode = TWorkerMsg::EWorkerIntroduction};//< Message code

	enum {KMaxIntroductionInfoSize = sizeof(Messages::TNodeId)};

	inline TWorkerIntroductionMsg(const TWorkerThreadPublicInfo& aWorkerInfo)

	:	TWorkerMsg(KCode)

		{

		TParams* params=reinterpret_cast<TParams*>(ParamBlock());

		params->iWorkerInfo = aWorkerInfo;

		params->iDebugMsgIntercept = NULL;

		params->iFailType = RAllocator::ENone;

		params->iFailRate = 0;

		params->iIntroductionInfo[0] = 0; //To mark as empty

		}

	inline const TWorkerThreadPublicInfo& WorkerInfo() const

		{

		const TParams* params = reinterpret_cast<const TParams*>(ParamBlock());

		return params->iWorkerInfo;

		}

	inline void IntroductionInfo(TDes8& aIntroductionInfo) const

		{

		TInt size = aIntroductionInfo.MaxSize() - aIntroductionInfo.Size();

		__ASSERT_DEBUG(size <= KMaxIntroductionInfoSize, User::Panic(KSpecAssert_ElemSvrDenMsgH, 1));

		const TParams* params=reinterpret_cast<const TParams*>(ParamBlock());

		aIntroductionInfo.Copy(&params->iIntroductionInfo[0], KMaxIntroductionInfoSize);

		}

	inline void SetIntroductionInfo(const TDesC8& aIntroductionInfo)

		{

		__ASSERT_DEBUG(aIntroductionInfo.Size() <= KMaxIntroductionInfoSize, User::Panic(KSpecAssert_ElemSvrDenMsgH, 2));

		TParams* params=reinterpret_cast<TParams*>(ParamBlock());

		__ASSERT_DEBUG(params->iIntroductionInfo[0] == 0, User::Panic(KSpecAssert_ElemSvrDenMsgH, 3));

		Mem::Copy(params->iIntroductionInfo, aIntroductionInfo.Ptr(), aIntroductionInfo.Size());

		}

#ifdef _DEBUG

	inline void SetFailType(RAllocator::TAllocFail aFailType)

		{

		TParams* params = reinterpret_cast<TParams*>(ParamBlock());

		params->iFailType = aFailType;

		}

	inline RAllocator::TAllocFail FailType() const

		{

		const TParams* params = reinterpret_cast<const TParams*>(ParamBlock());

		return params->iFailType;

		}

	inline void SetFailRate(TInt aFailRate)

		{

		TParams* params = reinterpret_cast<TParams*>(ParamBlock());

		params->iFailRate = aFailRate;

		}

	inline TInt FailRate() const

		{

		const TParams* params = reinterpret_cast<const TParams*>(ParamBlock());

		return params->iFailType;

		}

#endif

#if defined (__ELEMENTS_MESSAGE_INTERCEPT_ACTIVE)

	inline void SetMessageInterceptGlobal(CMessageInterceptRegister* aMsgInterceptRegister)

		{

		TParams* params = reinterpret_cast<TParams*>(ParamBlock());

		params->iDebugMsgIntercept = reinterpret_cast<TAny*>(aMsgInterceptRegister);

		}

	inline CMessageInterceptRegister* MsgInterceptRegister() const

		{

		const TParams* params = reinterpret_cast<const TParams*>(ParamBlock());

		return reinterpret_cast<CMessageInterceptRegister*>(params->iDebugMsgIntercept);

		}

#endif // __ELEMENTS_MESSAGE_INTERCEPT_ACTIVE

private:

	struct TParams /** Message parameters */

		{

		TWorkerThreadPublicInfo iWorkerInfo;	//< Crucial information about the worker thread/server

		// Pointer to the process wide singleton created by the main thread

		TAny* iDebugMsgIntercept;

		RAllocator::TAllocFail iFailType;

		TInt iFailRate;

		TUint8 iIntroductionInfo[KMaxIntroductionInfoSize];

		};

	__ASSERT_COMPILE(sizeof(TParams) <= CommsFW::KCFMessageParamBlockSize);

	};

/**

class TWorkerConfigurationComplete

@see TWorkerMsg::EConfigurationComplete

*/

class TWorkerConfigurationComplete : public TWorkerMsg

	{

public:

	enum {KCode = TWorkerMsg::EConfigurationComplete};/**Message code*/

	inline TWorkerConfigurationComplete(TConfigurationCompletionType aType)

	: TWorkerMsg(KCode)

		{

		TParams* params=reinterpret_cast<TParams*>(ParamBlock());

		params->iType = aType;

		}

	inline TConfigurationCompletionType Type() const

		{

		const TParams* params = reinterpret_cast<const TParams*>(ParamBlock());

		return params->iType;

		}

private:

	struct TParams /** Message parameters */

		{

		TConfigurationCompletionType iType;

		};

	};

/**

class TWorkerCleanupDeadPeerMsg

@see TWorkerMsg::ECleanupDeadPeer

*/

class TWorkerCleanupDeadPeerMsg : public TWorkerMsg

	{

public:

	enum {KCode = TWorkerMsg::ECleanupDeadPeer};//< Message code

	inline TWorkerCleanupDeadPeerMsg(CommsFW::TWorkerId aWorkerId)

	: TWorkerMsg(KCode)

		{

		TParams* params = reinterpret_cast<TParams*>(ParamBlock());

		params->iWorkerId = aWorkerId;

		}

	inline CommsFW::TWorkerId WorkerId() const

		{

		const TParams* params = reinterpret_cast<const TParams*>(ParamBlock());

		return params->iWorkerId;

		}

private:

	struct TParams /** Message parameters */

		{

		CommsFW::TWorkerId iWorkerId;	//< Identifying which dead peer to cleanup

		};

	};

/**

class TWorkerCleanupDeadPeerRespMsg

@see TWorkerMsg::ECleanupDeadPeerResp

*/

class TWorkerCleanupDeadPeerRespMsg : public TWorkerMsg

	{

public:

	enum {KCode = TWorkerMsg::ECleanupDeadPeerResp};//< Message code

	inline TWorkerCleanupDeadPeerRespMsg(CommsFW::TWorkerId aWorkerId)

	: TWorkerMsg(KCode)

		{

		TParams* params = reinterpret_cast<TParams*>(ParamBlock());

		params->iWorkerId = aWorkerId;

		}

	inline CommsFW::TWorkerId WorkerId() const

		{

		const TParams* params = reinterpret_cast<const TParams*>(ParamBlock());

		return params->iWorkerId;

		}

private:

	struct TParams /** Message parameters */

		{

		CommsFW::TWorkerId iWorkerId;	//< Identifying which dead peer the cleanup was related to.

		};

	};

class TPlaneUnboundMsg : public TWorkerMsg

	{

public:

	enum {KCode = TWorkerMsg::EPlaneUnbound};//< Message code

	inline TPlaneUnboundMsg(TPlayerRole aPlayerRole)

	:	Den::TWorkerMsg(KCode)

		{

		TParams* params=reinterpret_cast<TParams*>(ParamBlock());

		params->iPlayerRole = aPlayerRole;

		}

	inline const TPlayerRole& PlayerRole() const

		{

		const TParams* params = reinterpret_cast<const TParams*>(ParamBlock());

		return params->iPlayerRole;

		}

private:

	struct TParams /** Message parameters */

		{

		TPlayerRole iPlayerRole;

		};

	};

/**

class TPlayerMsg

Messages from a Dealer to a Player in another thread

*/

class TPlayerMsg : public CommsFW::TCFMessage

	{

public:

	enum TCode

		{

		/** This is the most common message. It is used to forward IPC requests

		from a Dealer to a Player. */

		EForwardRequest = TWorkerMsg::ELastWorkerMsgCode + 1,

		/** When a session is closed by a client the Dealer will send this message to all Players

		that might have relations (sub-sessions) to this session.

		@note The receiver is expected to response with a ESessionCloseResp message.

		@see TPlayerMsg::ESessionCloseResp

		*/

		ESessionClose,

		/** Notify the Dealer that cleanup related to the ESessionClose message is completed.

		@see TPlayerMsg::ESessionClose

		*/

		ESessionCloseResp,

		};

	inline TPlayerMsg(TInt aCode)

		{

		Code(aCode);

		}

	};

/**

class TPlayerForwardRequestMsg

@see TPlayerMsg::EForwardRequest

*/

class TPlayerForwardRequestMsg : public TPlayerMsg

	{

public:

	enum {KCode = TPlayerMsg::EForwardRequest};//< Message code

	inline TPlayerForwardRequestMsg(const RMessage2& aMsg, CWorkerSubSession* aSubSession):TPlayerMsg(KCode)

		{

		TParams* params = reinterpret_cast<TParams*>(ParamBlock());

		params->iMsg.Adopt(static_cast<Den::RSafeMessage&>(const_cast<RMessage2&>(aMsg)));

		params->iSubSession=aSubSession;

		}

	/* Create requests have no meaningful subsession pointer (it gets created through the request) but can need

	to communicate additional status. This is carried through these magic subsession consts

	*/

	inline static CWorkerSubSession* UnusedParam()

		{

		return reinterpret_cast<CWorkerSubSession*>(NULL);

		}

	inline static CWorkerSubSession* NormalCreationFlag()

		{

		return reinterpret_cast<CWorkerSubSession*>(NULL);

		}

	inline static CWorkerSubSession* AbnormalCreationFlag()

		{

		return reinterpret_cast<CWorkerSubSession*>(-1);

		}

	inline const RSafeMessage& SafeMessage() const

		{

		const TParams* params = reinterpret_cast<const TParams*>(ParamBlock());

		return params->iMsg;

		}

	inline CWorkerSubSession* SubSession() const

		{

		const TParams* params = reinterpret_cast<const TParams*>(ParamBlock());

		return params->iSubSession;

		}

private:

	struct TParams /** Message parameters */

		{

		/** The IPC message to process. The Player must complete this itself when ready.

		When sent to a Player the Dealer will have forgotten completely about it and left

		the responsibility to the Player.

		*/

		RSafeMessage iMsg;

		CWorkerSubSession* iSubSession;

		};

	__ASSERT_COMPILE(sizeof(TParams) <= CommsFW::KCFMessageParamBlockSize);

	};

/**

class TPlayerSessionCloseMsg

@see TPlayerMsg::ESessionClose

*/

class TPlayerSessionCloseMsg : public TPlayerMsg

	{

public:

	enum {KCode = TPlayerMsg::ESessionClose};//< Message code

	inline TPlayerSessionCloseMsg(CWorkerSession* aSession):TPlayerMsg(KCode)

		{

		TParams* params = reinterpret_cast<TParams*>(ParamBlock());

		params->iSession=aSession;

		}

	inline CWorkerSession* Session() const

		{

		const TParams* params = reinterpret_cast<const TParams*>(ParamBlock());

		return params->iSession;

		}

private:

	struct TParams /** Message parameters */

		{

		CWorkerSession* iSession;			//< The session that is being closed.

		};

	};

/**

class TPlayerSessionCloseRespMsg

@see TPlayerMsg::ESessionCloseResp

*/

class TPlayerSessionCloseRespMsg : public TPlayerMsg

	{

public:

	enum {KCode = TPlayerMsg::ESessionCloseResp};//< Message code

	inline TPlayerSessionCloseRespMsg(CommsFW::TWorkerId aPlayerId, CWorkerSession* aSession)

	: TPlayerMsg(KCode)

		{

		TParams* params = reinterpret_cast<TParams*>(ParamBlock());

		params->iSession=aSession;

		params->iPlayerId=aPlayerId;

		}

	inline CWorkerSession* Session() const

		{

		const TParams* params = reinterpret_cast<const TParams*>(ParamBlock());

		return params->iSession;

		}

	inline const CommsFW::TWorkerId WorkerId() const

		{

		const TParams* params = reinterpret_cast<const TParams*>(ParamBlock());

		return params->iPlayerId;

		}

private:

	struct TParams /** Message parameters */

		{

		CWorkerSession* iSession;	//< The session which was closed

		CommsFW::TWorkerId iPlayerId;			//< Id of the sending worker thread

		};

	};

class TWorkerTransportMsg : public CommsFW::TCFMessage

	{

public:

	inline TWorkerTransportMsg(TInt aCode)

		{

		Code(aCode);

		TWorkerTransportParams* params = reinterpret_cast<TWorkerTransportParams*>(ParamBlock());

		params->iStatus = NULL;

		}

	inline TWorkerTransportMsg(TInt aCode, TRequestStatus& aStatus)

		{

		Code(aCode);

		TWorkerTransportParams* params = reinterpret_cast<TWorkerTransportParams*>(ParamBlock());

		params->iStatus = &aStatus;

		}

	inline TRequestStatus& Status() const

		{

		const TWorkerTransportParams* params = reinterpret_cast<const TWorkerTransportParams*>(ParamBlock());

		return *params->iStatus;

		}

	inline TRequestStatus* GetStatusPtr() const

		{

		const TWorkerTransportParams* params = reinterpret_cast<const TWorkerTransportParams*>(ParamBlock());

		return params->iStatus;

		}

	inline void SetStatusPtr(TRequestStatus* aStatus)

		{

		TWorkerTransportParams* params = reinterpret_cast<TWorkerTransportParams*>(ParamBlock());

		params->iStatus = aStatus;

		}

protected:

	struct TWorkerTransportParams /** Message parameters */

		{

		TRequestStatus* iStatus;	//< Pointer to request status to set when the request is complete.

		};

	};

} //namespace Den

#endif

//SYMBIAN_DEN_MSGS_H