|
1 /* |
|
2 * Copyright (c) 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 mobility activity implementation |
|
15 * |
|
16 */ |
|
17 |
|
18 /** |
|
19 @file s60mcprmobilityactivity.cpp |
|
20 S60 MCPR mobility activity implementation |
|
21 */ |
|
22 |
|
23 #include "s60mcpractivities.h" |
|
24 #include "s60mcprstates.h" |
|
25 |
|
26 using namespace Messages; |
|
27 using namespace MeshMachine; |
|
28 using namespace ESock; |
|
29 |
|
30 // ----------------------------------------------------------------------------- |
|
31 // S60MCprMobilityActivity |
|
32 // ----------------------------------------------------------------------------- |
|
33 // |
|
34 namespace S60MCprMobilityActivity |
|
35 { |
|
36 // ----------------------------------------------------------------------------- |
|
37 // S60MCprMobilityActivity::TDoNothingOrReSendPendingNotification::DoL |
|
38 // ----------------------------------------------------------------------------- |
|
39 // |
|
40 DEFINE_SMELEMENT( TDoNothingOrReSendPendingNotification, NetStateMachine::MStateTransition, TContext ) |
|
41 void TDoNothingOrReSendPendingNotification::DoL() |
|
42 { |
|
43 S60MCPRLOGSTRING1("S60MCPR<%x>::TDoNothingOrReSendPendingNotification::DoL()",(TInt*)&iContext.Node()) |
|
44 __ASSERT_DEBUG(iContext.iNodeActivity, User::Panic(KS60MCprPanic, KPanicNoActivity)); |
|
45 CS60MetaConnectionProvider& node = (CS60MetaConnectionProvider&)iContext.Node(); |
|
46 |
|
47 // Process the pending request first. |
|
48 // |
|
49 node.ReSendPolicyNotification(); |
|
50 node.ClearPolicyNotification(); |
|
51 } |
|
52 |
|
53 |
|
54 // ----------------------------------------------------------------------------- |
|
55 // S60MCprMobilityActivity::TReplyMobilityStarted::DoL |
|
56 // ----------------------------------------------------------------------------- |
|
57 // |
|
58 DEFINE_SMELEMENT( TReplyMobilityStarted, NetStateMachine::MStateTransition, TContext ) |
|
59 void TReplyMobilityStarted::DoL() |
|
60 { |
|
61 S60MCPRLOGSTRING1("S60MCPR<%x>::TReplyMobilityStarted::DoL()",(TInt*)&iContext.Node()) |
|
62 __ASSERT_DEBUG(iContext.iNodeActivity, User::Panic(KS60MCprPanic, KPanicNoActivity)); |
|
63 iContext.iNodeActivity->PostToOriginators( TCFMobilityProvider::TMobilityStarted().CRef() ); |
|
64 iContext.iNodeActivity->ClearPostedTo(); |
|
65 } |
|
66 |
|
67 |
|
68 // ----------------------------------------------------------------------------- |
|
69 // S60MCprMobilityActivity::TSendAvailabilityRequest::DoL |
|
70 // ----------------------------------------------------------------------------- |
|
71 // |
|
72 DEFINE_SMELEMENT( TSendAvailabilityRequest, NetStateMachine::MStateTransition, TContext ) |
|
73 void TSendAvailabilityRequest::DoL() |
|
74 { |
|
75 S60MCPRLOGSTRING1("S60MCPR<%x>::TSendAvailabilityRequest::DoL()", (TInt*)&iContext.Node()) |
|
76 CS60MetaConnectionProvider& node = (CS60MetaConnectionProvider&)iContext.Node(); |
|
77 node.Policy()->RegisterPreferredIAPNotificationL(); |
|
78 } |
|
79 |
|
80 |
|
81 // ----------------------------------------------------------------------------- |
|
82 // S60MCprMobilityActivity::TSendInitialApplicationReject::DoL |
|
83 // ----------------------------------------------------------------------------- |
|
84 // |
|
85 DEFINE_SMELEMENT( TSendInitialApplicationReject, |
|
86 NetStateMachine::MStateTransition, |
|
87 TContext ) |
|
88 void TSendInitialApplicationReject::DoL() |
|
89 { |
|
90 S60MCPRLOGSTRING1("S60MCPR<%x>::TSendInitialApplicationReject::DoL()", (TInt*)&iContext.Node()) |
|
91 CS60MetaConnectionProvider& node = (CS60MetaConnectionProvider&)iContext.Node(); |
|
92 |
|
93 RMetaServiceProviderInterface* sp = NULL; |
|
94 // Set service provider to point to active service provider. |
|
95 sp = (RMetaServiceProviderInterface*) node.ServiceProvider(); |
|
96 TInt iapid = sp ? sp->ProviderInfo().APId() : 0; |
|
97 |
|
98 node.Policy()->ApplicationRejectedTheCarrierL( iapid ); |
|
99 } |
|
100 |
|
101 |
|
102 // ----------------------------------------------------------------------------- |
|
103 // S60MCprMobilityActivity::TAwaitingStartMobility::Accept |
|
104 // ----------------------------------------------------------------------------- |
|
105 // |
|
106 DEFINE_SMELEMENT( TAwaitingStartMobility, NetStateMachine::MState, TContext ) |
|
107 TBool TAwaitingStartMobility::Accept() |
|
108 { |
|
109 if (!iContext.iMessage.IsMessage<TCFMobilityProvider::TStartMobility>()) |
|
110 { |
|
111 return EFalse; |
|
112 } |
|
113 if (iContext.Node().ServiceProvider()==NULL) |
|
114 { |
|
115 S60MCPRLOGSTRING1("S60MCPR<%x>::TAwaitingStartMobility::Accept() no Provider!",(TInt*)&iContext.Node()) |
|
116 //There is no mobility on the lowest layer of the stack |
|
117 iContext.iMessage.ClearMessageId(); |
|
118 return EFalse; |
|
119 } |
|
120 S60MCPRLOGSTRING1("S60MCPR<%x>::TAwaitingStartMobility::Accept()", (TInt*)&iContext.Node() ); |
|
121 return ETrue; |
|
122 } |
|
123 |
|
124 |
|
125 // ----------------------------------------------------------------------------- |
|
126 // S60MCprMobilityActivity::TAwaitingMigrationRequestedOrRejectedOrCancel::Accept |
|
127 // ----------------------------------------------------------------------------- |
|
128 // |
|
129 DEFINE_SMELEMENT( TAwaitingMigrationRequestedOrRejectedOrCancel, |
|
130 NetStateMachine::MState, TContext ) |
|
131 TBool TAwaitingMigrationRequestedOrRejectedOrCancel::Accept() |
|
132 { |
|
133 S60MCPRLOGSTRING1("S60MCPR<%x>::TAwaitingMigrationRequestedOrRejectedOrCancel::Accept()", |
|
134 (TInt*)&iContext.Node()) |
|
135 return (iContext.iMessage.IsMessage<TCFMobilityProvider::TMigrationRequested>()) || |
|
136 (iContext.iMessage.IsMessage<TCFMobilityProvider::TMigrationRejected>()) || |
|
137 (iContext.iMessage.IsMessage<TEBase::TCancel>()); |
|
138 // (iContext.iMessage.IsMessage<TEBase::TError>()); |
|
139 } |
|
140 |
|
141 |
|
142 // ----------------------------------------------------------------------------- |
|
143 // S60MCprMobilityActivity::TAwaitingMigrationAcceptedOrRejectedOrCancel::Accept |
|
144 // ----------------------------------------------------------------------------- |
|
145 // |
|
146 DEFINE_SMELEMENT( TAwaitingMigrationAcceptedOrRejectedOrCancel, NetStateMachine::MState, TContext ) |
|
147 TBool TAwaitingMigrationAcceptedOrRejectedOrCancel::Accept() |
|
148 { |
|
149 if ( (iContext.iMessage.IsMessage<TCFMobilityProvider::TMigrationAccepted>()) || |
|
150 (iContext.iMessage.IsMessage<TCFMobilityProvider::TMigrationRejected>()) || |
|
151 (iContext.iMessage.IsMessage<TEBase::TCancel>()) ) |
|
152 { |
|
153 S60MCPRLOGSTRING1("S60MCPR<%x>::TAwaitingMigrationAcceptedOrRejectedOrCancel::Accept()",(TInt*)&iContext.Node()) |
|
154 return ETrue; |
|
155 } |
|
156 return EFalse; |
|
157 } |
|
158 |
|
159 |
|
160 // ----------------------------------------------------------------------------- |
|
161 // S60MCprMobilityActivity::TNoTagOrInformMigrationAvailableBackwardsOrErrorOrCancel::TransitionTag |
|
162 // ----------------------------------------------------------------------------- |
|
163 // |
|
164 DEFINE_SMELEMENT( TNoTagOrInformMigrationAvailableBackwardsOrErrorOrCancel, NetStateMachine::MStateFork, TContext ) |
|
165 TBool TNoTagOrInformMigrationAvailableBackwardsOrErrorOrCancel::TransitionTag() |
|
166 { |
|
167 // Error notification falls into the error -case. |
|
168 if ( iContext.iNodeActivity->Error() ) |
|
169 { |
|
170 S60MCPRLOGSTRING1("S60MCPR<%x>::TNoTagOrInformMigrationAvailableBackwardsOrErrorOrCancel::TransitionTag() Error",(TInt*)&iContext.Node()); |
|
171 return MeshMachine::KErrorTag | NetStateMachine::EForward; |
|
172 } |
|
173 if ( iContext.iMessage.IsMessage<TCFS60MCPRMessage::TMPMStartIAPNotificationMsg>() ) |
|
174 { |
|
175 S60MCPRLOGSTRING1("S60MCPR<%x>::TNoTagOrInformMigrationAvailableBackwardsOrErrorOrCancel::TransitionTag() TMPMStartIAPNotificationMsg",(TInt*)&iContext.Node()) |
|
176 return KNoTag | NetStateMachine::EForward; |
|
177 } |
|
178 if ( iContext.iMessage.IsMessage<TCFS60MCPRMessage::TMPMPreferredCarrierAvailableMsg>() ) |
|
179 { |
|
180 S60MCPRLOGSTRING1("S60MCPR<%x>::TNoTagOrInformMigrationAvailableBackwardsOrErrorOrCancel::TransitionTag() TMPMPreferredCarrierAvailableMsg",(TInt*)&iContext.Node()) |
|
181 return S60MCprStates::KInformMigrationAvailable | NetStateMachine::EBackward; |
|
182 } |
|
183 // else cancel |
|
184 return KCancelTag | NetStateMachine::EForward; |
|
185 } |
|
186 |
|
187 |
|
188 // ----------------------------------------------------------------------------- |
|
189 // S60MCprMobilityActivity::TStartMobilityHandshakeBackwardsOrError::TransitionTag |
|
190 // ----------------------------------------------------------------------------- |
|
191 // |
|
192 DEFINE_SMELEMENT( TStartMobilityHandshakeBackwardsOrError, NetStateMachine::MStateFork, TContext ) |
|
193 TBool TStartMobilityHandshakeBackwardsOrError::TransitionTag() |
|
194 { |
|
195 if ( iContext.iNodeActivity->Error() ) |
|
196 { |
|
197 S60MCPRLOGSTRING1("S60MCPR<%x>::TStartMobilityHandshakeBackwardsOrError::TransitionTag() KErrorTag",(TInt*)&iContext.Node()) |
|
198 return MeshMachine::KErrorTag | NetStateMachine::EForward; |
|
199 } |
|
200 S60MCPRLOGSTRING1("S60MCPR<%x>::TStartMobilityHandshakeBackwardsOrError::TransitionTag() KStartMobilityHandshake",(TInt*)&iContext.Node()) |
|
201 return MobilityMCprStates::KStartMobilityHandshake | NetStateMachine::EBackward; |
|
202 } |
|
203 |
|
204 |
|
205 // ----------------------------------------------------------------------------- |
|
206 // S60MCprMobilityActivity::TInformMigrationAvailableOrCancelTag::TransitionTag |
|
207 // ----------------------------------------------------------------------------- |
|
208 // |
|
209 DEFINE_SMELEMENT( TInformMigrationAvailableOrCancelTag, NetStateMachine::MStateFork, TContext ) |
|
210 TBool TInformMigrationAvailableOrCancelTag::TransitionTag() |
|
211 { |
|
212 if ( iContext.iMessage.IsMessage<TEBase::TCancel>() ) |
|
213 { |
|
214 S60MCPRLOGSTRING1("S60MCPR<%x>::TInformMigrationAvailableOrCancelTag::TransitionTag() KCancelTag",(TInt*)&iContext.Node()) |
|
215 return KCancelTag | NetStateMachine::EForward; |
|
216 } |
|
217 else if ( iContext.iMessage.IsMessage<TCFMobilityProvider::TMigrationRejected>() ) |
|
218 { |
|
219 S60MCPRLOGSTRING1("S60MCPR<%x>::TInformMigrationAvailableOrCancelTag::TransitionTag() KSendInitialApplicationReject", |
|
220 (TInt*)&iContext.Node()) |
|
221 return S60MCprStates::KSendInitialApplicationReject | NetStateMachine::EForward; |
|
222 } |
|
223 else |
|
224 { |
|
225 S60MCPRLOGSTRING1("S60MCPR<%x>::TInformMigrationAvailableOrCancelTag::TransitionTag() KInformMigrationAvailable",(TInt*)&iContext.Node()) |
|
226 return S60MCprStates::KInformMigrationAvailable | NetStateMachine::EForward; |
|
227 } |
|
228 } |
|
229 |
|
230 |
|
231 // ----------------------------------------------------------------------------- |
|
232 // S60MCprMobilityActivity::TNoTagOrErrorTagOrApplicationRejected::TransitionTag |
|
233 // ----------------------------------------------------------------------------- |
|
234 // |
|
235 DEFINE_SMELEMENT( TNoTagOrErrorTagOrApplicationRejected, NetStateMachine::MStateFork, TContext ) |
|
236 TBool TNoTagOrErrorTagOrApplicationRejected::TransitionTag() |
|
237 { |
|
238 if ( iContext.iNodeActivity->Error() ) |
|
239 { |
|
240 S60MCPRLOGSTRING1("S60MCPR<%x>::TNoTagOrErrorTagOrApplicationRejected::TransitionTag() KErrorTag",(TInt*)&iContext.Node()) |
|
241 return MeshMachine::KErrorTag | NetStateMachine::EForward; |
|
242 } |
|
243 if ( message_cast<TCFMobilityProvider::TMigrationAccepted>(&iContext.iMessage) ) |
|
244 { |
|
245 S60MCPRLOGSTRING1("S60MCPR<%x>::TNoTagOrErrorTagOrApplicationRejected::TransitionTag() KNoTag",(TInt*)&iContext.Node()) |
|
246 return MeshMachine::KNoTag | NetStateMachine::EForward; |
|
247 } |
|
248 else if ( message_cast<TCFMobilityProvider::TMigrationRejected>(&iContext.iMessage) ) |
|
249 { |
|
250 S60MCPRLOGSTRING1("S60MCPR<%x>::TNoTagOrErrorTagOrApplicationRejected::TransitionTag() KApplicationRejectedMigration",(TInt*)&iContext.Node()) |
|
251 return S60MCprStates::KApplicationRejectedMigration | NetStateMachine::EForward; |
|
252 } |
|
253 else |
|
254 { |
|
255 S60MCPRLOGSTRING1("S60MCPR<%x>::TNoTagOrErrorTagOrApplicationRejected::TransitionTag() KCancelTag",(TInt*)&iContext.Node()) |
|
256 return MeshMachine::KCancelTag | NetStateMachine::EForward; |
|
257 } |
|
258 } |
|
259 |
|
260 |
|
261 // ----------------------------------------------------------------------------- |
|
262 // S60MCprMobilityActivity::TWaitPolicyServerResponseBackwardOrErrorTag::TransitionTag |
|
263 // ----------------------------------------------------------------------------- |
|
264 // |
|
265 DEFINE_SMELEMENT( TWaitPolicyServerResponseBackwardOrErrorTag, NetStateMachine::MStateFork, TContext ) |
|
266 TBool TWaitPolicyServerResponseBackwardOrErrorTag::TransitionTag() |
|
267 { |
|
268 if ( iContext.iMessage.IsMessage<TCFS60MCPRMessage::TMPMProcessErrorCompletedMsg>() ) |
|
269 { |
|
270 // Make sure policy server doesn't say, reselect. |
|
271 ASSERT( message_cast<TCFS60MCPRMessage::TMPMProcessErrorCompletedMsg>(&iContext.iMessage)->iValue != |
|
272 (TInt)EDoReselection ); |
|
273 // Make sure we're are no longer in error state. |
|
274 iContext.iNodeActivity->SetError( KErrNone ); |
|
275 S60MCPRLOGSTRING1("S60MCPR<%x>::TWaitPolicyServerResponseBackwardOrErrorTag::TransitionTag() KWaitPolicyServerResponse",(TInt*)&iContext.Node()) |
|
276 return S60MCprStates::KWaitPolicyServerResponse | NetStateMachine::EBackward; |
|
277 } |
|
278 else |
|
279 { |
|
280 S60MCPRLOGSTRING1("S60MCPR<%x>::TWaitPolicyServerResponseBackwardOrErrorTag::TransitionTag() KErrorTag",(TInt*)&iContext.Node()) |
|
281 return MeshMachine::KErrorTag | NetStateMachine::EForward; |
|
282 } |
|
283 } |
|
284 |
|
285 |
|
286 // ----------------------------------------------------------------------------- |
|
287 // CS60MobilityActivity::NewL |
|
288 // ----------------------------------------------------------------------------- |
|
289 // |
|
290 MeshMachine::CNodeActivityBase* CS60MobilityActivity::NewL( const MeshMachine::TNodeActivity& aActivitySig, |
|
291 MeshMachine::AMMNodeBase& aNode ) |
|
292 { |
|
293 CS60MobilityActivity* self = new(ELeave) CS60MobilityActivity( aActivitySig, aNode ); |
|
294 return self; |
|
295 } |
|
296 |
|
297 // ----------------------------------------------------------------------------- |
|
298 // CS60MobilityActivity::CS60MobilityActivity |
|
299 // ----------------------------------------------------------------------------- |
|
300 // |
|
301 CS60MobilityActivity::CS60MobilityActivity( const MeshMachine::TNodeActivity& aActivitySig, |
|
302 MeshMachine::AMMNodeBase& aNode ) |
|
303 : S60MCprStates::CS60ErrorRecoveryActivity( aActivitySig, aNode ) |
|
304 {} |
|
305 |
|
306 |
|
307 // ----------------------------------------------------------------------------- |
|
308 // CS60MobilityActivity::TInformMigrationAvailableAndSetHandshakingFlag::DoL |
|
309 // ----------------------------------------------------------------------------- |
|
310 // |
|
311 DEFINE_SMELEMENT( CS60MobilityActivity::TInformMigrationAvailableAndSetHandshakingFlag, |
|
312 NetStateMachine::MStateTransition, |
|
313 CS60MobilityActivity::TContext ) |
|
314 void CS60MobilityActivity::TInformMigrationAvailableAndSetHandshakingFlag::DoL() |
|
315 { |
|
316 S60MCPRLOGSTRING1("S60MCPR<%x>::TInformMigrationAvailableAndSetHandshakingFlag::DoL()",(TInt*)&iContext.Node()) |
|
317 __ASSERT_DEBUG(iContext.iNodeActivity, User::Panic(KS60MCprPanic, KPanicNoActivity)); |
|
318 CS60MobilityActivity& activity = static_cast<CS60MobilityActivity&>(*iContext.iNodeActivity); |
|
319 |
|
320 //Inform the CPR that a potential migration is available. We only support a single data client |
|
321 //in this implementation. |
|
322 __ASSERT_DEBUG(activity.iPreferredAPId, User::Panic(KS60MCprPanic, KPanicNoServiceProvider)); |
|
323 |
|
324 //Compute all this here to keep EvaluatePreference() as fast as possible |
|
325 activity.iCurrent = static_cast<RMetaServiceProviderInterface*>( |
|
326 iContext.Node().GetFirstClient<TDefaultClientMatchPolicy>( |
|
327 TClientType( TCFClientType::EServProvider, TCFClientType::EStarted ))); |
|
328 |
|
329 __ASSERT_DEBUG(activity.iCurrent, User::Panic(KS60MCprPanic, KPanicNoServiceProvider)); |
|
330 /* Not valid ASSERT |
|
331 __ASSERT_DEBUG(activity.iCurrent->ProviderInfo().APId() == activity.iCurrentAssumedAPId, |
|
332 User::Panic(KS60MCprPanic, KPanicInConsistentMCPRState)); |
|
333 */ |
|
334 // Activity received the necessary information from the policy server earlier |
|
335 // and now holds that information which we'll send to IPCPR. |
|
336 TCFMobilityControlClient::TMigrationNotification msg( activity.iCurrentAssumedAPId, |
|
337 //activity.iCurrent->ProviderInfo().APId(), |
|
338 activity.iPreferredAPId, |
|
339 activity.iIsUpgrade, |
|
340 activity.iIsSeamless ); |
|
341 |
|
342 activity.PostToOriginators(msg); |
|
343 activity.ClearPostedTo(); |
|
344 activity.SetHandshakingFlag(); |
|
345 } |
|
346 |
|
347 |
|
348 // ----------------------------------------------------------------------------- |
|
349 // CS60MobilityActivity::TSendMigrationRejected::DoL |
|
350 // ----------------------------------------------------------------------------- |
|
351 // |
|
352 DEFINE_SMELEMENT( CS60MobilityActivity::TSendMigrationRejected, |
|
353 NetStateMachine::MStateTransition, |
|
354 CS60MobilityActivity::TContext ) |
|
355 void CS60MobilityActivity::TSendMigrationRejected::DoL() |
|
356 { |
|
357 S60MCPRLOGSTRING1("S60MCPR<%x>::TSendMigrationRejected::DoL()",(TInt*)&iContext.Node()) |
|
358 CS60MetaConnectionProvider& node = (CS60MetaConnectionProvider&)iContext.Node(); |
|
359 CS60MobilityActivity& activity = static_cast<CS60MobilityActivity&>(*iContext.iNodeActivity); |
|
360 node.Policy()->ApplicationIgnoredTheCarrierL( activity.iPreferredAPId ); |
|
361 } |
|
362 |
|
363 |
|
364 // ----------------------------------------------------------------------------- |
|
365 // CS60MobilityActivity::TSendMigrationAccepted::DoL |
|
366 // ----------------------------------------------------------------------------- |
|
367 // |
|
368 DEFINE_SMELEMENT( CS60MobilityActivity::TSendMigrationAccepted, |
|
369 NetStateMachine::MStateTransition, |
|
370 CS60MobilityActivity::TContext ) |
|
371 void CS60MobilityActivity::TSendMigrationAccepted::DoL() |
|
372 { |
|
373 S60MCPRLOGSTRING1("S60MCPR<%x>::TSendMigrationAccepted::DoL()",(TInt*)&iContext.Node()) |
|
374 CS60MetaConnectionProvider& node = (CS60MetaConnectionProvider&)iContext.Node(); |
|
375 CS60MobilityActivity& activity = static_cast<CS60MobilityActivity&>(*iContext.iNodeActivity); |
|
376 node.Policy()->ApplicationMigratesToCarrierL( activity.iPreferredAPId ); |
|
377 } |
|
378 |
|
379 |
|
380 // ----------------------------------------------------------------------------- |
|
381 // CS60MobilityActivity::TSendApplicationAccept::DoL |
|
382 // ----------------------------------------------------------------------------- |
|
383 // |
|
384 DEFINE_SMELEMENT( CS60MobilityActivity::TSendApplicationAccept, |
|
385 NetStateMachine::MStateTransition, |
|
386 CS60MobilityActivity::TContext ) |
|
387 void CS60MobilityActivity::TSendApplicationAccept::DoL() |
|
388 { |
|
389 S60MCPRLOGSTRING1("S60MCPR<%x>::TSendApplicationAccept::DoL()",(TInt*)&iContext.Node()) |
|
390 CS60MetaConnectionProvider& node = (CS60MetaConnectionProvider&)iContext.Node(); |
|
391 CS60MobilityActivity& activity = static_cast<CS60MobilityActivity&>(*iContext.iNodeActivity); |
|
392 node.Policy()->ApplicationAcceptedTheCarrierL( activity.iPreferredAPId ); |
|
393 } |
|
394 |
|
395 |
|
396 // ----------------------------------------------------------------------------- |
|
397 // CS60MobilityActivity::TSendApplicationReject::DoL |
|
398 // ----------------------------------------------------------------------------- |
|
399 // |
|
400 DEFINE_SMELEMENT( CS60MobilityActivity::TSendApplicationReject, |
|
401 NetStateMachine::MStateTransition, |
|
402 CS60MobilityActivity::TContext ) |
|
403 void CS60MobilityActivity::TSendApplicationReject::DoL() |
|
404 { |
|
405 S60MCPRLOGSTRING1("S60MCPR<%x>::TSendApplicationReject::DoL()",(TInt*)&iContext.Node()) |
|
406 CS60MetaConnectionProvider& node = (CS60MetaConnectionProvider&)iContext.Node(); |
|
407 CS60MobilityActivity& activity = static_cast<CS60MobilityActivity&>(*iContext.iNodeActivity); |
|
408 node.Policy()->ApplicationRejectedTheCarrierL( activity.iPreferredAPId ); |
|
409 } |
|
410 |
|
411 |
|
412 // ----------------------------------------------------------------------------- |
|
413 // CS60MobilityActivity::TClearHandshakingFlag::DoL |
|
414 // ----------------------------------------------------------------------------- |
|
415 // |
|
416 DEFINE_SMELEMENT( CS60MobilityActivity::TClearHandshakingFlag, |
|
417 NetStateMachine::MStateTransition, CS60MobilityActivity::TContext ) |
|
418 void CS60MobilityActivity::TClearHandshakingFlag::DoL() |
|
419 { |
|
420 S60MCPRLOGSTRING1("S60MCPR<%x>::TClearHandshakingFlag::DoL()",(TInt*)&iContext.Node()) |
|
421 __ASSERT_DEBUG(iContext.iNodeActivity, User::Panic(KS60MCprPanic, KPanicNoActivity)); |
|
422 CS60MobilityActivity& activity = static_cast<CS60MobilityActivity&>(*iContext.iNodeActivity); |
|
423 activity.ClearHandshakingFlag(); |
|
424 } |
|
425 |
|
426 |
|
427 // ----------------------------------------------------------------------------- |
|
428 // CS60MobilityActivity::TInformMigrationCompleted::DoL |
|
429 // ----------------------------------------------------------------------------- |
|
430 // |
|
431 DEFINE_SMELEMENT( CS60MobilityActivity::TInformMigrationCompleted, |
|
432 NetStateMachine::MStateTransition, CS60MobilityActivity::TContext ) |
|
433 void CS60MobilityActivity::TInformMigrationCompleted::DoL() |
|
434 { |
|
435 S60MCPRLOGSTRING1("S60MCPR<%x>::TInformMigrationCompleted::DoL()",(TInt*)&iContext.Node()) |
|
436 __ASSERT_DEBUG(iContext.iNodeActivity, User::Panic(KS60MCprPanic, KPanicNoActivity)); |
|
437 iContext.iNodeActivity->PostToOriginators(TCFMobilityProvider::TMigrationComplete().CRef()); |
|
438 iContext.iNodeActivity->ClearPostedTo(); |
|
439 } |
|
440 |
|
441 |
|
442 // ----------------------------------------------------------------------------- |
|
443 // CS60MobilityActivity::TCancelMobilityActivity::DoL |
|
444 // ----------------------------------------------------------------------------- |
|
445 // |
|
446 DEFINE_SMELEMENT( CS60MobilityActivity::TCancelMobilityActivity, |
|
447 NetStateMachine::MStateTransition, CS60MobilityActivity::TContext ) |
|
448 void CS60MobilityActivity::TCancelMobilityActivity::DoL() |
|
449 { |
|
450 S60MCPRLOGSTRING1("S60MCPR<%x>::TCancelAvailabilityRequest::DoL()",(TInt*)&iContext.Node()) |
|
451 CS60MetaConnectionProvider& node = (CS60MetaConnectionProvider&)iContext.Node(); |
|
452 // Unregister from preferred IAP Notifications. |
|
453 // |
|
454 node.Policy()->UnregisterPreferredIAPNotificationL(); |
|
455 // Clear the mobility handshaking flag. |
|
456 // |
|
457 CS60MobilityActivity& activity = static_cast<CS60MobilityActivity&>(*iContext.iNodeActivity); |
|
458 activity.ClearHandshakingFlag(); |
|
459 // At last we must set the activity in error since we're ready to go down. |
|
460 // |
|
461 iContext.iNodeActivity->SetError( KErrCancel ); |
|
462 } |
|
463 |
|
464 |
|
465 // ----------------------------------------------------------------------------- |
|
466 // CS60MobilityActivity::TAwaitingPreferredCarrierOrCancelOrRejected::Accept |
|
467 // ----------------------------------------------------------------------------- |
|
468 // |
|
469 DEFINE_SMELEMENT( CS60MobilityActivity::TAwaitingPreferredCarrierOrCancelOrRejected, |
|
470 NetStateMachine::MState, TContext ) |
|
471 TBool CS60MobilityActivity::TAwaitingPreferredCarrierOrCancelOrRejected::Accept() |
|
472 { |
|
473 TBool result( EFalse ); |
|
474 |
|
475 if ( iContext.iMessage.IsMessage<TCFS60MCPRMessage::TMPMPreferredCarrierAvailableMsg>() ) |
|
476 { |
|
477 CS60MobilityActivity& activity = static_cast<CS60MobilityActivity&>(*iContext.iNodeActivity); |
|
478 |
|
479 TCFS60MCPRMessage::TMPMPreferredCarrierAvailableMsg* msg = |
|
480 message_cast<TCFS60MCPRMessage::TMPMPreferredCarrierAvailableMsg>( &iContext.iMessage ); |
|
481 |
|
482 TMpmNotificationPrefIAPAvailable* notif = (TMpmNotificationPrefIAPAvailable*)msg->iPtr; |
|
483 |
|
484 S60MCPRLOGSTRING4("S60MCPR<%x>::TAwaitingPreferredCarrierOrCancelOrRejected::Accept() TMPMPreferredCarrierAvailableMsg %d -> %d upgrade=%d", |
|
485 (TInt*)&iContext.Node(), notif->iOldIapId, notif->iNewIapId, notif->iIsUpgrade) |
|
486 // notif must be there. |
|
487 ASSERT(notif); |
|
488 |
|
489 // Message received ok, clear the pending preferred IAP. |
|
490 // |
|
491 ((CS60MetaConnectionProvider&)iContext.Node()).ClearPolicyNotification(); |
|
492 |
|
493 // Store the message preferences. |
|
494 // |
|
495 activity.iPreferredAPId = notif->iNewIapId; |
|
496 activity.iCurrentAssumedAPId = notif->iOldIapId; |
|
497 activity.iIsUpgrade = notif->iIsUpgrade; |
|
498 activity.iIsSeamless = notif->iIsSeamless; |
|
499 |
|
500 result = ETrue; |
|
501 } |
|
502 else if ( iContext.iMessage.IsMessage<TEBase::TCancel>() ) |
|
503 { |
|
504 S60MCPRLOGSTRING1("S60MCPR<%x>::TAwaitingPreferredCarrierOrCancelOrRejected::Accept() TCancel", |
|
505 (TInt*)&iContext.Node()) |
|
506 |
|
507 result = ETrue; |
|
508 } |
|
509 else if ( iContext.iMessage.IsMessage<TCFMobilityProvider::TMigrationRejected>() ) |
|
510 { |
|
511 S60MCPRLOGSTRING1("S60MCPR<%x>::TAwaitingPreferredCarrierOrCancelOrRejected::Accept() TMigrationRejected", |
|
512 (TInt*)&iContext.Node()) |
|
513 |
|
514 result = ETrue; |
|
515 } |
|
516 |
|
517 return result; |
|
518 } |
|
519 |
|
520 |
|
521 // ----------------------------------------------------------------------------- |
|
522 // CS60MobilityActivity::TAwaitingPreferredCarrierOrStartIAPNotificationOrErrorNotificationOrCancel::Accept |
|
523 // ----------------------------------------------------------------------------- |
|
524 // |
|
525 DEFINE_SMELEMENT( CS60MobilityActivity::TAwaitingPreferredCarrierOrStartIAPNotificationOrErrorNotificationOrCancel, |
|
526 NetStateMachine::MState, |
|
527 CS60MobilityActivity::TContext ) |
|
528 TBool CS60MobilityActivity::TAwaitingPreferredCarrierOrStartIAPNotificationOrErrorNotificationOrCancel::Accept() |
|
529 { |
|
530 CS60MetaConnectionProvider& node = (CS60MetaConnectionProvider&)iContext.Node(); |
|
531 // Clear the pending at the end if the msg was accepted. |
|
532 // |
|
533 TBool result( EFalse ); |
|
534 |
|
535 if ( iContext.iMessage.IsMessage<TCFS60MCPRMessage::TMPMErrorNotificationMsg>() ) |
|
536 { |
|
537 CS60MobilityActivity& activity = static_cast<CS60MobilityActivity&>(*iContext.iNodeActivity); |
|
538 TCFS60MCPRMessage::TMPMErrorNotificationMsg* msg = |
|
539 message_cast<TCFS60MCPRMessage::TMPMErrorNotificationMsg>( &iContext.iMessage ); |
|
540 S60MCPRLOGSTRING2("S60MCPR<%x>::TAwaitingPreferredCarrierOrStartIAPNotificationOrErrorNotificationOrCancel::Accept() TMPMErrorNotificationMsg %d",(TInt*)&iContext.Node(),msg->iValue) |
|
541 ASSERT( msg->iValue != KErrNone ); |
|
542 activity.SetError( msg->iValue ); |
|
543 result = ETrue; |
|
544 } |
|
545 |
|
546 if ( iContext.iMessage.IsMessage<TCFS60MCPRMessage::TMPMPreferredCarrierAvailableMsg>() ) |
|
547 { |
|
548 CS60MobilityActivity& activity = static_cast<CS60MobilityActivity&>(*iContext.iNodeActivity); |
|
549 |
|
550 TCFS60MCPRMessage::TMPMPreferredCarrierAvailableMsg* msg = |
|
551 message_cast<TCFS60MCPRMessage::TMPMPreferredCarrierAvailableMsg>( &iContext.iMessage ); |
|
552 |
|
553 TMpmNotificationPrefIAPAvailable* notif = (TMpmNotificationPrefIAPAvailable*)msg->iPtr; |
|
554 |
|
555 S60MCPRLOGSTRING4("S60MCPR<%x>::TAwaitingPreferredCarrierOrStartIAPNotificationOrErrorNotificationOrCancel::Accept() TMPMPreferredCarrierAvailableMsg %d -> %d upgrade=%d", |
|
556 (TInt*)&iContext.Node(), notif->iOldIapId, notif->iNewIapId, notif->iIsUpgrade) |
|
557 |
|
558 // info must be there. |
|
559 ASSERT(notif); |
|
560 |
|
561 activity.iPreferredAPId = notif->iNewIapId; |
|
562 activity.iCurrentAssumedAPId = notif->iOldIapId; |
|
563 activity.iIsUpgrade = notif->iIsUpgrade; |
|
564 activity.iIsSeamless = notif->iIsSeamless; |
|
565 result = ETrue; |
|
566 } |
|
567 |
|
568 if ( iContext.iMessage.IsMessage<TCFS60MCPRMessage::TMPMStartIAPNotificationMsg>() ) |
|
569 { |
|
570 TCFS60MCPRMessage::TMPMStartIAPNotificationMsg* msg = |
|
571 message_cast<TCFS60MCPRMessage::TMPMStartIAPNotificationMsg>( &iContext.iMessage ); |
|
572 |
|
573 CS60MetaConnectionProvider& node = (CS60MetaConnectionProvider&)iContext.Node(); |
|
574 |
|
575 S60MCPRLOGSTRING2("S60MCPR<%x>::TAwaitingPreferredCarrierOrStartIAPNotificationOrErrorNotificationOrCancel::Accept() TMPMStartIAPNotificationMsg IAP=%d NET=%d",(TInt*)&iContext.Node(), msg->iValue) |
|
576 |
|
577 node.PolicyPrefs().SetIapId( msg->iValue ); |
|
578 result = ETrue; |
|
579 } |
|
580 |
|
581 if ( iContext.iMessage.IsMessage<TEBase::TCancel>() ) |
|
582 { |
|
583 S60MCPRLOGSTRING1("S60MCPR<%x>::TAwaitingPreferredCarrierOrStartIAPNotificationOrErrorNotificationOrCancel::Accept() TCancel",(TInt*)&iContext.Node()) |
|
584 // There's nothing to cancel as we're waiting for notification only. |
|
585 // Cancelling the notifications in standard cancel-transition is enough. |
|
586 result = ETrue; |
|
587 } |
|
588 |
|
589 // Ok, we can clear the msg. |
|
590 // |
|
591 if ( result ) |
|
592 { |
|
593 // Clear. |
|
594 node.ClearPolicyNotification(); |
|
595 } |
|
596 |
|
597 // other messages. |
|
598 // |
|
599 return result; |
|
600 } |
|
601 |
|
602 |
|
603 // ----------------------------------------------------------------------------- |
|
604 // CS60MobilityActivity::TNoTagOrErrorTagOrApplicationRejectedMigrationOrCancel::TransitionTag |
|
605 // ----------------------------------------------------------------------------- |
|
606 // |
|
607 DEFINE_SMELEMENT( CS60MobilityActivity::TNoTagOrApplicationRejectedMigrationOrCancel, |
|
608 NetStateMachine::MStateFork, CS60MobilityActivity::TContext ) |
|
609 TInt CS60MobilityActivity::TNoTagOrApplicationRejectedMigrationOrCancel::TransitionTag() |
|
610 { |
|
611 if ( message_cast<TCFMobilityProvider::TMigrationRequested>(&iContext.iMessage) ) |
|
612 { |
|
613 S60MCPRLOGSTRING1("S60MCPR<%x>::TNoTagOrApplicationRejectedMigrationOrCancel::TransitionTag() KNoTag",(TInt*)&iContext.Node()) |
|
614 return MeshMachine::KNoTag | NetStateMachine::EForward; |
|
615 } |
|
616 if ( message_cast<TCFMobilityProvider::TMigrationRejected>(&iContext.iMessage) ) |
|
617 { |
|
618 S60MCPRLOGSTRING1("S60MCPR<%x>::TNoTagOrApplicationRejectedMigrationOrCancel::TransitionTag() KApplicationRejectedMigration",(TInt*)&iContext.Node()) |
|
619 return S60MCprStates::KApplicationRejectedMigration | NetStateMachine::EForward; |
|
620 } |
|
621 if ( message_cast<TEBase::TCancel>(&iContext.iMessage) ) |
|
622 { |
|
623 S60MCPRLOGSTRING1("S60MCPR<%x>::TNoTagOrApplicationRejectedMigrationOrCancel::TransitionTag() KCancelTag Generating ApplicationIgnoredTheCarrier",(TInt*)&iContext.Node()) |
|
624 |
|
625 // Need to put MPM in consistent state and continue. |
|
626 CS60MetaConnectionProvider& node = (CS60MetaConnectionProvider&)iContext.Node(); |
|
627 CS60MobilityActivity& activity = static_cast<CS60MobilityActivity&>(*iContext.iNodeActivity); |
|
628 TRAP_IGNORE( node.Policy()->ApplicationIgnoredTheCarrierL( activity.iPreferredAPId ) ); |
|
629 |
|
630 return MeshMachine::KCancelTag | NetStateMachine::EForward; |
|
631 } |
|
632 /* else |
|
633 { |
|
634 S60MCPRLOGSTRING1("S60MCPR<%x>::TNoTagOrErrorTagOrApplicationRejectedMigrationOrCancel::TransitionTag() Generating ApplicationIgnoredTheCarrier", (TInt*)&iContext.Node() ); |
|
635 |
|
636 // Need to put MPM in consistent state and continue. |
|
637 CS60MetaConnectionProvider& node = (CS60MetaConnectionProvider&)iContext.Node(); |
|
638 CS60MobilityActivity& activity = static_cast<CS60MobilityActivity&>(*iContext.iNodeActivity); |
|
639 TRAP_IGNORE( node.Policy()->ApplicationIgnoredTheCarrierL( activity.iPreferredAPId ) ); |
|
640 |
|
641 if ( iContext.iNodeActivity->Error() == KErrNone ) |
|
642 { |
|
643 ASSERT(EFalse); // should not happend |
|
644 iContext.iNodeActivity->SetError( KErrGeneral ); // doesn't have effect if already set. |
|
645 return MeshMachine::KErrorTag | NetStateMachine::EForward; |
|
646 } |
|
647 |
|
648 return MeshMachine::KErrorTag | NetStateMachine::EForward; |
|
649 }*/ |
|
650 S60MCPRLOGSTRING1("S60MCPR<%x>::TNoTagOrApplicationRejectedMigrationOrCancel::TransitionTag() KErrorTag ESock_IP Panic",(TInt*)&iContext.Node()) |
|
651 ASSERT(EFalse); // error, IPCPR should not send TError in this case. |
|
652 return MeshMachine::KErrorTag | NetStateMachine::EForward; |
|
653 } |
|
654 |
|
655 |
|
656 // ----------------------------------------------------------------------------- |
|
657 // CS60MobilityActivity::ClearHandshakingFlag |
|
658 // ----------------------------------------------------------------------------- |
|
659 // |
|
660 void CS60MobilityActivity::SetHandshakingFlag() |
|
661 { |
|
662 static_cast<CS60MetaConnectionProvider&>(iNode).SetHandshakingFlag(); |
|
663 } |
|
664 |
|
665 |
|
666 // ----------------------------------------------------------------------------- |
|
667 // CS60MobilityActivity::ClearHandshakingFlag |
|
668 // ----------------------------------------------------------------------------- |
|
669 // |
|
670 void CS60MobilityActivity::ClearHandshakingFlag() |
|
671 { |
|
672 static_cast<CS60MetaConnectionProvider&>(iNode).ClearHandshakingFlag(); |
|
673 } |
|
674 |
|
675 |
|
676 // ----------------------------------------------------------------------------- |
|
677 // CS60MobilityActivity::TConnectionRecoveryOrMobilityPreferenceOrErrorMutex::IsBlocked |
|
678 // ----------------------------------------------------------------------------- |
|
679 // |
|
680 TBool CS60MobilityActivity::TConnectionRecoveryOrMobilityPreferenceOrErrorMutex::IsBlocked( MeshMachine::TNodeContextBase& aContext ) |
|
681 { |
|
682 if ( aContext.iNode.CountActivities( ECFActivityConnectionStartRecovery ) != 0 || |
|
683 aContext.iNode.CountActivities( ECFActivityConnectionGoneDownRecovery ) != 0 ) |
|
684 { |
|
685 S60MCPRLOGSTRING1("S60MCPR<%x>::TConnectionRecoveryOrMobilityPreferenceOrErrorMutex::IsBlocked() BLOCKED!",(TInt*)&aContext.Node()) |
|
686 return ETrue; |
|
687 } |
|
688 // In all other cases we have received a preferred carrier available from |
|
689 // policy server and we need to act on it. |
|
690 return EFalse; |
|
691 } |
|
692 |
|
693 } // namespace S60MCprMobilityActivity |
|
694 |
|
695 // End of File |
|
696 |