diff -r 000000000000 -r dfb7c4ff071f datacommsserver/esockserver/inc/ss_nodemessages_legacy_internal.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/datacommsserver/esockserver/inc/ss_nodemessages_legacy_internal.h Thu Dec 17 09:22:25 2009 +0200 @@ -0,0 +1,585 @@ +// 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: +// Link CPR Node Messages +// +// + +/** + @file + @internalTechnology +*/ + +#ifndef SS_NODEMESSAGES_LEGACY_INTERNAL_INCLUDED +#define SS_NODEMESSAGES_LEGACY_INTERNAL_INCLUDED + +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +#include + +namespace ESock +{ + +//-========================================================= +// +//Extension messages +// +//-========================================================= + +class TCFLegacyMessageInternal + { +public: + enum EMessageTypeInternal //message signatures only (NOT messages) messages are declared under class TCFMessage + { + EGetOrSetParameters =200, + + ECprRetrieveProgress =201, + ECprRetrieveLastProgressError =202, + ECprRequestServiceNotification =203, + + ECprSendIoctl =204, + ECprAllSubConnectionNotificationEnable =205, + ECprEnumerateConnections =206, + + ELegacyDataMonitoringTransferredRequest = 207, + ELegacyDataMonitoringNotificationRequest = 208, + + ELegacySubConnectionActiveRequest = 209, + + ELegacyEnumerateSubConnections = 210, + + ELegacyControlMessage =211, + ELegacyConnEnumMessage =212, + + ESignatureRMessage2Response =213, + ELegacyGetSubConnectionInfo =214 + }; + }; +/** +A self-propagating extension message. It advances down the stack looking for +a MeshMachine::AMMNodeBase that implements MLinkCprExtensionApi. When found, the message +calls MLinkCprExtensionApi::ProgressL and completes the original request (see aMessage +in the c'tor). + +@internalComponent +*/ +class TCprRetrieveProgress : public TCFSigLegacyRMessage2Ext, + public Messages::TSignatureBase::TTypeToMessageId + { +public: + inline TCprRetrieveProgress() {}; + TCprRetrieveProgress(const Den::RSafeMessage& aMessage, Elements::TStateChange& aLastProgress) + : TCFSigLegacyRMessage2Ext(Messages::TNodeSignal::TMessageId(EId, ERealm), aMessage), iLastProgress(aLastProgress) + { + } + +protected: + virtual TBool CanProcess(MeshMachine::TNodeContextBase& aContext); + virtual void ForwardL(MeshMachine::TNodeContextBase& aContext); + virtual void ProcessL(MeshMachine::TNodeContextBase& aContext); + virtual TInt CheckError(MeshMachine::TNodeContextBase& aContext, TInt aError); + +public: + DECLARE_MVIP_CTR(TCprRetrieveProgress) +protected: + DATA_VTABLE + +private: + Elements::TStateChange iLastProgress; + }; + + +/** +A self-propagating extension message. It advances down the stack looking for +a MeshMachine::AMMNodeBase that implements MLinkCprExtensionApi. When found, the message +calls MLinkCprExtensionApi::LastProgressError and completes the original request (see +aMessage in the c'tor). + +@internalComponent +*/ +class TCprRetrieveLastProgressError : public TCFSigLegacyRMessage2Ext, + public Messages::TSignatureBase::TTypeToMessageId + { +public: + inline TCprRetrieveLastProgressError() {}; + TCprRetrieveLastProgressError(const Den::RSafeMessage& aMessage, Elements::TStateChange& aLastProgressError) + : TCFSigLegacyRMessage2Ext(Messages::TNodeSignal::TMessageId(EId, ERealm), aMessage), iLastProgressError(aLastProgressError) + { + } + +protected: + virtual TBool CanProcess(MeshMachine::TNodeContextBase& aContext); + virtual void ForwardL(MeshMachine::TNodeContextBase& aContext); + virtual void ProcessL(MeshMachine::TNodeContextBase& aContext); + virtual TInt CheckError(MeshMachine::TNodeContextBase& aContext, TInt aError); + +public: + DECLARE_MVIP_CTR(TCprRetrieveLastProgressError) +protected: + DATA_VTABLE + +private: + Elements::TStateChange iLastProgressError; + }; + + +/** +A self-propagating extension message. It advances down the stack looking for +a MeshMachine::AMMNodeBase that implements MLinkCprExtensionApi. When found, the message +calls MLinkCprExtensionApi::RequestServiceChangeNotificationL + +@internalComponent +*/ +class TCprRequestServiceNotification : public TCFSigLegacyRMessage2Ext, + public Messages::TSignatureBase::TTypeToMessageId + { +public: + TCprRequestServiceNotification(const Messages::TNodeId& aSender, const Den::RSafeMessage& aMessage) + : TCFSigLegacyRMessage2Ext(Messages::TNodeSignal::TMessageId(EId, ERealm), aMessage), iSender(aSender) + { + } + +protected: + virtual TBool CanProcess(MeshMachine::TNodeContextBase& aContext); + virtual void ForwardL(MeshMachine::TNodeContextBase& aContext); + virtual void ProcessL(MeshMachine::TNodeContextBase& aContext); + + virtual void Cancel(MeshMachine::TNodeContextBase& aContext); + +public: + DECLARE_MVIP_CTR(TCprRequestServiceNotification) + +protected: + inline TCprRequestServiceNotification() {}; + DATA_VTABLE + Messages::TNodeId iSender; + }; + +/** +A self-propagating extension message. It advances down the stack looking for +a MeshMachine::AMMNodeBase that implements MLinkCprExtensionApi. When found, the message +calls MLinkCprExtensionApi::SendIoctlMessageL and completes the original +request (see aMessage in the c'tor). + +@internalComponent +*/ +class TCprSendIoctl : public TCFSigLegacyRMessage2Ext, + public Messages::TSignatureBase::TTypeToMessageId + { +public: + inline TCprSendIoctl() {}; + TCprSendIoctl(const Den::RSafeMessage& aMessage) + : TCFSigLegacyRMessage2Ext(Messages::TNodeSignal::TMessageId(EId, ERealm), aMessage) + { + } + +protected: + virtual TBool CanProcess(MeshMachine::TNodeContextBase& aContext); + virtual void ForwardL(MeshMachine::TNodeContextBase& aContext); + virtual void ProcessL(MeshMachine::TNodeContextBase& aContext); + + virtual void Cancel(MeshMachine::TNodeContextBase& aContext); + +public: + DECLARE_MVIP_CTR(TCprSendIoctl) +protected: + DATA_VTABLE + }; + + +/** +A self-propagating extension message. It advances down the stack looking for +a MeshMachine::AMMNodeBase that implements MLinkCprExtensionApi. When found, the message +calls MLinkCprExtensionApi::AllSubConnectionNotificationEnable and completes the original +request (see aMessage in the c'tor). + +@internalComponent +*/ +class TCprAllSubConnectionNotificationEnable : public Messages::TSignalBase, public TCFClientItfExt + { +protected: + virtual void DispatchL(const Messages::TRuntimeCtxId& aSender, const Messages::TRuntimeCtxId& aRecipient); + virtual void Error(const Messages::TRuntimeCtxId& aSender, const Messages::TRuntimeCtxId& aRecipient, TInt aError); + +public: + DECLARE_MVIP_CTR(TCprAllSubConnectionNotificationEnable) +protected: + DATA_VTABLE + }; + + +/** +@internalComponent +*/ +class TCprFactEnumerateConnections : public TCFSigLegacyRMessage2Ext, + public Messages::TSignatureBase::TTypeToMessageId + { +public: + TCprFactEnumerateConnections() + { + } + + TCprFactEnumerateConnections(RPointerArray& aConnectionInfoPtrArray, const Den::RSafeMessage& aMessage) + :TCFSigLegacyRMessage2Ext(Messages::TNodeSignal::TMessageId(EId, ERealm), aMessage), iConnectionInfoPtrArray(&aConnectionInfoPtrArray) + { + } + +protected: + virtual TBool CanProcess(MeshMachine::TNodeContextBase& aContext); + virtual void ForwardL(MeshMachine::TNodeContextBase& aContext); + virtual void ProcessL(MeshMachine::TNodeContextBase& aContext); + +public: + DECLARE_MVIP_CTR(TCprFactEnumerateConnections) +protected: + DATA_VTABLE + RPointerArray* iConnectionInfoPtrArray; + }; + + +/** + * + * DATA MONITORING + * + */ + +/** + A self-propagating extension message. It advances down the stack looking for + a MeshMachine::AMMNodeBase that implements EDataMonitoringApiExt. + + @internalComponent +*/ +class TLegacyDataMonitoringTransferredRequest : public TCFSigLegacyRMessage2Ext, + public Messages::TSignatureBase::TTypeToMessageId + { +public: + TLegacyDataMonitoringTransferredRequest() : TCFSigLegacyRMessage2Ext() {} + + TLegacyDataMonitoringTransferredRequest(TSubSessionUniqueId aClientId, const Den::RSafeMessage& aMessage) + : TCFSigLegacyRMessage2Ext(Messages::TNodeSignal::TMessageId(EId, ERealm), aMessage), iClientId(aClientId) + { + } + +protected: + virtual TBool CanProcess(MeshMachine::TNodeContextBase& aContext); + virtual void ForwardL(MeshMachine::TNodeContextBase& aContext); + virtual void ProcessL(MeshMachine::TNodeContextBase& aContext); + + virtual void Cancel(MeshMachine::TNodeContextBase& aContext); + virtual TInt CheckError(MeshMachine::TNodeContextBase& aContext, TInt aError); + +private: + TBool HasServiceProviderL(const Messages::TRuntimeCtxId& aRecipient); + +public: + DECLARE_MVIP_CTR(TLegacyDataMonitoringTransferredRequest) + +protected: + DATA_VTABLE + + TSubSessionUniqueId iClientId; + }; + +class TLegacyDataMonitoringTransferredRequest; +class TLegacyDataMonitoringNotificationRequest; + +/** + IPC responder to support the legacy data monitoring APIs on RConnection. + + Inherits from CDataMonitoringResponder as there's shared code needed by the legacy and api ext versions + + @internalTechnology +*/ +class CLegacyDataMonitoringResponder : public CDataMonitoringResponder + { +friend class TLegacyDataMonitoringTransferredRequest; +friend class TLegacyDataMonitoringNotificationRequest; + +public: + virtual void DoCancelRequest(); + virtual void DoDataTransferred(TUint32 aReceivedBytes, TUint32 aSentBytes); + virtual void DoDataSentNotification(TUint32 aSentBytes); + virtual void DoDataReceivedNotification(TUint32 aReceivedBytes); + +private: + IMPORT_C static CLegacyDataMonitoringResponder* NewL(ESock::RLegacyResponseMsg& aResponseMsg); + CLegacyDataMonitoringResponder(ESock::RLegacyResponseMsg& aResponseMsg); + +private: + ESock::RLegacyResponseMsg iLegacyResponseMsg; + }; + +/** + A self-propagating extension message. It advances down the stack looking for + a MeshMachine::AMMNodeBase that implements EDataMonitoringApiExt. + + @internalComponent +*/ +class TLegacyDataMonitoringNotificationRequest : public TCFSigLegacyRMessage2Ext, + public Messages::TSignatureBase::TTypeToMessageId + { +public: + inline TLegacyDataMonitoringNotificationRequest() {}; + TLegacyDataMonitoringNotificationRequest(TDataMonitoringDirection aDirection, TSubSessionUniqueId aClientId, const Den::RSafeMessage& aMessage) + : TCFSigLegacyRMessage2Ext(Messages::TNodeSignal::TMessageId(EId, ERealm), aMessage), iDirection(aDirection), iClientId(aClientId) + { + } + +protected: + virtual TBool CanProcess(MeshMachine::TNodeContextBase& aContext); + virtual void ForwardL(MeshMachine::TNodeContextBase& aContext); + virtual void ProcessL(MeshMachine::TNodeContextBase& aContext); + + virtual void Cancel(MeshMachine::TNodeContextBase& aContext); + virtual TInt CheckError(MeshMachine::TNodeContextBase& aContext, TInt aError); + +public: + DECLARE_MVIP_CTR(TLegacyDataMonitoringNotificationRequest) + + TDataMonitoringDirection iDirection; + TSubSessionUniqueId iClientId; + +protected: + DATA_VTABLE + }; + +/** + A self-propagating extension message. It advances down the stack looking for + a MeshMachine::AMMNodeBase that implements xxx. + + @internalComponent +*/ +class TLegacyEnumerateSubConnections : public TCFSigLegacyRMessage2Ext, + public Messages::TSignatureBase::TTypeToMessageId + { +public: + TLegacyEnumerateSubConnections() + { + } + + TLegacyEnumerateSubConnections(const Den::RSafeMessage& aMessage) + : TCFSigLegacyRMessage2Ext(Messages::TNodeSignal::TMessageId(EId, ERealm), aMessage) + { + } + +protected: + virtual TBool CanProcess(MeshMachine::TNodeContextBase& aContext); + virtual void ForwardL(MeshMachine::TNodeContextBase& aContext); + virtual void ProcessL(MeshMachine::TNodeContextBase& aContext); + +public: + DECLARE_MVIP_CTR(TLegacyEnumerateSubConnections) + +protected: + DATA_VTABLE + }; + +/** +A self-propagating extension message. It advances down the stack looking for +a MeshMachine::AMMNodeBase that implements MLegacyControlExtApi and wants to handle the +requested control message. +@internalComponent +*/ +class TLegacyControlMessage : public TCFSigLegacyRMessage2PlatsecExt, + public Messages::TSignatureBase::TTypeToMessageId + { +public: + TLegacyControlMessage() + { + } + + TLegacyControlMessage(const Den::RSafeMessage& aMessage) + : TCFSigLegacyRMessage2PlatsecExt(Messages::TNodeSignal::TMessageId(EId, ERealm), aMessage) + { + } + +protected: + virtual TBool CanProcess(MeshMachine::TNodeContextBase& aContext); + virtual void ForwardL(MeshMachine::TNodeContextBase& aContext); + virtual void ProcessL(MeshMachine::TNodeContextBase& aContext); + +public: + DECLARE_MVIP_CTR(TLegacyControlMessage) + +protected: + DATA_VTABLE + }; + +/** Self-dispatching messages supporting the legacy enumeration of connection clients and sockets +*/ +NONSHARABLE_CLASS(TLegacyConnectionEnumRequest) : public Messages::TSignalBase + { +public: + TLegacyConnectionEnumRequest() + { + } + + TLegacyConnectionEnumRequest(RArray& aSCPRCandidates, TLegacyConnEnumClients aClientType); + +public: + DECLARE_MVIP_CTR(TLegacyConnectionEnumRequest) +protected: + DATA_VTABLE + + void DispatchL(const Messages::TRuntimeCtxId& aSender, const Messages::TRuntimeCtxId& aRecipient); + void Error(const Messages::TRuntimeCtxId& aSender, const Messages::TRuntimeCtxId& aRecipient, TInt aError); +public: + RArray* iSCPRCandidates; // owned by sender; data thread only references + TLegacyConnEnumClients iClientType; + }; + +/** + A self-propagating extension message. It advances down the stack looking for + a MeshMachine::AMMNodeBase that implements ELegacySubConnectionActiveApiExt. + + @internalComponent +*/ +NONSHARABLE_CLASS(TLegacySubConnectionActiveRequest) : public TCFSigLegacyRMessage2Ext, + public Messages::TSignatureBase::TTypeToMessageId + { +public: + inline TLegacySubConnectionActiveRequest() {}; + inline TLegacySubConnectionActiveRequest(TSubSessionUniqueId aClientId, const Den::RSafeMessage& aMessage) + : TCFSigLegacyRMessage2Ext(Messages::TNodeSignal::TMessageId(EId, ERealm), aMessage), iClientId(aClientId) + {} + +protected: + virtual TBool CanProcess(MeshMachine::TNodeContextBase& aContext); + virtual void ForwardL(MeshMachine::TNodeContextBase& aContext); + virtual void ProcessL(MeshMachine::TNodeContextBase& aContext); + virtual void Cancel(MeshMachine::TNodeContextBase& aContext); + +public: + DECLARE_MVIP_CTR(TLegacySubConnectionActiveRequest) + + TSubSessionUniqueId iClientId; +protected: + DATA_VTABLE + }; + +/** + A self-propagating extension message. It advances down the stack looking for + a MeshMachine::AMMNodeBase that implements ELegacySubConnectionInfoxt. + + @internalComponent +*/ +NONSHARABLE_CLASS(TLegacyGetSubConnectionInfo) : public TCFSigLegacyRMessage2Ext, + public Messages::TSignatureBase::TTypeToMessageId + { +public: + inline TLegacyGetSubConnectionInfo() {}; + inline TLegacyGetSubConnectionInfo(TSubSessionUniqueId aClientId, TSubConnectionInfo& aSubConnectionInfo, const Den::RSafeMessage& aMessage) + : TCFSigLegacyRMessage2Ext(Messages::TNodeSignal::TMessageId(EId, ERealm), aMessage), iClientId(aClientId), iSubConnectionInfo(aSubConnectionInfo) + {} + +protected: + virtual TBool CanProcess(MeshMachine::TNodeContextBase& aContext); + virtual void ForwardL(MeshMachine::TNodeContextBase& aContext); + virtual void ProcessL(MeshMachine::TNodeContextBase& aContext); + +public: + DECLARE_MVIP_CTR(TLegacyGetSubConnectionInfo) + + TSubSessionUniqueId iClientId; + TSubConnectionInfo iSubConnectionInfo; + +protected: + DATA_VTABLE + }; + + +class CClientRequest; +class ALegacySubConnectionActiveApiExt; + +/** +@internalComponent +*/ +NONSHARABLE_CLASS(CLegacySubConnectionActiveResponder) : public CCommsApiExtLegacyIpcResponder + { + friend class TLegacySubConnectionActiveRequest; + friend class ALegacySubConnectionActiveApiExt; + friend class CClientRequest; + +public: + static CLegacySubConnectionActiveResponder* NewL(ESock::RLegacyResponseMsg& aResponseMsg, TUint aTimerPeriod, TUint aClientId); + + inline TUint ClientId() + { + return iClientId; + } + + inline TInt TimerPeriod() + { + return iTimerPeriod; + } + + inline TBool ClientPerceivedState() + { + return iClientPerceivedState; + } + +protected: + CLegacySubConnectionActiveResponder(ESock::RLegacyResponseMsg& aResponseMsg, TUint aTimerPeriod, TUint aClientId) + : CCommsApiExtLegacyIpcResponder(aResponseMsg), iTimerPeriod(aTimerPeriod), iClientId(aClientId) + { + } + +private: + void SubConnectionActive(TBool aState); + void Error(TInt aError); + void Complete(TInt aError); + +private: + TBool iClientPerceivedState; + TInt iTimerPeriod; + TUint iClientId; + }; + + +/** + @internalComponent +*/ + +/** + @internalComponent +*/ +class CLegacyEnumerateSubConnectionsResponder : public CCommsApiExtLegacyIpcResponder + { + friend class TLegacyEnumerateSubConnections; + +public: + IMPORT_C static void CompleteClient(CLegacyEnumerateSubConnectionsResponder*& aThis, TInt aCount); + +protected: + CLegacyEnumerateSubConnectionsResponder(RLegacyResponseMsg& aResponseMsg) + : CCommsApiExtLegacyIpcResponder(aResponseMsg) + { + } + +private: + static CLegacyEnumerateSubConnectionsResponder* NewL(RLegacyResponseMsg& aResponseMsg); + }; + +}//namespace ESock + +#endif +