1 // Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // Link CPR Node Messages

    15 // 

    16 //

    17 

    18 /**

    19  @file

    20  @internalTechnology

    21 */

    22 

    23 #ifndef SS_NODEMESSAGES_LEGACY_INTERNAL_INCLUDED

    24 #define SS_NODEMESSAGES_LEGACY_INTERNAL_INCLUDED

    25 

    26 #include <comms-infras/ss_nodeinterfaces.h>

    27 #include <comms-infras/ss_dispatchers.h>

    28 #include <elements/responsemsg.h>

    29 #include <es_enum.h>

    30 

    31 #include <comms-infras/api_ext_list.h>

    32 #include <comms-infras/ss_platsec_apiext.h>

    33 #include <comms-infras/ss_datamon_apiext.h>

    34 #include <comms-infras/ss_datamonitoringprovider.h>

    35 #include <comms-infras/ss_nodemessages_legacy.h>

    36 

    37 #include <comms-infras/ss_legacyinterfaces.h>

    38 

    39 namespace ESock

    40 {

    41 

    42 //-=========================================================

    43 //

    44 //Extension messages

    45 //

    46 //-=========================================================

    47 

    48 class TCFLegacyMessageInternal

    49 	{

    50 public:

    51 	enum EMessageTypeInternal //message signatures only (NOT messages) messages are declared under class TCFMessage

    52 		{

    53 		EGetOrSetParameters				=200,

    54 

    55 		ECprRetrieveProgress			=201, 

    56 		ECprRetrieveLastProgressError	=202,

    57 		ECprRequestServiceNotification	=203,

    58 		

    59 		ECprSendIoctl					=204,

    60 		ECprAllSubConnectionNotificationEnable		=205,

    61 		ECprEnumerateConnections		=206,

    62 		

    63 		ELegacyDataMonitoringTransferredRequest		= 207,

    64 		ELegacyDataMonitoringNotificationRequest	= 208,

    65 		

    66 		ELegacySubConnectionActiveRequest			= 209,

    67 		

    68 		ELegacyEnumerateSubConnections				= 210,

    69 		

    70 		ELegacyControlMessage           =211,

    71 		ELegacyConnEnumMessage          =212,

    72 		

    73 		ESignatureRMessage2Response     =213,

    74 		ELegacyGetSubConnectionInfo     =214

    75 		};

    76 	};

    77 /**

    78 A self-propagating extension message. It advances down the stack looking for

    79 a MeshMachine::AMMNodeBase that implements MLinkCprExtensionApi. When found, the message

    80 calls MLinkCprExtensionApi::ProgressL and completes the original request (see aMessage

    81 in the c'tor).

    82 

    83 @internalComponent

    84 */

    85 class TCprRetrieveProgress : public TCFSigLegacyRMessage2Ext,

    86 							 public Messages::TSignatureBase::TTypeToMessageId<TCFLegacyMessageInternal::ECprRetrieveProgress, TCFLegacyMessage::ERealmId>

    87     {

    88 public:

    89     inline TCprRetrieveProgress() {};

    90 	TCprRetrieveProgress(const Den::RSafeMessage& aMessage, Elements::TStateChange& aLastProgress)

    91         : TCFSigLegacyRMessage2Ext(Messages::TNodeSignal::TMessageId(EId, ERealm), aMessage), iLastProgress(aLastProgress)

    92         {

    93         }

    94 

    95 protected:

    96 	virtual TBool CanProcess(MeshMachine::TNodeContextBase& aContext);

    97     virtual void ForwardL(MeshMachine::TNodeContextBase& aContext);

    98     virtual void ProcessL(MeshMachine::TNodeContextBase& aContext);

    99 	virtual TInt CheckError(MeshMachine::TNodeContextBase& aContext, TInt aError);

   100 

   101 public:

   102     DECLARE_MVIP_CTR(TCprRetrieveProgress)

   103 protected:

   104     DATA_VTABLE

   105 

   106 private:

   107     Elements::TStateChange iLastProgress;

   108     };

   109 

   110 

   111 /**

   112 A self-propagating extension message. It advances down the stack looking for

   113 a MeshMachine::AMMNodeBase that implements MLinkCprExtensionApi. When found, the message

   114 calls MLinkCprExtensionApi::LastProgressError and completes the original request (see

   115 aMessage in the c'tor).

   116 

   117 @internalComponent

   118 */

   119 class TCprRetrieveLastProgressError : public TCFSigLegacyRMessage2Ext,

   120 									  public Messages::TSignatureBase::TTypeToMessageId<TCFLegacyMessageInternal::ECprRetrieveLastProgressError, TCFLegacyMessage::ERealmId>

   121     {

   122 public:

   123     inline TCprRetrieveLastProgressError() {};

   124 	TCprRetrieveLastProgressError(const Den::RSafeMessage& aMessage, Elements::TStateChange& aLastProgressError)

   125         : TCFSigLegacyRMessage2Ext(Messages::TNodeSignal::TMessageId(EId, ERealm), aMessage), iLastProgressError(aLastProgressError)

   126         {

   127         }

   128 

   129 protected:

   130 	virtual TBool CanProcess(MeshMachine::TNodeContextBase& aContext);

   131     virtual void ForwardL(MeshMachine::TNodeContextBase& aContext);

   132     virtual void ProcessL(MeshMachine::TNodeContextBase& aContext);

   133 	virtual TInt CheckError(MeshMachine::TNodeContextBase& aContext, TInt aError);

   134 

   135 public:

   136     DECLARE_MVIP_CTR(TCprRetrieveLastProgressError)

   137 protected:

   138     DATA_VTABLE

   139 

   140 private:

   141     Elements::TStateChange iLastProgressError;

   142     };

   143 

   144 

   145 /**

   146 A self-propagating extension message. It advances down the stack looking for

   147 a MeshMachine::AMMNodeBase that implements MLinkCprExtensionApi. When found, the message

   148 calls MLinkCprExtensionApi::RequestServiceChangeNotificationL

   149 

   150 @internalComponent

   151 */

   152 class TCprRequestServiceNotification : public TCFSigLegacyRMessage2Ext,

   153 									   public Messages::TSignatureBase::TTypeToMessageId<TCFLegacyMessageInternal::ECprRequestServiceNotification, TCFLegacyMessage::ERealmId>

   154     {

   155 public:

   156 	TCprRequestServiceNotification(const Messages::TNodeId& aSender, const Den::RSafeMessage& aMessage)

   157 		:	TCFSigLegacyRMessage2Ext(Messages::TNodeSignal::TMessageId(EId, ERealm), aMessage), iSender(aSender)

   158 		{

   159 		}

   160 

   161 protected:

   162 	virtual TBool CanProcess(MeshMachine::TNodeContextBase& aContext);

   163     virtual void ForwardL(MeshMachine::TNodeContextBase& aContext);

   164     virtual void ProcessL(MeshMachine::TNodeContextBase& aContext);

   165 

   166 	virtual void Cancel(MeshMachine::TNodeContextBase& aContext);

   167 

   168 public:

   169     DECLARE_MVIP_CTR(TCprRequestServiceNotification)

   170 

   171 protected:

   172 	inline TCprRequestServiceNotification() {};

   173     DATA_VTABLE

   174 	Messages::TNodeId iSender;

   175     };

   176 

   177 /**

   178 A self-propagating extension message. It advances down the stack looking for

   179 a MeshMachine::AMMNodeBase that implements MLinkCprExtensionApi. When found, the message

   180 calls MLinkCprExtensionApi::SendIoctlMessageL and completes the original

   181 request (see aMessage in the c'tor).

   182 

   183 @internalComponent

   184 */

   185 class TCprSendIoctl : public TCFSigLegacyRMessage2Ext,

   186 					  public Messages::TSignatureBase::TTypeToMessageId<TCFLegacyMessageInternal::ECprSendIoctl, TCFLegacyMessage::ERealmId>

   187     {

   188 public:

   189     inline TCprSendIoctl() {};

   190 	TCprSendIoctl(const Den::RSafeMessage& aMessage)

   191         : TCFSigLegacyRMessage2Ext(Messages::TNodeSignal::TMessageId(EId, ERealm), aMessage)

   192         {

   193         }

   194 

   195 protected:

   196 	virtual TBool CanProcess(MeshMachine::TNodeContextBase& aContext);

   197     virtual void ForwardL(MeshMachine::TNodeContextBase& aContext);

   198     virtual void ProcessL(MeshMachine::TNodeContextBase& aContext);

   199 

   200 	virtual void Cancel(MeshMachine::TNodeContextBase& aContext);

   201 

   202 public:

   203     DECLARE_MVIP_CTR(TCprSendIoctl)

   204 protected:

   205     DATA_VTABLE

   206     };

   207 

   208 

   209 /**

   210 A self-propagating extension message. It advances down the stack looking for

   211 a MeshMachine::AMMNodeBase that implements MLinkCprExtensionApi. When found, the message

   212 calls MLinkCprExtensionApi::AllSubConnectionNotificationEnable and completes the original

   213 request (see aMessage in the c'tor).

   214 

   215 @internalComponent

   216 */

   217 class TCprAllSubConnectionNotificationEnable : public Messages::TSignalBase, public TCFClientItfExt<TCFClientType::ECtrl>

   218     {

   219 protected:

   220 	virtual void DispatchL(const Messages::TRuntimeCtxId& aSender, const Messages::TRuntimeCtxId& aRecipient);

   221 	virtual void Error(const Messages::TRuntimeCtxId& aSender, const Messages::TRuntimeCtxId& aRecipient, TInt aError);

   222 

   223 public:

   224     DECLARE_MVIP_CTR(TCprAllSubConnectionNotificationEnable)

   225 protected:

   226     DATA_VTABLE

   227     };

   228 

   229 

   230 /**

   231 @internalComponent

   232 */

   233 class TCprFactEnumerateConnections : public TCFSigLegacyRMessage2Ext,

   234 									 public Messages::TSignatureBase::TTypeToMessageId<TCFLegacyMessageInternal::ECprEnumerateConnections, TCFLegacyMessage::ERealmId>

   235     {

   236 public:

   237     TCprFactEnumerateConnections()

   238         {

   239         }

   240 

   241 	TCprFactEnumerateConnections(RPointerArray<TSourcedConnectionInfo>& aConnectionInfoPtrArray, const Den::RSafeMessage& aMessage)

   242         :TCFSigLegacyRMessage2Ext(Messages::TNodeSignal::TMessageId(EId, ERealm), aMessage), iConnectionInfoPtrArray(&aConnectionInfoPtrArray)

   243         {

   244         }

   245 

   246 protected:

   247 	virtual TBool CanProcess(MeshMachine::TNodeContextBase& aContext);

   248     virtual void ForwardL(MeshMachine::TNodeContextBase& aContext);

   249     virtual void ProcessL(MeshMachine::TNodeContextBase& aContext);

   250 

   251 public:

   252     DECLARE_MVIP_CTR(TCprFactEnumerateConnections)

   253 protected:

   254     DATA_VTABLE

   255 	RPointerArray<TSourcedConnectionInfo>* iConnectionInfoPtrArray;

   256     };

   257 

   258 

   259 /**

   260  *

   261  *  DATA MONITORING

   262  *

   263  */

   264 

   265 /**

   266 	A self-propagating extension message. It advances down the stack looking for

   267 	a MeshMachine::AMMNodeBase that implements EDataMonitoringApiExt.

   268 

   269 	@internalComponent

   270 */

   271 class TLegacyDataMonitoringTransferredRequest : public TCFSigLegacyRMessage2Ext,

   272 												public Messages::TSignatureBase::TTypeToMessageId<TCFLegacyMessageInternal::ELegacyDataMonitoringTransferredRequest, TCFLegacyMessage::ERealmId>

   273     {

   274 public:

   275 	TLegacyDataMonitoringTransferredRequest() : TCFSigLegacyRMessage2Ext() {}

   276 												

   277 	TLegacyDataMonitoringTransferredRequest(TSubSessionUniqueId aClientId, const Den::RSafeMessage& aMessage)

   278         : TCFSigLegacyRMessage2Ext(Messages::TNodeSignal::TMessageId(EId, ERealm), aMessage), iClientId(aClientId)

   279         {

   280         }

   281 

   282 protected:

   283 	virtual TBool CanProcess(MeshMachine::TNodeContextBase& aContext);

   284     virtual void ForwardL(MeshMachine::TNodeContextBase& aContext);

   285     virtual void ProcessL(MeshMachine::TNodeContextBase& aContext);

   286 

   287 	virtual void Cancel(MeshMachine::TNodeContextBase& aContext);

   288 	virtual TInt CheckError(MeshMachine::TNodeContextBase& aContext, TInt aError);

   289 

   290 private:

   291 	TBool HasServiceProviderL(const Messages::TRuntimeCtxId& aRecipient);

   292 

   293 public:

   294     DECLARE_MVIP_CTR(TLegacyDataMonitoringTransferredRequest)

   295 

   296 protected:

   297     DATA_VTABLE

   298 

   299     TSubSessionUniqueId iClientId;

   300     };

   301 

   302 class TLegacyDataMonitoringTransferredRequest;

   303 class TLegacyDataMonitoringNotificationRequest;	

   304 	

   305 /**

   306 	IPC responder to support the legacy data monitoring APIs on RConnection.

   307 

   308 	Inherits from CDataMonitoringResponder as there's shared code needed by the legacy and api ext versions

   309 

   310 	@internalTechnology

   311 */

   312 class CLegacyDataMonitoringResponder : public CDataMonitoringResponder

   313 	{

   314 friend class TLegacyDataMonitoringTransferredRequest;

   315 friend class TLegacyDataMonitoringNotificationRequest;

   316 

   317 public:

   318 	virtual void DoCancelRequest();

   319 	virtual void DoDataTransferred(TUint32 aReceivedBytes, TUint32 aSentBytes);

   320 	virtual void DoDataSentNotification(TUint32 aSentBytes);

   321 	virtual void DoDataReceivedNotification(TUint32 aReceivedBytes);

   322 

   323 private:

   324 	IMPORT_C static CLegacyDataMonitoringResponder* NewL(ESock::RLegacyResponseMsg& aResponseMsg);

   325 	CLegacyDataMonitoringResponder(ESock::RLegacyResponseMsg& aResponseMsg);

   326 

   327 private:

   328 	ESock::RLegacyResponseMsg iLegacyResponseMsg;

   329 	};

   330 

   331 /**

   332 	A self-propagating extension message. It advances down the stack looking for

   333 	a MeshMachine::AMMNodeBase that implements EDataMonitoringApiExt.

   334 

   335 	@internalComponent

   336 */

   337 class TLegacyDataMonitoringNotificationRequest : public TCFSigLegacyRMessage2Ext,

   338 												 public Messages::TSignatureBase::TTypeToMessageId<TCFLegacyMessageInternal::ELegacyDataMonitoringNotificationRequest, TCFLegacyMessage::ERealmId>

   339     {

   340 public:

   341     inline TLegacyDataMonitoringNotificationRequest() {};

   342     TLegacyDataMonitoringNotificationRequest(TDataMonitoringDirection aDirection, TSubSessionUniqueId aClientId, const Den::RSafeMessage& aMessage)

   343         : TCFSigLegacyRMessage2Ext(Messages::TNodeSignal::TMessageId(EId, ERealm), aMessage), iDirection(aDirection), iClientId(aClientId)

   344         {

   345         }

   346 

   347 protected:

   348 	virtual TBool CanProcess(MeshMachine::TNodeContextBase& aContext);

   349     virtual void ForwardL(MeshMachine::TNodeContextBase& aContext);

   350     virtual void ProcessL(MeshMachine::TNodeContextBase& aContext);

   351 

   352 	virtual void Cancel(MeshMachine::TNodeContextBase& aContext);

   353 	virtual TInt CheckError(MeshMachine::TNodeContextBase& aContext, TInt aError);

   354 

   355 public:

   356     DECLARE_MVIP_CTR(TLegacyDataMonitoringNotificationRequest)

   357 

   358 	TDataMonitoringDirection iDirection;

   359     TSubSessionUniqueId iClientId;

   360 

   361 protected:

   362     DATA_VTABLE

   363     };

   364 

   365 /**

   366 	A self-propagating extension message. It advances down the stack looking for

   367 	a MeshMachine::AMMNodeBase that implements xxx.

   368 

   369 	@internalComponent

   370 */

   371 class TLegacyEnumerateSubConnections : public TCFSigLegacyRMessage2Ext,

   372 									   public Messages::TSignatureBase::TTypeToMessageId<TCFLegacyMessageInternal::ELegacyEnumerateSubConnections, TCFLegacyMessage::ERealmId>

   373     {

   374 public:

   375     TLegacyEnumerateSubConnections()

   376         {

   377         }

   378 

   379 	TLegacyEnumerateSubConnections(const Den::RSafeMessage& aMessage)

   380         : TCFSigLegacyRMessage2Ext(Messages::TNodeSignal::TMessageId(EId, ERealm), aMessage)

   381         {

   382         }

   383 

   384 protected:

   385 	virtual TBool CanProcess(MeshMachine::TNodeContextBase& aContext);

   386     virtual void ForwardL(MeshMachine::TNodeContextBase& aContext);

   387     virtual void ProcessL(MeshMachine::TNodeContextBase& aContext);

   388 

   389 public:

   390     DECLARE_MVIP_CTR(TLegacyEnumerateSubConnections)

   391 

   392 protected:

   393     DATA_VTABLE

   394     };

   395 

   396 /**

   397 A self-propagating extension message. It advances down the stack looking for

   398 a MeshMachine::AMMNodeBase that implements MLegacyControlExtApi and wants to handle the

   399 requested control message.

   400 @internalComponent

   401 */

   402 class TLegacyControlMessage : public TCFSigLegacyRMessage2PlatsecExt,

   403 							  public Messages::TSignatureBase::TTypeToMessageId<TCFLegacyMessageInternal::ELegacyControlMessage, TCFLegacyMessage::ERealmId>

   404     {

   405 public:

   406     TLegacyControlMessage()

   407         {

   408         }

   409 

   410 	TLegacyControlMessage(const Den::RSafeMessage& aMessage)

   411         : TCFSigLegacyRMessage2PlatsecExt(Messages::TNodeSignal::TMessageId(EId, ERealm), aMessage)

   412         {

   413         }

   414 

   415 protected:

   416 	virtual TBool CanProcess(MeshMachine::TNodeContextBase& aContext);

   417     virtual void ForwardL(MeshMachine::TNodeContextBase& aContext);

   418     virtual void ProcessL(MeshMachine::TNodeContextBase& aContext);

   419 	

   420 public:

   421     DECLARE_MVIP_CTR(TLegacyControlMessage)

   422 

   423 protected:

   424     DATA_VTABLE

   425     };

   426 

   427 /** Self-dispatching messages supporting the legacy enumeration of connection clients and sockets

   428 */

   429 NONSHARABLE_CLASS(TLegacyConnectionEnumRequest) : public Messages::TSignalBase

   430 	{

   431 public:

   432 	TLegacyConnectionEnumRequest()

   433 		{

   434 		}

   435 

   436     TLegacyConnectionEnumRequest(RArray<Messages::TNodeId>& aSCPRCandidates, TLegacyConnEnumClients aClientType);

   437 

   438 public:

   439     DECLARE_MVIP_CTR(TLegacyConnectionEnumRequest)

   440 protected:

   441     DATA_VTABLE

   442 

   443 	void DispatchL(const Messages::TRuntimeCtxId& aSender, const Messages::TRuntimeCtxId& aRecipient);

   444 	void Error(const Messages::TRuntimeCtxId& aSender, const Messages::TRuntimeCtxId& aRecipient, TInt aError);

   445 public:

   446 	RArray<Messages::TNodeId>* iSCPRCandidates;	// owned by sender; data thread only references

   447 	TLegacyConnEnumClients iClientType;

   448 	};

   449 

   450 /**

   451 	A self-propagating extension message. It advances down the stack looking for

   452 	a MeshMachine::AMMNodeBase that implements ELegacySubConnectionActiveApiExt.

   453 

   454 	@internalComponent

   455 */

   456 NONSHARABLE_CLASS(TLegacySubConnectionActiveRequest) : public TCFSigLegacyRMessage2Ext,

   457 													   public Messages::TSignatureBase::TTypeToMessageId<TCFLegacyMessageInternal::ELegacySubConnectionActiveRequest, TCFLegacyMessage::ERealmId>

   458     {

   459 public:

   460     inline TLegacySubConnectionActiveRequest() {};

   461 	inline TLegacySubConnectionActiveRequest(TSubSessionUniqueId aClientId, const Den::RSafeMessage& aMessage)

   462 		: TCFSigLegacyRMessage2Ext(Messages::TNodeSignal::TMessageId(EId, ERealm), aMessage), iClientId(aClientId)

   463 		{}

   464 

   465 protected:

   466 	virtual TBool CanProcess(MeshMachine::TNodeContextBase& aContext);

   467     virtual void ForwardL(MeshMachine::TNodeContextBase& aContext);

   468     virtual void ProcessL(MeshMachine::TNodeContextBase& aContext);

   469 	virtual void Cancel(MeshMachine::TNodeContextBase& aContext);

   470 

   471 public:

   472     DECLARE_MVIP_CTR(TLegacySubConnectionActiveRequest)

   473 

   474 	TSubSessionUniqueId iClientId;

   475 protected:

   476     DATA_VTABLE

   477     };

   478 

   479 /**

   480 	A self-propagating extension message. It advances down the stack looking for

   481 	a MeshMachine::AMMNodeBase that implements ELegacySubConnectionInfoxt.

   482 

   483 	@internalComponent

   484 */

   485 NONSHARABLE_CLASS(TLegacyGetSubConnectionInfo) : public TCFSigLegacyRMessage2Ext,

   486 												 public Messages::TSignatureBase::TTypeToMessageId<TCFLegacyMessageInternal::ELegacyGetSubConnectionInfo, TCFLegacyMessage::ERealmId>

   487     {

   488 public:

   489     inline TLegacyGetSubConnectionInfo() {};

   490 	inline TLegacyGetSubConnectionInfo(TSubSessionUniqueId aClientId, TSubConnectionInfo& aSubConnectionInfo, const Den::RSafeMessage& aMessage)

   491 		: TCFSigLegacyRMessage2Ext(Messages::TNodeSignal::TMessageId(EId, ERealm), aMessage), iClientId(aClientId), iSubConnectionInfo(aSubConnectionInfo)

   492 		{}

   493 

   494 protected:

   495 	virtual TBool CanProcess(MeshMachine::TNodeContextBase& aContext);

   496     virtual void ForwardL(MeshMachine::TNodeContextBase& aContext);

   497     virtual void ProcessL(MeshMachine::TNodeContextBase& aContext);

   498 

   499 public:

   500     DECLARE_MVIP_CTR(TLegacyGetSubConnectionInfo)

   501 

   502 	TSubSessionUniqueId iClientId;

   503 	TSubConnectionInfo iSubConnectionInfo;

   504 	

   505 protected:

   506     DATA_VTABLE

   507     };

   508 

   509 

   510 class CClientRequest;

   511 class ALegacySubConnectionActiveApiExt;

   512 

   513 /**

   514 @internalComponent

   515 */

   516 NONSHARABLE_CLASS(CLegacySubConnectionActiveResponder) : public CCommsApiExtLegacyIpcResponder

   517 	{

   518 	friend class TLegacySubConnectionActiveRequest;

   519 	friend class ALegacySubConnectionActiveApiExt;

   520 	friend class CClientRequest;

   521 

   522 public:

   523 	static CLegacySubConnectionActiveResponder* NewL(ESock::RLegacyResponseMsg& aResponseMsg, TUint aTimerPeriod, TUint aClientId);

   524 

   525 	inline TUint ClientId()

   526 		{

   527 		return iClientId;

   528 		}

   529 

   530 	inline TInt TimerPeriod()

   531 		{

   532 		return iTimerPeriod;

   533 		}

   534 

   535 	inline TBool ClientPerceivedState()

   536 		{

   537 		return iClientPerceivedState;

   538 		}

   539 	

   540 protected:

   541 	CLegacySubConnectionActiveResponder(ESock::RLegacyResponseMsg& aResponseMsg, TUint aTimerPeriod, TUint aClientId)

   542 		: CCommsApiExtLegacyIpcResponder(aResponseMsg), iTimerPeriod(aTimerPeriod), iClientId(aClientId)

   543 		{

   544 		}

   545 

   546 private:

   547 	void SubConnectionActive(TBool aState);

   548 	void Error(TInt aError);

   549 	void Complete(TInt aError); 

   550 	

   551 private:

   552 	TBool iClientPerceivedState;

   553 	TInt iTimerPeriod;

   554 	TUint iClientId;

   555 	};

   556 

   557 

   558 /**

   559 	@internalComponent

   560 */

   561 

   562 /**

   563 	@internalComponent

   564 */

   565 class CLegacyEnumerateSubConnectionsResponder : public CCommsApiExtLegacyIpcResponder

   566 	{

   567 	friend class TLegacyEnumerateSubConnections;

   568 

   569 public:

   570 	IMPORT_C static void CompleteClient(CLegacyEnumerateSubConnectionsResponder*& aThis, TInt aCount);

   571 

   572 protected:

   573 	CLegacyEnumerateSubConnectionsResponder(RLegacyResponseMsg& aResponseMsg)

   574 		: CCommsApiExtLegacyIpcResponder(aResponseMsg)

   575 		{

   576 		}

   577 

   578 private:

   579 	static CLegacyEnumerateSubConnectionsResponder* NewL(RLegacyResponseMsg& aResponseMsg);

   580 	};

   581 

   582 }//namespace ESock

   583 

   584 #endif

   585