|
1 /* |
|
2 * Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies). |
|
3 * All rights reserved. |
|
4 * This component and the accompanying materials are made available |
|
5 * under the terms of "Eclipse Public License v1.0" |
|
6 * which accompanies this distribution, and is available |
|
7 * at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
8 * |
|
9 * Initial Contributors: |
|
10 * Nokia Corporation - initial contribution. |
|
11 * |
|
12 * Contributors: |
|
13 * |
|
14 * Description: S60 MCPR activities implementation |
|
15 * |
|
16 */ |
|
17 |
|
18 /** |
|
19 @file s60mcpractivities.cpp |
|
20 S60 MCPR activities implementation |
|
21 */ |
|
22 |
|
23 #include "s60mcpractivities.h" |
|
24 |
|
25 using namespace Messages; |
|
26 using namespace MeshMachine; |
|
27 using namespace ESock; |
|
28 using namespace MCprActivities; |
|
29 |
|
30 // ----------------------------------------------------------------------------- |
|
31 // S60MCprSelectActivity |
|
32 // ----------------------------------------------------------------------------- |
|
33 // |
|
34 namespace S60MCprSelectActivity |
|
35 { |
|
36 namespace Simple = S60MCprSimpleSelectActivity; |
|
37 |
|
38 DECLARE_DEFINE_CUSTOM_NODEACTIVITY( ECFActivitySelect, |
|
39 S60MCprSelect, |
|
40 TCFSelector::TSelect, |
|
41 CSelectNextLayerActivity::NewL ) |
|
42 |
|
43 // Reply from TAwaitingSelectNextLayer if no choices, otherwise accept |
|
44 FIRST_NODEACTIVITY_ENTRY( TAwaitingSelectNextLayer, |
|
45 Simple::TChooseBestIAPRequiredOrNoTagOrSetChosenApActive ) |
|
46 |
|
47 // Execute ChooseBestIAPL() to MPM to resolve the most preferred IAP. |
|
48 NODEACTIVITY_ENTRY( S60MCprStates::KChooseBestIAPRequired, |
|
49 Simple::TChooseBestIAP, |
|
50 Simple::TAwaitingChooseBestIAP, |
|
51 MeshMachine::TNoTag ) |
|
52 |
|
53 // ChooseBestIAP done or not required |
|
54 THROUGH_NODEACTIVITY_ENTRY( KNoTag, |
|
55 MeshMachine::TDoNothing, |
|
56 MCprStates::TSelectedProvider ) |
|
57 |
|
58 // Start the selection main loop |
|
59 NODEACTIVITY_ENTRY( MCprStates::KSelectedProvider, |
|
60 CSelectNextLayerActivity::TFindOrCreateTierManager, |
|
61 MCprStates::TAwaitingTierManagerCreated, |
|
62 MeshMachine::TNoTag ) |
|
63 |
|
64 // Join the newly created tier manager |
|
65 NODEACTIVITY_ENTRY( KNoTag, |
|
66 CSelectNextLayerActivity::TJoinTierManager, |
|
67 CoreStates::TAwaitingJoinComplete, |
|
68 MeshMachine::TNoTag ) |
|
69 |
|
70 // Select next provider and enter the selection internal loop if provider received. Break if SelectComplete(NULL). |
|
71 // Then post the selection list to TM. |
|
72 NODEACTIVITY_ENTRY( KNoTag, |
|
73 TSelectNextLayer, |
|
74 MCprStates::TAwaitingSelectComplete, |
|
75 CSelectNextLayerActivity::TNoTagOrSelectedProviderIsNull ) |
|
76 |
|
77 // Add provider info |
|
78 NODEACTIVITY_ENTRY( KNoTag, |
|
79 CSelectNextLayerActivity::TAddProviderInfo, |
|
80 MCprStates::TAwaitingSelectComplete, |
|
81 CSelectNextLayerActivity::TNoTagBackwardsOrJoinServiceProvider ) |
|
82 |
|
83 // Break the selection internal loop if SelectComplete(NULL), otherwise stay in this tripple |
|
84 NODEACTIVITY_ENTRY( MCprStates::KJoinServiceProvider, |
|
85 CSelectNextLayerActivity::TJoinServiceProvider, |
|
86 CoreStates::TAwaitingJoinComplete, |
|
87 MeshMachine::TNoTag ) |
|
88 |
|
89 // Send select complete |
|
90 THROUGH_NODEACTIVITY_ENTRY( KNoTag, |
|
91 CSelectNextLayerActivity::TSendSelectComplete, |
|
92 CSelectNextLayerActivity::TSelectedProviderIsNullOrJoinServiceProviderBackward ) |
|
93 |
|
94 // Break the selection main loop if no more choices, otherwise go back again |
|
95 THROUGH_NODEACTIVITY_ENTRY( MCprStates::KSelectedProviderIsNull, |
|
96 CSelectNextLayerActivity::TLeaveTierManager, |
|
97 Simple::TSetChosenApActiveOrSelectedProviderBackward ) |
|
98 |
|
99 // Set Selected Node Active |
|
100 THROUGH_NODEACTIVITY_ENTRY( S60MCprStates::KSetChosenApActive, |
|
101 Simple::TSetChosenApActive, |
|
102 MeshMachine::TNoTag ) |
|
103 |
|
104 // Finish the activity |
|
105 LAST_NODEACTIVITY_ENTRY( KNoTag, |
|
106 MCprStates::TSendFinalSelectComplete ) |
|
107 |
|
108 NODEACTIVITY_END() |
|
109 } |
|
110 |
|
111 // ----------------------------------------------------------------------------- |
|
112 // S60MCprSimpleSelectActivity |
|
113 // ----------------------------------------------------------------------------- |
|
114 // |
|
115 namespace S60MCprSimpleSelectActivity |
|
116 { |
|
117 DECLARE_DEFINE_CUSTOM_NODEACTIVITY( ECFActivitySelect, |
|
118 MCprSimpleSelect, |
|
119 TCFSelector::TSimpleSelect, |
|
120 CSelectNextLayerActivity::NewL ) |
|
121 // Reply from TAwaitingSelectNextLayer if no choices, otherwise accept |
|
122 FIRST_NODEACTIVITY_ENTRY( S60MCprSimpleSelectActivity::TAwaitingSelectNextLayer, |
|
123 S60MCprSimpleSelectActivity::TChooseBestIAPRequiredOrNoTagOrSetChosenApActive ) |
|
124 // Execute ChooseBestIAPL() to MPM to resolve the most preferred IAP. |
|
125 NODEACTIVITY_ENTRY( S60MCprStates::KChooseBestIAPRequired, |
|
126 S60MCprSimpleSelectActivity::TChooseBestIAP, |
|
127 S60MCprSimpleSelectActivity::TAwaitingChooseBestIAP, |
|
128 MeshMachine::TNoTag ) |
|
129 // ChooseBestIAP done or not required |
|
130 THROUGH_NODEACTIVITY_ENTRY( KNoTag, |
|
131 MeshMachine::TDoNothing, |
|
132 MCprStates::TSelectedProvider ) |
|
133 // Start the selection main loop |
|
134 NODEACTIVITY_ENTRY( MCprStates::KSelectedProvider, |
|
135 CSelectNextLayerActivity::TFindOrCreateTierManager, |
|
136 MCprStates::TAwaitingTierManagerCreated, |
|
137 MeshMachine::TNoTag ) |
|
138 // Join the newly created tier manager |
|
139 NODEACTIVITY_ENTRY( KNoTag, |
|
140 CSelectNextLayerActivity::TJoinTierManager, |
|
141 CoreStates::TAwaitingJoinComplete, |
|
142 MeshMachine::TNoTag ) |
|
143 // Select next provider and enter the selection internal loop if provider received. Break if SelectComplete(NULL). |
|
144 // Then post the selection list to TM. |
|
145 NODEACTIVITY_ENTRY( KNoTag, |
|
146 S60MCprSimpleSelectActivity::TSelectNextLayer, |
|
147 MCprStates::TAwaitingSelectComplete, |
|
148 CSelectNextLayerActivity::TNoTagOrSelectedProviderIsNull ) |
|
149 // Add provider info |
|
150 NODEACTIVITY_ENTRY( KNoTag, |
|
151 CSelectNextLayerActivity::TAddProviderInfo, |
|
152 MCprStates::TAwaitingSelectComplete, |
|
153 CSelectNextLayerActivity::TNoTagBackwardsOrJoinServiceProvider ) |
|
154 // Break the selection internal loop if SelectComplete(NULL), otherwise stay in this tripple |
|
155 NODEACTIVITY_ENTRY( MCprStates::KJoinServiceProvider, |
|
156 CSelectNextLayerActivity::TJoinServiceProvider, |
|
157 CoreStates::TAwaitingJoinComplete, |
|
158 MeshMachine::TNoTag ) |
|
159 // Send select complete |
|
160 THROUGH_NODEACTIVITY_ENTRY( KNoTag, |
|
161 CSelectNextLayerActivity::TSendSelectComplete, |
|
162 CSelectNextLayerActivity::TSelectedProviderIsNullOrJoinServiceProviderBackward ) |
|
163 // Break the selection main loop if no more choices, otherwise go back again |
|
164 THROUGH_NODEACTIVITY_ENTRY( MCprStates::KSelectedProviderIsNull, |
|
165 CSelectNextLayerActivity::TLeaveTierManager, |
|
166 S60MCprSimpleSelectActivity::TSetChosenApActiveOrSelectedProviderBackward ) |
|
167 // Set Selected Node Active |
|
168 THROUGH_NODEACTIVITY_ENTRY( S60MCprStates::KSetChosenApActive, |
|
169 S60MCprSimpleSelectActivity::TSetChosenApActive, |
|
170 MeshMachine::TNoTag ) |
|
171 // Finish the activity |
|
172 LAST_NODEACTIVITY_ENTRY( KNoTag, |
|
173 MCprStates::TSendFinalSelectComplete ) |
|
174 NODEACTIVITY_END() |
|
175 } |
|
176 |
|
177 // ----------------------------------------------------------------------------- |
|
178 // Connection Status Notification to MPM. |
|
179 // ----------------------------------------------------------------------------- |
|
180 // |
|
181 namespace S60MCprMonitorDataClientStatusActivity |
|
182 { |
|
183 DECLARE_DEFINE_NODEACTIVITY( ECFActivityMonitorProviderStatus, |
|
184 MCprDataClientStatusChange, |
|
185 TCFControlProvider::TDataClientStatusChange ) |
|
186 SINGLE_NODEACTIVITY_ENTRY( S60MCprStates::THandleMPMAndCoreDataClientStatusChangeAndDestroyOrphans, |
|
187 CoreNetStates::TAwaitingDataClientStatusChange ) |
|
188 NODEACTIVITY_END() |
|
189 } |
|
190 |
|
191 // ----------------------------------------------------------------------------- |
|
192 // MCprConnectionStartRecovery -activity is overriden error processing activity |
|
193 // based on Symbian's mobilitymcpr implementation. |
|
194 // ----------------------------------------------------------------------------- |
|
195 // |
|
196 namespace S60MCprErrorRecoveryActivity |
|
197 { |
|
198 DECLARE_DEFINE_CUSTOM_NODEACTIVITY( ECFActivityConnectionStartRecovery, |
|
199 MCprConnectionStartRecovery, |
|
200 TEErrorRecovery::TErrorRecoveryRequest, |
|
201 S60MCprErrorRecoveryActivity::CS60ConnectionRecoveryActivity::NewL ) |
|
202 // Intercept the reconnection request if appropriate |
|
203 FIRST_NODEACTIVITY_ENTRY( //MCprStates::TAwaitingConnectionStartRecoveryRequest, |
|
204 S60MCprErrorRecoveryActivity::TAwaitingNotGoneDownErrorRecoveryRequest, |
|
205 MeshMachine::TNoTag ) |
|
206 // Store error context but do not do proceed during mobility handshake. |
|
207 THROUGH_NODEACTIVITY_ENTRY( KNoTag, |
|
208 S60MCprErrorRecoveryActivity::CS60ConnectionRecoveryActivity::TStoreErrorContext, |
|
209 MeshMachine::TTag<S60MCprStates::KProcessError|NetStateMachine::EForward> ) |
|
210 //S60MCprErrorRecoveryActivity::TProcessErrorBlockedByMobilityHandshaking ) // can't block here. |
|
211 // Decide if it it possible/sensible to reconnect and retry |
|
212 NODEACTIVITY_ENTRY( S60MCprStates::KProcessError, |
|
213 S60MCprStates::TProcessError, |
|
214 S60MCprStates::TAwaitingProcessErrorCompleteOrError, |
|
215 S60MCprErrorRecoveryActivity::TNoTagOrIgnoreErrorOrErrorTag ) |
|
216 // ReSelection state, first execute reselect best IAP. |
|
217 NODEACTIVITY_ENTRY( KNoTag, |
|
218 S60MCprStates::TReselectBestIAP, |
|
219 S60MCprStates::TAwaitingReselectBestIAPCompleteOrError, |
|
220 S60MCprErrorRecoveryActivity::TNoTagOrRetryConnectionTagOrErrorTag ) |
|
221 // Then execute simpleselect. |
|
222 NODEACTIVITY_ENTRY( KNoTag, |
|
223 MCprStates::TSelectNextLayer, |
|
224 S60MCprStates::TAwaitingSelectNextLayerCompletedOrError, |
|
225 S60MCprErrorRecoveryActivity::TNoTagOrProcessErrorBackwardTag ) |
|
226 // This transition will leave if not possible to recover (==TSendPropagateRecoveryResponse from Transition::Error()) |
|
227 NODEACTIVITY_ENTRY( KNoTag, |
|
228 S60MCprStates::TRequestReConnect, |
|
229 MCprStates::TAwaitingReConnectCompleteOrError, |
|
230 S60MCprErrorRecoveryActivity::TRetryConnectionOrProcessErrorTagBackward ) |
|
231 // Respond with ignore error |
|
232 LAST_NODEACTIVITY_ENTRY( S60MCprStates::KIgnoreError, |
|
233 S60MCprErrorRecoveryActivity::TSendIgnoreRecoveryResponse ) |
|
234 // Respond with retry |
|
235 LAST_NODEACTIVITY_ENTRY( S60MCprStates::KRetryConnection, |
|
236 S60MCprErrorRecoveryActivity::CS60ConnectionRecoveryActivity::TSendRetryRecoveryResponse ) |
|
237 // Respond with propagate - the reconnect failed. |
|
238 LAST_NODEACTIVITY_ENTRY( KErrorTag, |
|
239 S60MCprErrorRecoveryActivity::CS60ConnectionRecoveryActivity::TSendPropagateRecoveryResponse ) |
|
240 NODEACTIVITY_END() |
|
241 } // namespace S60MCprErrorRecoveryActivity |
|
242 |
|
243 // ----------------------------------------------------------------------------- |
|
244 // S60MCprMobilityActivity |
|
245 // ----------------------------------------------------------------------------- |
|
246 // |
|
247 namespace S60MCprMobilityActivity |
|
248 { |
|
249 // Wait for start mobility message that is the representative of mobility API registration. |
|
250 DECLARE_DEFINE_CUSTOM_NODEACTIVITY( ECFActivityMCprMobility, |
|
251 MCprMobility, |
|
252 TCFMobilityProvider::TStartMobility, |
|
253 S60MCprMobilityActivity::CS60MobilityActivity::NewL ) |
|
254 // The activity only makes sense after the startup sequence completed on this layer |
|
255 FIRST_NODEACTIVITY_ENTRY( S60MCprMobilityActivity::TAwaitingStartMobility, |
|
256 MeshMachine::TNoTag/*BlockedByNoServiceProviderStarted*/ ) |
|
257 // Report to the client that we have successfully started |
|
258 THROUGH_NODEACTIVITY_ENTRY( KNoTag, |
|
259 S60MCprMobilityActivity::TReplyMobilityStarted, |
|
260 MeshMachine::TNoTag ) |
|
261 // Register for preferred carrier |
|
262 THROUGH_NODEACTIVITY_ENTRY( KNoTag, |
|
263 S60MCprMobilityActivity::TSendAvailabilityRequest, |
|
264 TTag<MobilityMCprStates::KStartMobilityHandshake> ) |
|
265 // Clear handshake status and wait for preferred carrier or mobility API close. |
|
266 NODEACTIVITY_ENTRY( MobilityMCprStates::KStartMobilityHandshake, |
|
267 CS60MobilityActivity::TClearHandshakingFlag, |
|
268 CS60MobilityActivity::TAwaitingPreferredCarrierOrCancelOrRejected, // Ok. Error is fatal. |
|
269 S60MCprMobilityActivity::TInformMigrationAvailableOrCancelTag ) |
|
270 // Application rejected active carrier |
|
271 THROUGH_NODEACTIVITY_ENTRY( S60MCprStates::KSendInitialApplicationReject, |
|
272 S60MCprMobilityActivity::TSendInitialApplicationReject, |
|
273 TTag<S60MCprStates::KWaitPolicyServerResponse> ) |
|
274 // Start mobility handshake if there is a better carrier available |
|
275 NODEACTIVITY_ENTRY( S60MCprStates::KInformMigrationAvailable, |
|
276 CS60MobilityActivity::TInformMigrationAvailableAndSetHandshakingFlagBlockedByConnectionRecoveryOrNoMobilityPreferenceOrError, |
|
277 S60MCprMobilityActivity::TAwaitingMigrationRequestedOrRejectedOrCancel, // Ok. Error is fatal. |
|
278 CS60MobilityActivity::TNoTagOrApplicationRejectedMigrationOrCancel ) |
|
279 // Informs policy server that application does not migrate |
|
280 THROUGH_NODEACTIVITY_ENTRY( S60MCprStates::KApplicationRejectedMigration, |
|
281 CS60MobilityActivity::TSendMigrationRejected, // Ok. Error is fatal |
|
282 S60MCprMobilityActivity::TStartMobilityHandshakeBackwardsOrError ) |
|
283 // Consults policy server if the user wants to migrate or not. |
|
284 THROUGH_NODEACTIVITY_ENTRY( KNoTag, |
|
285 CS60MobilityActivity::TSendMigrationAccepted, |
|
286 TTag<S60MCprStates::KWaitPolicyServerResponse> ) |
|
287 // Wait for Policy Server Response |
|
288 NODEACTIVITY_ENTRY( S60MCprStates::KWaitPolicyServerResponse, |
|
289 S60MCprMobilityActivity::TDoNothingOrReSendPendingNotification, |
|
290 CS60MobilityActivity::TAwaitingPreferredCarrierOrStartIAPNotificationOrErrorNotificationOrCancel, // Ok. Error is fatal |
|
291 S60MCprMobilityActivity::TNoTagOrInformMigrationAvailableBackwardsOrErrorOrCancel ) |
|
292 // Select the next layer MCPR. |
|
293 NODEACTIVITY_ENTRY( KNoTag, |
|
294 MCprStates::TSelectNextLayer, |
|
295 MCprStates::TAwaitingSelectNextLayerCompleted, // Ok. Error is fatal. |
|
296 MeshMachine::TNoTagOrErrorTag ) |
|
297 //S60MCprStates::TAwaitingSelectNextLayerCompletedOrError, // Not required Error is fatal. MPM should only give valid IAPs. |
|
298 //MeshMachine::TNoTagOrErrorTag )// Not required Error is fatal. MPM should only give valid IAPs. |
|
299 // For the moment it is sufficient to use the re-connect activity, in the future we may want to |
|
300 // customise the behavior, for example start the new layer before rebinding it, etc. |
|
301 NODEACTIVITY_ENTRY( KNoTag, |
|
302 S60MCprStates::TRequestReConnect, |
|
303 MCprStates::TAwaitingReConnectCompleteOrError, // Ok. Error is fatal. |
|
304 MeshMachine::TNoTagOrErrorTag ) //Own error handling MPM must be informed when error happens. |
|
305 // Select or activation failed, Ask MPM to decide if it it possible/sensible to ignore the error and continue. |
|
306 // EDoReselect return will fall into EIgnoreError branch. MPM shouldn't return Reselect in this case. |
|
307 // And if it does, then the use of startiapnotification in mobility scenarios should be |
|
308 // removed and only reselect should be used. |
|
309 /* Not required. PolicyServer should only give valid IAPs. |
|
310 NODEACTIVITY_ENTRY( KErrorTag, |
|
311 S60MCprStates::TProcessError, |
|
312 S60MCprStates::TAwaitingProcessErrorCompleteOrError, |
|
313 S60MCprMobilityActivity::TWaitPolicyServerResponseBackwardOrErrorTag ) |
|
314 */ |
|
315 // If the migration was acepted we loop again waiting for a new, preferred one |
|
316 NODEACTIVITY_ENTRY( KNoTag, |
|
317 CS60MobilityActivity::TInformMigrationCompleted, |
|
318 S60MCprMobilityActivity::TAwaitingMigrationAcceptedOrRejectedOrCancel, |
|
319 S60MCprMobilityActivity::TNoTagOrErrorTagOrApplicationRejected ) //-jl- TODO cancel here? |
|
320 // Informs policy server that application has accepted the carrier |
|
321 THROUGH_NODEACTIVITY_ENTRY( KNoTag, |
|
322 CS60MobilityActivity::TSendApplicationAccept, |
|
323 TTag<MobilityMCprStates::KStartMobilityHandshake|NetStateMachine::EBackward> ) |
|
324 // Informs policy server that application has rejected the carrier |
|
325 THROUGH_NODEACTIVITY_ENTRY( S60MCprStates::KApplicationRejectedMigration, |
|
326 CS60MobilityActivity::TSendApplicationReject, |
|
327 TTag<S60MCprStates::KWaitPolicyServerResponse|NetStateMachine::EBackward> ) |
|
328 // On error, we do not terminate the activity. |
|
329 // We need to inform the client and propose a new handshake should the client wish to continue |
|
330 THROUGH_NODEACTIVITY_ENTRY( KErrorTag, |
|
331 MeshMachine::TRaiseAndClearActivityError, |
|
332 TTag<MeshMachine::KCancelTag> ) |
|
333 // S60MCprMobilityActivity::TStartMobilityHandshakeBackwards ) |
|
334 // When closing, always continue to cancel the activity. |
|
335 LAST_NODEACTIVITY_ENTRY( KCancelTag, |
|
336 CS60MobilityActivity::TCancelMobilityActivity ) |
|
337 NODEACTIVITY_END() |
|
338 } // namespace S60MCprMobilityActivity |
|
339 |
|
340 // ----------------------------------------------------------------------------- |
|
341 // S60MCprConnectionGoneDownRecoveryActivity |
|
342 // ----------------------------------------------------------------------------- |
|
343 // |
|
344 namespace S60MCprConnectionGoneDownRecoveryActivity |
|
345 { |
|
346 // MCprConnectionGoneDownRecovery activity belongs to a group of Error Recovery Activities. |
|
347 // Error Recovery Activities need to handle their own errors (generated as well as returned). |
|
348 DECLARE_DEFINE_CUSTOM_NODEACTIVITY( ECFActivityConnectionGoneDownRecovery, |
|
349 MCprConnectionGoneDownRecovery, |
|
350 TEErrorRecovery::TErrorRecoveryRequest, |
|
351 S60MCprErrorRecoveryActivity::CS60ConnectionRecoveryActivity::NewL ) |
|
352 // Wait for GoneDown recovery request. GoneDown handles connection errors during active connection. |
|
353 // S60MCprConnectionGoneDownRecoveryActivity only needs to run if there's a mobility activity. |
|
354 FIRST_NODEACTIVITY_ENTRY( MCprStates::TAwaitingConnectionGoneDownRecoveryRequest, |
|
355 MeshMachine::TNoTag ) |
|
356 // Either TStoreErrorContext |
|
357 THROUGH_NODEACTIVITY_ENTRY( KNoTag, |
|
358 S60MCprErrorRecoveryActivity::CS60ConnectionRecoveryActivity::TStoreErrorContext, |
|
359 CoreStates::TNoTagOrNoPeer ) |
|
360 LAST_NODEACTIVITY_ENTRY( CoreStates::KNoPeer, |
|
361 S60MCprErrorRecoveryActivity::CS60ConnectionRecoveryActivity::TSendPropagateRecoveryResponse ) //Take error codes directly from the request |
|
362 THROUGH_NODEACTIVITY_ENTRY( KNoTag, |
|
363 MeshMachine::TDoNothing, |
|
364 S60MCprErrorRecoveryActivity::TProcessErrorBlockedByMobilityHandshaking ) |
|
365 // TProcessError assumes that errorcontext is stored in CS60ConnectionRecoveryActivity |
|
366 // The response from the policy server should always be ignore in this case. |
|
367 NODEACTIVITY_ENTRY( S60MCprStates::KProcessError, |
|
368 S60MCprStates::TProcessError, |
|
369 S60MCprStates::TAwaitingProcessErrorCompleteOrError, |
|
370 S60MCprErrorRecoveryActivity::TNoTagOrIgnoreErrorOrErrorTag ) |
|
371 // We have gone down. PolicyServer response EDoReselect means nothing here and |
|
372 // will be converted to propagate error. |
|
373 // Ignore is sensible in the case of mobility API where the mobility API can cause error. |
|
374 LAST_NODEACTIVITY_ENTRY( S60MCprStates::KIgnoreError, |
|
375 S60MCprErrorRecoveryActivity::TSendIgnoreRecoveryResponse ) |
|
376 LAST_NODEACTIVITY_ENTRY( KNoTag, |
|
377 S60MCprErrorRecoveryActivity::CS60ConnectionRecoveryActivity::TSendPropagateRecoveryResponse ) |
|
378 LAST_NODEACTIVITY_ENTRY( KErrorTag, |
|
379 S60MCprErrorRecoveryActivity::CS60ConnectionRecoveryActivity::TSendPropagateRecoveryResponse ) |
|
380 NODEACTIVITY_END() |
|
381 } // namespace S60MCprConnectionGoneDownRecoveryActivity |
|
382 |
|
383 // ----------------------------------------------------------------------------- |
|
384 // S60MCprServiceIdRMessage2HandlerActivity |
|
385 // ----------------------------------------------------------------------------- |
|
386 // |
|
387 namespace S60MCprServiceIdRMessage2HandlerActivity |
|
388 { |
|
389 DECLARE_DEFINE_CUSTOM_NODEACTIVITY( ECFActivityS60McprServiceIdMessage2Handler, |
|
390 S60MCprServiceIdLegacyRMessage2Handler, |
|
391 TNodeSignal::TNullMessageId, |
|
392 MeshMachine::CNodeParallelMessageStoreActivityBase::NewL ) |
|
393 |
|
394 FIRST_NODEACTIVITY_ENTRY( S60MCprStates::TAwaitingServiceIdRequest, |
|
395 MeshMachine::TNoTag ) |
|
396 |
|
397 NODEACTIVITY_ENTRY( KNoTag, |
|
398 S60MCprStates::TRetrieveServiceId, |
|
399 CoreNetStates::TAwaitingRMessage2Processed, |
|
400 MeshMachine::TNoTag ) |
|
401 |
|
402 LAST_NODEACTIVITY_ENTRY( KNoTag, |
|
403 CoreStates::TPostToOriginators ) |
|
404 |
|
405 NODEACTIVITY_END() |
|
406 } // S60MCprServiceIdRMessage2HandlerActivity |
|
407 |
|
408 // ----------------------------------------------------------------------------- |
|
409 // S60MCprActivities - activitymap |
|
410 // ----------------------------------------------------------------------------- |
|
411 // |
|
412 namespace S60MCprActivities |
|
413 { |
|
414 DEFINE_ACTIVITY_MAP(S60MCprActivityMap) |
|
415 ACTIVITY_MAP_ENTRY(S60MCprMonitorDataClientStatusActivity, MCprDataClientStatusChange) |
|
416 ACTIVITY_MAP_ENTRY(S60MCprSelectActivity, S60MCprSelect) // in s60mcprsimpleselectactivity.cpp |
|
417 ACTIVITY_MAP_ENTRY(S60MCprSimpleSelectActivity, MCprSimpleSelect) // in s60mcprsimpleselectactivity.cpp |
|
418 ACTIVITY_MAP_ENTRY(S60MCprErrorRecoveryActivity, MCprConnectionStartRecovery) // in s60mcprerrorrecoveryactivity.cpp |
|
419 ACTIVITY_MAP_ENTRY(S60MCprMobilityActivity, MCprMobility) // in s60mcprmobilityactivity.cpp |
|
420 ACTIVITY_MAP_ENTRY(S60MCprConnectionGoneDownRecoveryActivity, MCprConnectionGoneDownRecovery) |
|
421 ACTIVITY_MAP_ENTRY(S60MCprServiceIdRMessage2HandlerActivity, S60MCprServiceIdLegacyRMessage2Handler) |
|
422 ACTIVITY_MAP_END_BASE(MobilityMCprActivities, mobilityMCprActivities) |
|
423 } |
|
424 |
|
425 // End of File |