--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/serialserver/c32serialserver/INC/cs_msgs.h Thu Dec 17 09:22:25 2009 +0200
@@ -0,0 +1,506 @@
+// Copyright (c) 2005-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 CS_MSGS_H
+#define CS_MSGS_H
+
+#include <cfmsgs.h>
+#include <elements/cftransport.h>
+#include <cfshared.h>
+#include <cfutil.h>
+
+
+
+/** Messages from Main Thread to Worker Threads (with Resp messages being responses
+sent back from Worker)
+*/
+class TC32WorkerMsg : public CommsFW::TCFMessage
+ {
+public:
+ enum
+ {
+ /** Number of messages reserved for C32 internal usage. Currently bigger than the actual
+ number of messages to provide space for more in the future since player msgs being after this block.
+ The number is fairly arbitrary and is a guess at being "big enough" to accomodate a
+ reasonable multiplicity of future messages given we only use a couple at the moment.
+ @see TC32WorkerMsg::TCode::ELasTC32WorkerMsgCode
+ */
+ KC32MessageCodeReserveSize = 15
+ };
+ enum TCode {
+
+ /** This is the first message between worker thread and the main thread. It is sent from
+ the main thread when receiving a bind request and starts the initialisation sequence.
+ The receiver is expected to respond with a EMainIntroductionResp message.
+ @see TC32WorkerMsg::EMainIntroductionResp
+ */
+ EMainIntroduction = CommsFW::TCFCommsMessage::ECodePrivateFlag,
+
+ /** This is sent from a worker to the main thread in response to the
+ introduction message from the main thread. Once received the main thread will notify
+ the Root Server that the binding is complete.
+ @see TC32WorkerMsg::EMainIntroduction
+ */
+ EMainIntroductionResp,
+
+ /** Dummy trailer code to give reference point for starting a following sequence of message codes. */
+ ELasTC32WorkerMsgCode = CommsFW::TCFCommsMessage::ECodePrivateFlag + KC32MessageCodeReserveSize
+ };
+ inline TC32WorkerMsg(TInt aCode)
+ {
+ Code(aCode);
+ }
+ };
+
+class CC32Dealer;
+
+/**
+@class
+TC32WorkerMainIntroductionMsg
+@see TC32WorkerMsg::EMainIntroduction
+*/
+class TC32WorkerMainIntroductionMsg : public TC32WorkerMsg
+ {
+public:
+ enum {KCode = EMainIntroduction};//< Message code
+ inline TC32WorkerMainIntroductionMsg(CC32Dealer* aDealer)
+ : TC32WorkerMsg(KCode)
+ {
+ TParams* params = reinterpret_cast<TParams*>(TCFMessage::ParamBlock());
+ params->iDealer=aDealer;
+ }
+ inline CC32Dealer* Dealer() const
+ {
+ const TParams* params = reinterpret_cast<const TParams*>(TCFMessage::ParamBlock());
+ return params->iDealer;
+ }
+private:
+ struct TParams
+ {
+ CC32Dealer* iDealer; //< The Dealer
+ };
+ };
+
+/**
+@class
+TC32WorkerMainIntroductionRespMsg
+@see TC32WorkerMsg::EMainIntroductionResp
+*/
+class TC32WorkerMainIntroductionRespMsg : public TC32WorkerMsg
+ {
+public:
+ enum {KCode = TC32WorkerMsg::EMainIntroductionResp};//< Message code
+ inline TC32WorkerMainIntroductionRespMsg(const TC32WorkerThreadPublicInfo& aWorkerInfo)
+ : TC32WorkerMsg(KCode)
+ {
+ TParams* params=reinterpret_cast<TParams*>(TCFMessage::ParamBlock());
+ params->iWorkerInfo=aWorkerInfo;
+#ifdef _DEBUG
+ params->iFailType = RAllocator::ENone;
+ params->iFailRate = 0;
+#endif
+ }
+
+ inline const TC32WorkerThreadPublicInfo& WorkerInfo() const
+ {
+ const TParams* params = reinterpret_cast<const TParams*>(TCFMessage::ParamBlock());
+ return params->iWorkerInfo;
+ }
+#ifdef _DEBUG
+ inline void SetFailType(RAllocator::TAllocFail aFailType)
+ {
+ TParams* params = reinterpret_cast<TParams*>(TCFMessage::ParamBlock());
+ params->iFailType = aFailType;
+ }
+ inline RAllocator::TAllocFail FailType() const
+ {
+ const TParams* params = reinterpret_cast<const TParams*>(TCFMessage::ParamBlock());
+ return params->iFailType;
+ }
+ inline void SetFailRate(TInt aFailRate)
+ {
+ TParams* params = reinterpret_cast<TParams*>(TCFMessage::ParamBlock());
+ params->iFailRate = aFailRate;
+ }
+ inline TInt FailRate() const
+ {
+ const TParams* params = reinterpret_cast<const TParams*>(TCFMessage::ParamBlock());
+ return params->iFailRate;
+ }
+#endif
+
+private:
+ struct TParams
+ {
+ TC32WorkerThreadPublicInfo iWorkerInfo; //< Crucial information the Dealer needs about the worker thread/server
+#ifdef _DEBUG
+ RAllocator::TAllocFail iFailType;
+ TInt iFailRate;
+#endif
+ };
+ };
+
+
+
+
+/**
+@class
+TC32PlayerMsg
+Messages from a Dealer to a Player in another thread
+*/
+class TC32PlayerMsg : 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 = TC32WorkerMsg::ELasTC32WorkerMsgCode + 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 TC32PlayerMsg::ESessionCloseResp
+ */
+ ESessionClose,
+
+ /** Notify the Dealer that cleanup related to the ESessionClose message is completed.
+ @see TC32PlayerMsg::ESessionClose
+ */
+ ESessionCloseResp,
+
+ /** This message is sent from dealer to player on load request. Response message is sent from
+ player back.
+ @see TC32PlayerMsg::ELoadCommModuleSuccessResp
+ @see TC32PlayerMsg::ELoadCommModuleFailureResp
+ */
+ ELoadCommModuleMsg,
+
+ /** This message is sent from the player to dealer in response to ELoadCommModuleMsg
+ msg. On success, CSerial* with RMessage2 is sent to dealer. CSerial* is used by dealer to
+ update the ThreadManager entry of PortPrefix, while csyfilename is retrieved from message again.
+ After updation, the message is completed by dealer
+ */
+ ELoadCommModuleSuccessResp,
+
+ /** This message is sent from player to dealer when CSY load fails. The load failure
+ result is also sent with the message which the dealer completes the message with.
+ */
+ ELoadCommModuleFailureResp,
+
+ /**
+ Message sent from deale to player to unload Comm Module
+ */
+ EUnLoadCommModuleMsg,
+ /**
+ This is the message used specifically for RCommServ::GetPortInfo (aIndex) API as
+ global index which is sent via aMessage is no longer valid in player, which maintains
+ its local index.
+ */
+ EGetPortInfoMsg,
+ };
+ inline TC32PlayerMsg(TInt aCode)
+ {
+ Code(aCode);
+ }
+ };
+
+/**
+@class
+TC32PlayerForwardRequestMsg
+@see TC32PlayerMsg::EForwardRequest
+*/
+class TC32PlayerForwardRequestMsg : public TC32PlayerMsg
+ {
+public:
+ enum {KCode = TC32PlayerMsg::EForwardRequest};//< Message code
+ inline TC32PlayerForwardRequestMsg(const RMessage2& aMsg, CCommSubSession* aSubSession):TC32PlayerMsg(KCode)
+ {
+ TParams* params = reinterpret_cast<TParams*>(TCFMessage::ParamBlock());
+ params->iMsg=aMsg;
+ params->iSubSession=aSubSession;
+ }
+ inline const RMessage2& Message() const
+ {
+ const TParams* params = reinterpret_cast<const TParams*>(TCFMessage::ParamBlock());
+ return params->iMsg;
+ }
+ inline CCommSubSession* SubSession() const
+ {
+ const TParams* params = reinterpret_cast<const TParams*>(TCFMessage::ParamBlock());
+ return params->iSubSession;
+ }
+private:
+ struct TParams
+ {
+ /** 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.
+ */
+ RMessage2 iMsg;
+ CCommSubSession* iSubSession;
+ };
+ };
+
+/**
+@class
+TC32PlayerSessionCloseMsg
+@see TC32PlayerMsg::ESessionClose
+*/
+class TC32PlayerSessionCloseMsg : public TC32PlayerMsg
+ {
+public:
+ enum {KCode = TC32PlayerMsg::ESessionClose};//< Message code
+ inline TC32PlayerSessionCloseMsg(CCommSession* aSession, const TInt64& aSessionCloseDeadline):TC32PlayerMsg(KCode)
+ {
+ TParams* params = reinterpret_cast<TParams*>(TCFMessage::ParamBlock());
+ params->iSession=aSession;
+ params->iSessionCloseDeadline=aSessionCloseDeadline;
+ }
+
+ inline CCommSession* Session() const
+ {
+ const TParams* params = reinterpret_cast<const TParams*>(TCFMessage::ParamBlock());
+ return params->iSession;
+ }
+ inline TInt64 SessionCloseDeadline() const
+ {
+ const TParams* params = reinterpret_cast<const TParams*>(TCFMessage::ParamBlock());
+ return params->iSessionCloseDeadline;
+ }
+private:
+ struct TParams
+ {
+ CCommSession* iSession; //< The session that is being closed.
+
+ /** The session pointer is only valid if TTime.HomeTime() returns a value smaller than
+ the value stored here, otherwise the Dealer will have timed out and deleted the session. */
+ TInt64 iSessionCloseDeadline;
+ };
+ };
+
+/**
+@class
+TC32PlayerSessionCloseRespMsg
+@see TC32PlayerMsg::ESessionCloseResp
+*/
+class TC32PlayerSessionCloseRespMsg : public TC32PlayerMsg
+ {
+public:
+ enum {KCode = TC32PlayerMsg::ESessionCloseResp};//< Message code
+ inline TC32PlayerSessionCloseRespMsg(CommsFW::TWorkerId aPlayerId, const TC32PlayerSessionCloseMsg& aCloseMsg):TC32PlayerMsg(KCode)
+ {
+ TParams* params = reinterpret_cast<TParams*>(TCFMessage::ParamBlock());
+ params->iSession=aCloseMsg.Session();
+ params->iPlayerId=aPlayerId;
+ params->iSessionCloseDeadline=aCloseMsg.SessionCloseDeadline();
+ }
+ inline CCommSession* Session() const
+ {
+ const TParams* params = reinterpret_cast<const TParams*>(TCFMessage::ParamBlock());
+ return params->iSession;
+ }
+ inline CommsFW::TWorkerId WorkerId() const
+ {
+ const TParams* params = reinterpret_cast<const TParams*>(TCFMessage::ParamBlock());
+ return params->iPlayerId;
+ }
+ inline TInt64 SessionCloseDeadline() const
+ {
+ const TParams* params = reinterpret_cast<const TParams*>(TCFMessage::ParamBlock());
+ return params->iSessionCloseDeadline;
+ }
+private:
+ struct TParams
+ {
+ CCommSession* iSession; //< The session which was closed
+ CommsFW::TWorkerId iPlayerId; //< Id of the sending worker thread
+
+ /** Must contain the session close deadline from the session close
+ message which this message is responding to. */
+ TInt64 iSessionCloseDeadline;
+ };
+ };
+
+/**
+@class
+TC32PlayerLoadCommModuleMsg
+@see TC32PlayerMsg::ELoadCommModuleMsg
+*/
+class TC32PlayerLoadCommModuleMsg : public TC32PlayerMsg
+ {
+public:
+ enum {KCode = TC32PlayerMsg::ELoadCommModuleMsg};//< Message code
+ inline TC32PlayerLoadCommModuleMsg(const RMessage2& aMsg):TC32PlayerMsg(KCode)
+ {
+ TParams* params = reinterpret_cast<TParams*>(TCFMessage::ParamBlock());
+ params->iMsg=aMsg;
+ }
+ inline const RMessage2& Message() const
+ {
+ const TParams* params = reinterpret_cast<const TParams*>(TCFMessage::ParamBlock());
+ return params->iMsg;
+ }
+private:
+ struct TParams
+ {
+ /** 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.
+ */
+ RMessage2 iMsg;
+ };
+ };
+
+/**
+@class
+TC32PlayerLoadCommModuleSuccessResp
+@see TC32PlayerMsg::ELoadCommModuleSuccessResp
+*/
+class TC32PlayerLoadCommModuleSuccessResp : public TC32PlayerMsg
+ {
+public:
+ enum {KCode = TC32PlayerMsg::ELoadCommModuleSuccessResp};//< Message code
+ inline TC32PlayerLoadCommModuleSuccessResp(const RMessage2& aMsg, CSerial* aSerial):TC32PlayerMsg(KCode)
+ {
+ TParams* params = reinterpret_cast<TParams*>(TCFMessage::ParamBlock());
+ params->iMsg=aMsg;
+ params->iSerial=aSerial;
+ }
+ inline const RMessage2& Message() const
+ {
+ const TParams* params = reinterpret_cast<const TParams*>(TCFMessage::ParamBlock());
+ return params->iMsg;
+ }
+ inline CSerial* SerialPtr() const
+ {
+ const TParams* params = reinterpret_cast<const TParams*>(TCFMessage::ParamBlock());
+ return params->iSerial;
+ }
+private:
+ struct TParams
+ {
+ /** 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.
+ */
+ RMessage2 iMsg;
+ CSerial* iSerial; //< used in PortInfo(aIndex)
+ };
+ };
+
+
+/**
+@class
+TC32PlayerLoadCommModuleMsg
+@see TC32PlayerMsg::ELoadCommModuleFailureResp
+*/
+class TC32PlayerLoadCommModuleFailureResp : public TC32PlayerMsg
+ {
+public:
+ enum {KCode = TC32PlayerMsg::ELoadCommModuleFailureResp};//< Message code
+ inline TC32PlayerLoadCommModuleFailureResp(const RMessage2& aMsg, TInt aFailReason):TC32PlayerMsg(KCode)
+ {
+ TParams* params = reinterpret_cast<TParams*>(TCFMessage::ParamBlock());
+ params->iMsg=aMsg;
+ params->iFailReason=aFailReason;
+ }
+ inline const RMessage2& Message() const
+ {
+ const TParams* params = reinterpret_cast<const TParams*>(TCFMessage::ParamBlock());
+ return params->iMsg;
+ }
+ inline TInt FailureReason() const
+ {
+ const TParams* params = reinterpret_cast<const TParams*>(TCFMessage::ParamBlock());
+ return params->iFailReason;
+ }
+private:
+ struct TParams
+ {
+ RMessage2 iMsg;
+ TInt iFailReason;
+ };
+ };
+/*
+@class
+TC32PlayerUnLoadCommModuleMsg
+@see TC32PlayerMsg::EUnLoadCommModuleMsg
+*/
+class TC32PlayerUnLoadCommModuleMsg : public TC32PlayerMsg
+ {
+public:
+ enum {KCode = TC32PlayerMsg::EUnLoadCommModuleMsg};//< Message code
+ inline TC32PlayerUnLoadCommModuleMsg(CSerial* aSerial):TC32PlayerMsg(KCode)
+ {
+ TParams* params = reinterpret_cast<TParams*>(TCFMessage::ParamBlock());
+ params->iSerial=aSerial;
+ }
+ inline CSerial* SerialPtr() const
+ {
+ const TParams* params = reinterpret_cast<const TParams*>(TCFMessage::ParamBlock());
+ return params->iSerial;
+ }
+private:
+ struct TParams
+ {
+ CSerial* iSerial; //< CSerial to call Close()
+ };
+ };
+
+
+/**
+@class
+TC32PlayerGetPortInfoMsg
+@see TC32PlayerMsg::EGetPortInfoMsg
+*/
+class TC32PlayerGetPortInfoMsg : public TC32PlayerMsg
+ {
+public:
+ enum {KCode = TC32PlayerMsg::EGetPortInfoMsg};//< Message code
+ inline TC32PlayerGetPortInfoMsg(const RMessage2& aMsg, CSerial* aSerial):TC32PlayerMsg(KCode)
+ {
+ TParams* params = reinterpret_cast<TParams*>(TCFMessage::ParamBlock());
+ params->iMsg=aMsg;
+ params->iSerial=aSerial;
+ }
+ inline const RMessage2& Message() const
+ {
+ const TParams* params = reinterpret_cast<const TParams*>(TCFMessage::ParamBlock());
+ return params->iMsg;
+ }
+ inline CSerial* SerialPtr() const
+ {
+ const TParams* params = reinterpret_cast<const TParams*>(TCFMessage::ParamBlock());
+ return params->iSerial;
+ }
+private:
+ struct TParams
+ {
+ /** 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.
+ */
+ RMessage2 iMsg;
+ CSerial* iSerial;
+ };
+ };
+
+#endif // CS_MSGS_H
+