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 the License "Symbian Foundation License v1.0" |
|
5 // which accompanies this distribution, and is available |
|
6 // at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html". |
|
7 // |
|
8 // Initial Contributors: |
|
9 // Nokia Corporation - initial contribution. |
|
10 // |
|
11 // Contributors: |
|
12 // |
|
13 // Description: |
|
14 // |
|
15 |
|
16 /** |
|
17 @file |
|
18 @publishedPartner |
|
19 @released |
|
20 */ |
|
21 |
|
22 #ifndef SYMBIAN_NODEMESSAGES_SELECTOR_H |
|
23 #define SYMBIAN_NODEMESSAGES_SELECTOR_H |
|
24 |
|
25 #include <connpref.h> |
|
26 #include <comms-infras/metadata.h> |
|
27 #include <elements/nm_signatures.h> |
|
28 |
|
29 #include <comms-infras/ss_nodemessages.h> |
|
30 #include <comms-infras/cfmacro.h> |
|
31 #include <comms-infras/api_ext_msg.h> |
|
32 |
|
33 #include <es_enum.h> |
|
34 #include <comms-infras/ss_commsprov.h> |
|
35 #include <comms-infras/es_availability.h> |
|
36 |
|
37 namespace ConnStates |
|
38 { |
|
39 class TSelectMetaPlane; |
|
40 } |
|
41 |
|
42 class TConnProviderInfo; |
|
43 |
|
44 namespace ESock |
|
45 { |
|
46 |
|
47 /** |
|
48 TConnProviderInfo based preferences. Can be passed into RConnection::Start |
|
49 to specify what connection should be started. The handling of this preference |
|
50 is implementation specific. |
|
51 |
|
52 @publishedPartner |
|
53 @released |
|
54 */ |
|
55 |
|
56 class TConnProviderInfoPref : public TConnPref |
|
57 { |
|
58 public: |
|
59 IMPORT_C explicit TConnProviderInfoPref(const TConnProviderInfo& aProviderInfo); |
|
60 |
|
61 IMPORT_C const TConnProviderInfo& Info() const; |
|
62 }; |
|
63 |
|
64 /** |
|
65 Selection preferences object used internally by the 3 plane comms implementation. |
|
66 |
|
67 @publishedPartner |
|
68 @released |
|
69 */ |
|
70 class TSelectionPrefs : public Meta::SMetaData |
|
71 { |
|
72 public: |
|
73 /** |
|
74 Uid and TypeId for SMetaData |
|
75 */ |
|
76 enum {EUid = 0x10272C79, ETypeId = 1}; |
|
77 |
|
78 /** |
|
79 Scopes for which the selection can take place. |
|
80 |
|
81 Each of the flags may be set, alone, all or in any combinations |
|
82 */ |
|
83 enum TSelectionScope |
|
84 { |
|
85 /** |
|
86 For initialisation only |
|
87 */ |
|
88 ENone = 0x00, |
|
89 /** |
|
90 Select only from preexisting providers. Do not create new ones. |
|
91 */ |
|
92 ESelectFromExisting = 0x01, |
|
93 /** |
|
94 Select only the top provider. |
|
95 */ |
|
96 EExplicitConnection = 0x02, |
|
97 /** |
|
98 Do not request a comms binder. |
|
99 */ |
|
100 ERequestCommsBinder = 0x04 |
|
101 }; |
|
102 |
|
103 /** |
|
104 Flags to indicate what type of selection is taking place. |
|
105 */ |
|
106 enum TSelectionFlags |
|
107 { |
|
108 /** |
|
109 Selecting for a monitor access point. This access point does not affect the idleness |
|
110 of a node. |
|
111 */ |
|
112 EMonitor = 0x01, |
|
113 /** |
|
114 Selecting for an access point wishing to attach to a specified access point which |
|
115 already exists |
|
116 */ |
|
117 EAttach = 0x02 |
|
118 }; |
|
119 |
|
120 public: |
|
121 IMPORT_C TSelectionPrefs(); |
|
122 /** |
|
123 @param aSelectionScope Scope for which the selection will take place |
|
124 */ |
|
125 IMPORT_C TSelectionPrefs(TSelectionScope aSelectionScope); |
|
126 /** |
|
127 @param aPref Preferences used to decide which access point to select |
|
128 */ |
|
129 IMPORT_C TSelectionPrefs(const TConnPref& aPref); |
|
130 |
|
131 /** |
|
132 @param aPref Preferences used to decide which access point to select |
|
133 */ |
|
134 inline void SetPrefs(const TConnPref& aPref); |
|
135 |
|
136 /** |
|
137 @return Mutable connection preferences of this selection preference. |
|
138 */ |
|
139 inline TConnPref& Prefs(); |
|
140 |
|
141 /** |
|
142 @return Immutable connection preferences of this selection preference. |
|
143 */ |
|
144 inline const TConnPref& Prefs() const; |
|
145 |
|
146 /** |
|
147 @return ETrue if no preferences has been set in the selection preferences object |
|
148 */ |
|
149 inline TBool IsEmpty() const; |
|
150 |
|
151 /** |
|
152 @return the scope of the selection preferences |
|
153 */ |
|
154 inline TUint Scope() const; |
|
155 |
|
156 /** |
|
157 @param aScope a new scope for the selection preferences |
|
158 */ |
|
159 inline void SetScope(TUint aScope); |
|
160 |
|
161 /** |
|
162 @return The flags which have been set for the selection preferences |
|
163 */ |
|
164 inline TUint Flags() const; |
|
165 |
|
166 /** |
|
167 @param aFlags New flags for set for the selection preferences. Overwrites the old flags |
|
168 */ |
|
169 inline void SetFlags(TUint aFlags); |
|
170 |
|
171 /** |
|
172 @return The subsession unique id of the subsession which initiated this selection |
|
173 */ |
|
174 inline TSubSessionUniqueId SubSessionUniqueId() const; |
|
175 |
|
176 /** |
|
177 @param aSubSessionUniqueId The subsession unique id of the subsession initiated this selection |
|
178 */ |
|
179 inline void SetSubSessionUniqueId(TSubSessionUniqueId aSubSessionUniqueId); |
|
180 |
|
181 EXPORT_DATA_VTABLE_AND_FN |
|
182 |
|
183 private: |
|
184 TConnPref iPrefs; |
|
185 union |
|
186 { |
|
187 TUint iSelectionParams; //used by meta data offset |
|
188 struct //used by node |
|
189 { |
|
190 TUint iScope : 16; |
|
191 TUint iFlags : 16; |
|
192 } iS; |
|
193 } iU; |
|
194 TSubSessionUniqueId iSubSessionUniqueId; |
|
195 }; |
|
196 |
|
197 void TSelectionPrefs::SetPrefs(const TConnPref& aPref) |
|
198 { |
|
199 iPrefs = aPref; |
|
200 } |
|
201 |
|
202 TConnPref& TSelectionPrefs::Prefs() |
|
203 { |
|
204 return iPrefs; |
|
205 } |
|
206 |
|
207 const TConnPref& TSelectionPrefs::Prefs() const |
|
208 { |
|
209 return iPrefs; |
|
210 } |
|
211 |
|
212 TBool TSelectionPrefs::IsEmpty() const |
|
213 { |
|
214 return iPrefs.ExtensionId() == TConnPref::EConnPrefUnknown; |
|
215 } |
|
216 |
|
217 TUint TSelectionPrefs::Scope() const |
|
218 { |
|
219 return iU.iS.iScope; |
|
220 } |
|
221 |
|
222 void TSelectionPrefs::SetScope(TUint aScope) |
|
223 { |
|
224 iU.iS.iScope = aScope; |
|
225 } |
|
226 |
|
227 TUint TSelectionPrefs::Flags() const |
|
228 { |
|
229 return iU.iS.iFlags; |
|
230 } |
|
231 |
|
232 void TSelectionPrefs::SetFlags(TUint aFlags) |
|
233 { |
|
234 iU.iS.iFlags = aFlags; |
|
235 } |
|
236 |
|
237 TSubSessionUniqueId TSelectionPrefs::SubSessionUniqueId() const |
|
238 { |
|
239 return iSubSessionUniqueId; |
|
240 } |
|
241 |
|
242 void TSelectionPrefs::SetSubSessionUniqueId(TSubSessionUniqueId aSubSessionUniqueId) |
|
243 { |
|
244 iSubSessionUniqueId = aSubSessionUniqueId; |
|
245 } |
|
246 |
|
247 /** |
|
248 Selection preferences override. By default a mcpr will select using the selection prefs |
|
249 which were used to create it. The selection preferences override can be used to make them use |
|
250 something else. |
|
251 |
|
252 @publishedPartner |
|
253 @released |
|
254 */ |
|
255 class TOverridenSelectionPrefsExt : public Meta::SMetaData |
|
256 { |
|
257 public: |
|
258 enum {EUid = 0x10272C79, ETypeId = 2}; |
|
259 |
|
260 public: |
|
261 /** |
|
262 @param aTierId The tier on which the preferences will be used |
|
263 @param aPrefs The preferences which will override the default preferences |
|
264 */ |
|
265 IMPORT_C explicit TOverridenSelectionPrefsExt(TUid aTierId, const TSelectionPrefs& aPrefs); |
|
266 |
|
267 EXPORT_DATA_VTABLE_AND_FN |
|
268 |
|
269 TSelectionPrefs iPrefs; |
|
270 TUid iTierId; |
|
271 }; |
|
272 |
|
273 /** |
|
274 Panic catagory for RConnPrefList panics |
|
275 */ |
|
276 _LIT (RConnPrefListPanic,"RConnPrefListPanic"); |
|
277 |
|
278 /** |
|
279 Null element panic code. An attempt was made to access an element in the |
|
280 preferences list that didn't exist |
|
281 */ |
|
282 const TInt ENullElement = 1; |
|
283 |
|
284 /** |
|
285 This class will be used as a handle to TConnPrefList. During construction of |
|
286 the stack this class will be sent in messages as TConnPrefList cannot be sent |
|
287 in every message. The overhead of this would be too great (as it would have to |
|
288 be serialized and deserialized every time the message was sent). A reference |
|
289 cannot be sent as this would not work across processes. |
|
290 |
|
291 |
|
292 @publishedPartner |
|
293 @released |
|
294 */ |
|
295 class RConnPrefList |
|
296 { |
|
297 friend class ConnStates::TSelectMetaPlane; |
|
298 public: |
|
299 /** |
|
300 Base class for RConnPrefList iterators |
|
301 */ |
|
302 class TIterBase |
|
303 { |
|
304 protected: |
|
305 /** |
|
306 @param aConnPrefList Connection preference list to iterate over |
|
307 */ |
|
308 TIterBase(RConnPrefList &aConnPrefList) |
|
309 : iConnPrefList(aConnPrefList), iMasterIndex(0) |
|
310 { |
|
311 |
|
312 } |
|
313 |
|
314 /** |
|
315 @param aType Only return preferences of this type |
|
316 @param aIndex Index of preference requested |
|
317 @return The requested connection preference, or NULL if no preference of the specified type was found at aIndex |
|
318 */ |
|
319 IMPORT_C Meta::SMetaData* AtIndex(const Meta::STypeId& aType, TInt aIndex); |
|
320 |
|
321 protected: |
|
322 RConnPrefList& iConnPrefList; |
|
323 TInt iMasterIndex; |
|
324 }; |
|
325 |
|
326 template<class TYPE> |
|
327 /** |
|
328 This iterator will return objects of the templated class. It will only |
|
329 return objects from the list that are of the type passed in as the template parameter |
|
330 */ |
|
331 class TIter : public TIterBase |
|
332 { |
|
333 public: |
|
334 /** |
|
335 @param aConnPrefList Connection preferences to iterate over |
|
336 */ |
|
337 TIter(RConnPrefList &aConnPrefList) |
|
338 : TIterBase(aConnPrefList) |
|
339 { |
|
340 iIndex = 0; |
|
341 } |
|
342 |
|
343 /** |
|
344 This will return the instance of the given type in the list at the |
|
345 point specified by aIndex |
|
346 |
|
347 @param aIndex index of item to return |
|
348 @return The item found at the index, or NULL if not found |
|
349 */ |
|
350 TYPE* operator[](TInt aIndex) |
|
351 { |
|
352 return static_cast<TYPE*>(AtIndex(Meta::STypeId::CreateSTypeId(TYPE::EUid,TYPE::ETypeId) , aIndex)); |
|
353 } |
|
354 |
|
355 /** |
|
356 @return the next instance of the given tpye in the list or NULL if no more instances remain |
|
357 */ |
|
358 TYPE* operator++(TInt) |
|
359 { |
|
360 return static_cast<TYPE*>((*this)[iIndex++]); |
|
361 } |
|
362 |
|
363 /** |
|
364 @return a reference to the current object pointed to by the iterator |
|
365 */ |
|
366 TYPE& operator*() |
|
367 { |
|
368 TYPE* ptr = static_cast<TYPE*>(iConnPrefList[iMasterIndex]); |
|
369 __ASSERT_ALWAYS(ptr != NULL,User::Panic(RConnPrefListPanic, ENullElement)); |
|
370 return *ptr; |
|
371 } |
|
372 |
|
373 /** |
|
374 @return a pointer to the current object pointed to by the iterator |
|
375 */ |
|
376 TYPE* operator->() |
|
377 { |
|
378 TYPE* ptr = static_cast<TYPE*>(iConnPrefList[iMasterIndex]); |
|
379 return ptr; |
|
380 } |
|
381 |
|
382 /** |
|
383 @return ETrue if there are no more elements to iterate over. EFalse, otherwise |
|
384 */ |
|
385 TBool IsEnd() |
|
386 { |
|
387 if((*this)[iIndex] == NULL) |
|
388 { |
|
389 return ETrue; |
|
390 } |
|
391 else |
|
392 { |
|
393 return EFalse; |
|
394 } |
|
395 } |
|
396 |
|
397 /** |
|
398 Remove the current object from the iterators associated RConnPrefList |
|
399 @return a pointer to the removed object |
|
400 */ |
|
401 TYPE* Remove() |
|
402 { |
|
403 TYPE* ptr = static_cast<TYPE*>(iConnPrefList[iMasterIndex]); |
|
404 iConnPrefList.Remove(iMasterIndex); |
|
405 (*this)[iIndex]; |
|
406 return ptr; |
|
407 } |
|
408 |
|
409 private: |
|
410 TInt iIndex; |
|
411 }; |
|
412 |
|
413 public: |
|
414 IMPORT_C RConnPrefList(); |
|
415 |
|
416 /** |
|
417 Open and initialise with data from passed in RConnPrefList |
|
418 @param aPrefList RConnPrefList to copy data from. The copy is shallow. |
|
419 */ |
|
420 IMPORT_C void Open(RConnPrefList& aPrefList); |
|
421 |
|
422 /** |
|
423 Close the RConnPrefList object |
|
424 */ |
|
425 IMPORT_C void Close(); |
|
426 |
|
427 /** |
|
428 Create an iterator for template parameter TYPE. The iterator will be able to |
|
429 iterate over all the members of the RConnPrefList which match the type specified. |
|
430 @return A new iterator object for this connection preferences list |
|
431 */ |
|
432 template<class TYPE> |
|
433 RConnPrefList::TIter<TYPE> getIter() |
|
434 { |
|
435 return RConnPrefList::TIter<TYPE>(*this); |
|
436 } |
|
437 |
|
438 /** |
|
439 Append a preference to connection preferences list |
|
440 @param aFamily Preference to append |
|
441 @leave System wide error code. |
|
442 */ |
|
443 IMPORT_C void AppendL(SMetaDataECom* aFamily); |
|
444 |
|
445 /** |
|
446 @param aIndex index of requested object |
|
447 @return The object at aIndex |
|
448 */ |
|
449 IMPORT_C SMetaData* operator[](TInt aIndex); |
|
450 |
|
451 /** |
|
452 Remove an object from the RConnPrefList |
|
453 @param aIndex the index of the object to remove |
|
454 */ |
|
455 IMPORT_C void Remove(TInt aIndex); |
|
456 |
|
457 /** |
|
458 @return the number of preferences in the list |
|
459 */ |
|
460 IMPORT_C TInt Count(); |
|
461 |
|
462 private: |
|
463 TInt Open(TConnPrefList* aObject); |
|
464 TConnPrefList* iObject; |
|
465 }; |
|
466 |
|
467 |
|
468 /** |
|
469 Signature for a message which can carry selection preferences |
|
470 */ |
|
471 struct TSigSelectionPrefs : public Messages::TSignatureBase |
|
472 { |
|
473 protected: |
|
474 inline TSigSelectionPrefs() {} |
|
475 |
|
476 /** |
|
477 @param aMessageId Id of the message this signature is being created for. |
|
478 */ |
|
479 TSigSelectionPrefs(const Messages::TNodeSignal::TMessageId& aMessageId) |
|
480 : Messages::TSignatureBase(aMessageId) |
|
481 {} |
|
482 |
|
483 /** |
|
484 @param aMessageId Id of the message this signature is being created for. |
|
485 @param aSelectionPrefs Selection preferences object to be passed in the message |
|
486 */ |
|
487 TSigSelectionPrefs(const Messages::TNodeSignal::TMessageId& aMessageId, const Meta::SMetaData& aSelectionPrefs) |
|
488 : Messages::TSignatureBase(aMessageId) |
|
489 { |
|
490 //TODO: the copy can be optimised out when SMetaDataNetCtr handlers supported. |
|
491 iSelectionPrefs.Copy(aSelectionPrefs); |
|
492 } |
|
493 public: |
|
494 DECLARE_MVIP_CTR(TSigSelectionPrefs) |
|
495 EXPORT_DATA_VTABLE_AND_FN |
|
496 |
|
497 /** |
|
498 Selection preferences object passed in the message |
|
499 */ |
|
500 TSelectionPrefs iSelectionPrefs; |
|
501 }; |
|
502 |
|
503 /** |
|
504 Signature for a message which can carry a list of connection preferences |
|
505 */ |
|
506 struct TSigConnPrefList : public Messages::TSignatureBase |
|
507 { |
|
508 protected: |
|
509 inline TSigConnPrefList() {} |
|
510 |
|
511 /** |
|
512 @param aMessageId Id of the message this signature is being created for. |
|
513 */ |
|
514 TSigConnPrefList(const Messages::TNodeSignal::TMessageId& aMessageId) |
|
515 : Messages::TSignatureBase(aMessageId) |
|
516 {} |
|
517 |
|
518 /** |
|
519 @param aMessageId Id of the message this signature is being created for. |
|
520 @param aConnPrefList List of connection preferences to be passed in this message |
|
521 */ |
|
522 TSigConnPrefList(const Messages::TNodeSignal::TMessageId& aMessageId, RConnPrefList& aConnPrefList) |
|
523 : Messages::TSignatureBase(aMessageId) |
|
524 { |
|
525 iConnPrefList = aConnPrefList; |
|
526 } |
|
527 public: |
|
528 DECLARE_MVIP_CTR(TSigConnPrefList) |
|
529 EXPORT_DATA_VTABLE_AND_FN |
|
530 |
|
531 /** |
|
532 List of connection preferences passed in this message |
|
533 */ |
|
534 RConnPrefList iConnPrefList; |
|
535 }; |
|
536 |
|
537 |
|
538 /** |
|
539 Message signature template for a message which can carry selection preferences |
|
540 |
|
541 @see TSigSelectionPrefs |
|
542 */ |
|
543 template<TInt id, TInt32 realm> |
|
544 struct TMessageSigSelectionPrefs : public TSigSelectionPrefs, public Messages::TSignatureBase::TTypeToMessageId<id, realm> |
|
545 { |
|
546 explicit TMessageSigSelectionPrefs() : |
|
547 TSigSelectionPrefs(Messages::TNodeSignal::TMessageId(id, realm)) |
|
548 { } |
|
549 |
|
550 explicit TMessageSigSelectionPrefs(const Meta::SMetaData& aSelectionPrefs) |
|
551 : TSigSelectionPrefs(Messages::TNodeSignal::TMessageId(id, realm), aSelectionPrefs) |
|
552 { |
|
553 } |
|
554 }; |
|
555 |
|
556 /** |
|
557 Message signature template for a message which can carry a list of connection preferences |
|
558 |
|
559 @see TSigConnPrefList |
|
560 */ |
|
561 template<TInt id, TInt32 realm> |
|
562 struct TMessageSigConnPrefList : public TSigConnPrefList, public Messages::TSignatureBase::TTypeToMessageId<id, realm> |
|
563 { |
|
564 explicit TMessageSigConnPrefList() |
|
565 : TSigConnPrefList(Messages::TNodeSignal::TMessageId(id, realm)) |
|
566 {} |
|
567 |
|
568 explicit TMessageSigConnPrefList(RConnPrefList& aCustomPrefs) |
|
569 : TSigConnPrefList(Messages::TNodeSignal::TMessageId(id, realm), aCustomPrefs) |
|
570 {} |
|
571 }; |
|
572 |
|
573 /** |
|
574 Signature for a select complete message. |
|
575 */ |
|
576 struct TSigSelectComplete : public Messages::TSignatureBase |
|
577 { |
|
578 protected: |
|
579 inline TSigSelectComplete() {} |
|
580 |
|
581 /** |
|
582 @param aMessageId Id of the message this signature is being created for. |
|
583 @param aNodeId Node id of node which has been created |
|
584 @param aProviderInfo Provider info of access point which has been created. |
|
585 */ |
|
586 TSigSelectComplete(const Messages::TNodeSignal::TMessageId& aMessageId, const Messages::TNodeId& aNodeId, const TProviderInfo& aProviderInfo) |
|
587 : Messages::TSignatureBase(aMessageId), |
|
588 iNodeId(aNodeId), |
|
589 iProviderInfo(aProviderInfo) |
|
590 { |
|
591 } |
|
592 public: |
|
593 DECLARE_MVIP_CTR(TSigSelectComplete) |
|
594 EXPORT_DATA_VTABLE_AND_FN |
|
595 /** |
|
596 Node id of node which has been created |
|
597 */ |
|
598 Messages::TNodeId iNodeId; |
|
599 /** |
|
600 Provider info of the access point which has been created |
|
601 */ |
|
602 TProviderInfo iProviderInfo; |
|
603 }; |
|
604 |
|
605 /** |
|
606 Message signature template for a select complete message |
|
607 |
|
608 @see TSigSelectComplete |
|
609 */ |
|
610 template<TInt id, TInt32 realm> |
|
611 struct TMessageSigSelectComplete : public TSigSelectComplete, public Messages::TSignatureBase::TTypeToMessageId<id, realm> |
|
612 { |
|
613 explicit TMessageSigSelectComplete(const Messages::TNodeId& aNodeId, const TProviderInfo aProviderInfo) |
|
614 : TSigSelectComplete(Messages::TNodeSignal::TMessageId(id, realm), aNodeId, aProviderInfo) |
|
615 { |
|
616 } |
|
617 }; |
|
618 |
|
619 /** |
|
620 Message signature template for availability subscription message |
|
621 */ |
|
622 DECLARE_MESSAGE_SIG_1(SigAvailabilitySubscriptionOptions, TAvailabilitySubscriptionOptions, AvailabilitySubscriptionOptions) |
|
623 /** |
|
624 Message signature for availability status message |
|
625 */ |
|
626 DECLARE_MESSAGE_SIG_1(SigAvailabilityStatus, TAvailabilityStatus, AvailabilityStatus) |
|
627 |
|
628 /** |
|
629 Message interface for selector nodes |
|
630 Nodes wishing to implement this interface must implement all message protocols in the interface. |
|
631 |
|
632 @publishedPartner |
|
633 @released |
|
634 */ |
|
635 class TCFSelector |
|
636 { |
|
637 private: |
|
638 enum |
|
639 { |
|
640 ECFSimpleSelect = 1, |
|
641 ECFSelect = 2, |
|
642 ECFSelectComplete = 3 |
|
643 }; |
|
644 |
|
645 public: |
|
646 enum { ERealmId = 0x10285F4E }; //UID allocated on 4/6/08 from KUidNodeMessageRealms |
|
647 |
|
648 /** |
|
649 Selection request sent to TierManagers (usually by MCPRs). Can only carry one type of selection preferences at a time, and for this |
|
650 reason, using TSelect is preferred. It should be noted however, that multiple nodes may be returned in exchange for this single |
|
651 preference, for example in the case of SNAP preferences. |
|
652 |
|
653 This request is completed only after TSelectComplete with a NULL address has been received by the requestor. |
|
654 |
|
655 @li Type: Request |
|
656 @li Fallible: Yes |
|
657 |
|
658 @param iSelectionPrefs preferences used by the selection process to choose nodes |
|
659 */ |
|
660 typedef TMessageSigSelectionPrefs<ECFSimpleSelect, TCFSelector::ERealmId> TSimpleSelect; |
|
661 |
|
662 |
|
663 /** |
|
664 Selection request sent to Tier Managers (usually by MCPRs or CSR). Carries an RConnPrefList instance, the objects in the list are used |
|
665 during the construction of the stack. Multiple nodes may be returned by the selection activity. This request is completed only after |
|
666 TSelectComplete with a NULL address has been received by the requestor. |
|
667 |
|
668 @li Type: Request |
|
669 @li Fallible: Yes |
|
670 |
|
671 @param aConnPrefList an instance of RConnPrefList |
|
672 */ |
|
673 typedef TMessageSigConnPrefList<ECFSelect, TCFSelector::ERealmId> TSelect; |
|
674 |
|
675 /** |
|
676 Response to TSelect or TSelectNextLayer. Carries address to selected providers (MCPRs). A selection request is completed only after |
|
677 TSelectComplete with a NULL address has been received by the requestor. This response also carries some additional information about |
|
678 the selected provider. |
|
679 |
|
680 @li Type: Response to TSimpleSelect or TSelect |
|
681 @li Fallible: No |
|
682 |
|
683 @param iNodeId node id of the node which has been selected |
|
684 @param iProviderInfo additional information about the created node |
|
685 */ |
|
686 typedef TMessageSigSelectComplete<ECFSelectComplete, TCFSelector::ERealmId> TSelectComplete; |
|
687 }; |
|
688 |
|
689 } //namespace esock |
|
690 |
|
691 #endif |
|
692 //SYMBIAN_NODEMESSAGES_SELECTOR_H |
|
693 |
|