--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/bearermanagement/S60MCPR/src/s60mcprmobilityactivity.cpp Thu Dec 17 08:55:21 2009 +0200
@@ -0,0 +1,696 @@
+/*
+* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description: S60 MCPR mobility activity implementation
+*
+*/
+
+/**
+@file s60mcprmobilityactivity.cpp
+S60 MCPR mobility activity implementation
+*/
+
+#include "s60mcpractivities.h"
+#include "s60mcprstates.h"
+
+using namespace Messages;
+using namespace MeshMachine;
+using namespace ESock;
+
+// -----------------------------------------------------------------------------
+// S60MCprMobilityActivity
+// -----------------------------------------------------------------------------
+//
+namespace S60MCprMobilityActivity
+ {
+ // -----------------------------------------------------------------------------
+ // S60MCprMobilityActivity::TDoNothingOrReSendPendingNotification::DoL
+ // -----------------------------------------------------------------------------
+ //
+ DEFINE_SMELEMENT( TDoNothingOrReSendPendingNotification, NetStateMachine::MStateTransition, TContext )
+ void TDoNothingOrReSendPendingNotification::DoL()
+ {
+ S60MCPRLOGSTRING1("S60MCPR<%x>::TDoNothingOrReSendPendingNotification::DoL()",(TInt*)&iContext.Node())
+ __ASSERT_DEBUG(iContext.iNodeActivity, User::Panic(KS60MCprPanic, KPanicNoActivity));
+ CS60MetaConnectionProvider& node = (CS60MetaConnectionProvider&)iContext.Node();
+
+ // Process the pending request first.
+ //
+ node.ReSendPolicyNotification();
+ node.ClearPolicyNotification();
+ }
+
+
+ // -----------------------------------------------------------------------------
+ // S60MCprMobilityActivity::TReplyMobilityStarted::DoL
+ // -----------------------------------------------------------------------------
+ //
+ DEFINE_SMELEMENT( TReplyMobilityStarted, NetStateMachine::MStateTransition, TContext )
+ void TReplyMobilityStarted::DoL()
+ {
+ S60MCPRLOGSTRING1("S60MCPR<%x>::TReplyMobilityStarted::DoL()",(TInt*)&iContext.Node())
+ __ASSERT_DEBUG(iContext.iNodeActivity, User::Panic(KS60MCprPanic, KPanicNoActivity));
+ iContext.iNodeActivity->PostToOriginators( TCFMobilityProvider::TMobilityStarted().CRef() );
+ iContext.iNodeActivity->ClearPostedTo();
+ }
+
+
+ // -----------------------------------------------------------------------------
+ // S60MCprMobilityActivity::TSendAvailabilityRequest::DoL
+ // -----------------------------------------------------------------------------
+ //
+ DEFINE_SMELEMENT( TSendAvailabilityRequest, NetStateMachine::MStateTransition, TContext )
+ void TSendAvailabilityRequest::DoL()
+ {
+ S60MCPRLOGSTRING1("S60MCPR<%x>::TSendAvailabilityRequest::DoL()", (TInt*)&iContext.Node())
+ CS60MetaConnectionProvider& node = (CS60MetaConnectionProvider&)iContext.Node();
+ node.Policy()->RegisterPreferredIAPNotificationL();
+ }
+
+
+ // -----------------------------------------------------------------------------
+ // S60MCprMobilityActivity::TSendInitialApplicationReject::DoL
+ // -----------------------------------------------------------------------------
+ //
+ DEFINE_SMELEMENT( TSendInitialApplicationReject,
+ NetStateMachine::MStateTransition,
+ TContext )
+ void TSendInitialApplicationReject::DoL()
+ {
+ S60MCPRLOGSTRING1("S60MCPR<%x>::TSendInitialApplicationReject::DoL()", (TInt*)&iContext.Node())
+ CS60MetaConnectionProvider& node = (CS60MetaConnectionProvider&)iContext.Node();
+
+ RMetaServiceProviderInterface* sp = NULL;
+ // Set service provider to point to active service provider.
+ sp = (RMetaServiceProviderInterface*) node.ServiceProvider();
+ TInt iapid = sp ? sp->ProviderInfo().APId() : 0;
+
+ node.Policy()->ApplicationRejectedTheCarrierL( iapid );
+ }
+
+
+ // -----------------------------------------------------------------------------
+ // S60MCprMobilityActivity::TAwaitingStartMobility::Accept
+ // -----------------------------------------------------------------------------
+ //
+ DEFINE_SMELEMENT( TAwaitingStartMobility, NetStateMachine::MState, TContext )
+ TBool TAwaitingStartMobility::Accept()
+ {
+ if (!iContext.iMessage.IsMessage<TCFMobilityProvider::TStartMobility>())
+ {
+ return EFalse;
+ }
+ if (iContext.Node().ServiceProvider()==NULL)
+ {
+ S60MCPRLOGSTRING1("S60MCPR<%x>::TAwaitingStartMobility::Accept() no Provider!",(TInt*)&iContext.Node())
+ //There is no mobility on the lowest layer of the stack
+ iContext.iMessage.ClearMessageId();
+ return EFalse;
+ }
+ S60MCPRLOGSTRING1("S60MCPR<%x>::TAwaitingStartMobility::Accept()", (TInt*)&iContext.Node() );
+ return ETrue;
+ }
+
+
+ // -----------------------------------------------------------------------------
+ // S60MCprMobilityActivity::TAwaitingMigrationRequestedOrRejectedOrCancel::Accept
+ // -----------------------------------------------------------------------------
+ //
+ DEFINE_SMELEMENT( TAwaitingMigrationRequestedOrRejectedOrCancel,
+ NetStateMachine::MState, TContext )
+ TBool TAwaitingMigrationRequestedOrRejectedOrCancel::Accept()
+ {
+ S60MCPRLOGSTRING1("S60MCPR<%x>::TAwaitingMigrationRequestedOrRejectedOrCancel::Accept()",
+ (TInt*)&iContext.Node())
+ return (iContext.iMessage.IsMessage<TCFMobilityProvider::TMigrationRequested>()) ||
+ (iContext.iMessage.IsMessage<TCFMobilityProvider::TMigrationRejected>()) ||
+ (iContext.iMessage.IsMessage<TEBase::TCancel>());
+// (iContext.iMessage.IsMessage<TEBase::TError>());
+ }
+
+
+ // -----------------------------------------------------------------------------
+ // S60MCprMobilityActivity::TAwaitingMigrationAcceptedOrRejectedOrCancel::Accept
+ // -----------------------------------------------------------------------------
+ //
+ DEFINE_SMELEMENT( TAwaitingMigrationAcceptedOrRejectedOrCancel, NetStateMachine::MState, TContext )
+ TBool TAwaitingMigrationAcceptedOrRejectedOrCancel::Accept()
+ {
+ if ( (iContext.iMessage.IsMessage<TCFMobilityProvider::TMigrationAccepted>()) ||
+ (iContext.iMessage.IsMessage<TCFMobilityProvider::TMigrationRejected>()) ||
+ (iContext.iMessage.IsMessage<TEBase::TCancel>()) )
+ {
+ S60MCPRLOGSTRING1("S60MCPR<%x>::TAwaitingMigrationAcceptedOrRejectedOrCancel::Accept()",(TInt*)&iContext.Node())
+ return ETrue;
+ }
+ return EFalse;
+ }
+
+
+ // -----------------------------------------------------------------------------
+ // S60MCprMobilityActivity::TNoTagOrInformMigrationAvailableBackwardsOrErrorOrCancel::TransitionTag
+ // -----------------------------------------------------------------------------
+ //
+ DEFINE_SMELEMENT( TNoTagOrInformMigrationAvailableBackwardsOrErrorOrCancel, NetStateMachine::MStateFork, TContext )
+ TBool TNoTagOrInformMigrationAvailableBackwardsOrErrorOrCancel::TransitionTag()
+ {
+ // Error notification falls into the error -case.
+ if ( iContext.iNodeActivity->Error() )
+ {
+ S60MCPRLOGSTRING1("S60MCPR<%x>::TNoTagOrInformMigrationAvailableBackwardsOrErrorOrCancel::TransitionTag() Error",(TInt*)&iContext.Node());
+ return MeshMachine::KErrorTag | NetStateMachine::EForward;
+ }
+ if ( iContext.iMessage.IsMessage<TCFS60MCPRMessage::TMPMStartIAPNotificationMsg>() )
+ {
+ S60MCPRLOGSTRING1("S60MCPR<%x>::TNoTagOrInformMigrationAvailableBackwardsOrErrorOrCancel::TransitionTag() TMPMStartIAPNotificationMsg",(TInt*)&iContext.Node())
+ return KNoTag | NetStateMachine::EForward;
+ }
+ if ( iContext.iMessage.IsMessage<TCFS60MCPRMessage::TMPMPreferredCarrierAvailableMsg>() )
+ {
+ S60MCPRLOGSTRING1("S60MCPR<%x>::TNoTagOrInformMigrationAvailableBackwardsOrErrorOrCancel::TransitionTag() TMPMPreferredCarrierAvailableMsg",(TInt*)&iContext.Node())
+ return S60MCprStates::KInformMigrationAvailable | NetStateMachine::EBackward;
+ }
+ // else cancel
+ return KCancelTag | NetStateMachine::EForward;
+ }
+
+
+ // -----------------------------------------------------------------------------
+ // S60MCprMobilityActivity::TStartMobilityHandshakeBackwardsOrError::TransitionTag
+ // -----------------------------------------------------------------------------
+ //
+ DEFINE_SMELEMENT( TStartMobilityHandshakeBackwardsOrError, NetStateMachine::MStateFork, TContext )
+ TBool TStartMobilityHandshakeBackwardsOrError::TransitionTag()
+ {
+ if ( iContext.iNodeActivity->Error() )
+ {
+ S60MCPRLOGSTRING1("S60MCPR<%x>::TStartMobilityHandshakeBackwardsOrError::TransitionTag() KErrorTag",(TInt*)&iContext.Node())
+ return MeshMachine::KErrorTag | NetStateMachine::EForward;
+ }
+ S60MCPRLOGSTRING1("S60MCPR<%x>::TStartMobilityHandshakeBackwardsOrError::TransitionTag() KStartMobilityHandshake",(TInt*)&iContext.Node())
+ return MobilityMCprStates::KStartMobilityHandshake | NetStateMachine::EBackward;
+ }
+
+
+ // -----------------------------------------------------------------------------
+ // S60MCprMobilityActivity::TInformMigrationAvailableOrCancelTag::TransitionTag
+ // -----------------------------------------------------------------------------
+ //
+ DEFINE_SMELEMENT( TInformMigrationAvailableOrCancelTag, NetStateMachine::MStateFork, TContext )
+ TBool TInformMigrationAvailableOrCancelTag::TransitionTag()
+ {
+ if ( iContext.iMessage.IsMessage<TEBase::TCancel>() )
+ {
+ S60MCPRLOGSTRING1("S60MCPR<%x>::TInformMigrationAvailableOrCancelTag::TransitionTag() KCancelTag",(TInt*)&iContext.Node())
+ return KCancelTag | NetStateMachine::EForward;
+ }
+ else if ( iContext.iMessage.IsMessage<TCFMobilityProvider::TMigrationRejected>() )
+ {
+ S60MCPRLOGSTRING1("S60MCPR<%x>::TInformMigrationAvailableOrCancelTag::TransitionTag() KSendInitialApplicationReject",
+ (TInt*)&iContext.Node())
+ return S60MCprStates::KSendInitialApplicationReject | NetStateMachine::EForward;
+ }
+ else
+ {
+ S60MCPRLOGSTRING1("S60MCPR<%x>::TInformMigrationAvailableOrCancelTag::TransitionTag() KInformMigrationAvailable",(TInt*)&iContext.Node())
+ return S60MCprStates::KInformMigrationAvailable | NetStateMachine::EForward;
+ }
+ }
+
+
+ // -----------------------------------------------------------------------------
+ // S60MCprMobilityActivity::TNoTagOrErrorTagOrApplicationRejected::TransitionTag
+ // -----------------------------------------------------------------------------
+ //
+ DEFINE_SMELEMENT( TNoTagOrErrorTagOrApplicationRejected, NetStateMachine::MStateFork, TContext )
+ TBool TNoTagOrErrorTagOrApplicationRejected::TransitionTag()
+ {
+ if ( iContext.iNodeActivity->Error() )
+ {
+ S60MCPRLOGSTRING1("S60MCPR<%x>::TNoTagOrErrorTagOrApplicationRejected::TransitionTag() KErrorTag",(TInt*)&iContext.Node())
+ return MeshMachine::KErrorTag | NetStateMachine::EForward;
+ }
+ if ( message_cast<TCFMobilityProvider::TMigrationAccepted>(&iContext.iMessage) )
+ {
+ S60MCPRLOGSTRING1("S60MCPR<%x>::TNoTagOrErrorTagOrApplicationRejected::TransitionTag() KNoTag",(TInt*)&iContext.Node())
+ return MeshMachine::KNoTag | NetStateMachine::EForward;
+ }
+ else if ( message_cast<TCFMobilityProvider::TMigrationRejected>(&iContext.iMessage) )
+ {
+ S60MCPRLOGSTRING1("S60MCPR<%x>::TNoTagOrErrorTagOrApplicationRejected::TransitionTag() KApplicationRejectedMigration",(TInt*)&iContext.Node())
+ return S60MCprStates::KApplicationRejectedMigration | NetStateMachine::EForward;
+ }
+ else
+ {
+ S60MCPRLOGSTRING1("S60MCPR<%x>::TNoTagOrErrorTagOrApplicationRejected::TransitionTag() KCancelTag",(TInt*)&iContext.Node())
+ return MeshMachine::KCancelTag | NetStateMachine::EForward;
+ }
+ }
+
+
+ // -----------------------------------------------------------------------------
+ // S60MCprMobilityActivity::TWaitPolicyServerResponseBackwardOrErrorTag::TransitionTag
+ // -----------------------------------------------------------------------------
+ //
+ DEFINE_SMELEMENT( TWaitPolicyServerResponseBackwardOrErrorTag, NetStateMachine::MStateFork, TContext )
+ TBool TWaitPolicyServerResponseBackwardOrErrorTag::TransitionTag()
+ {
+ if ( iContext.iMessage.IsMessage<TCFS60MCPRMessage::TMPMProcessErrorCompletedMsg>() )
+ {
+ // Make sure policy server doesn't say, reselect.
+ ASSERT( message_cast<TCFS60MCPRMessage::TMPMProcessErrorCompletedMsg>(&iContext.iMessage)->iValue !=
+ (TInt)EDoReselection );
+ // Make sure we're are no longer in error state.
+ iContext.iNodeActivity->SetError( KErrNone );
+ S60MCPRLOGSTRING1("S60MCPR<%x>::TWaitPolicyServerResponseBackwardOrErrorTag::TransitionTag() KWaitPolicyServerResponse",(TInt*)&iContext.Node())
+ return S60MCprStates::KWaitPolicyServerResponse | NetStateMachine::EBackward;
+ }
+ else
+ {
+ S60MCPRLOGSTRING1("S60MCPR<%x>::TWaitPolicyServerResponseBackwardOrErrorTag::TransitionTag() KErrorTag",(TInt*)&iContext.Node())
+ return MeshMachine::KErrorTag | NetStateMachine::EForward;
+ }
+ }
+
+
+ // -----------------------------------------------------------------------------
+ // CS60MobilityActivity::NewL
+ // -----------------------------------------------------------------------------
+ //
+ MeshMachine::CNodeActivityBase* CS60MobilityActivity::NewL( const MeshMachine::TNodeActivity& aActivitySig,
+ MeshMachine::AMMNodeBase& aNode )
+ {
+ CS60MobilityActivity* self = new(ELeave) CS60MobilityActivity( aActivitySig, aNode );
+ return self;
+ }
+
+ // -----------------------------------------------------------------------------
+ // CS60MobilityActivity::CS60MobilityActivity
+ // -----------------------------------------------------------------------------
+ //
+ CS60MobilityActivity::CS60MobilityActivity( const MeshMachine::TNodeActivity& aActivitySig,
+ MeshMachine::AMMNodeBase& aNode )
+ : S60MCprStates::CS60ErrorRecoveryActivity( aActivitySig, aNode )
+ {}
+
+
+ // -----------------------------------------------------------------------------
+ // CS60MobilityActivity::TInformMigrationAvailableAndSetHandshakingFlag::DoL
+ // -----------------------------------------------------------------------------
+ //
+ DEFINE_SMELEMENT( CS60MobilityActivity::TInformMigrationAvailableAndSetHandshakingFlag,
+ NetStateMachine::MStateTransition,
+ CS60MobilityActivity::TContext )
+ void CS60MobilityActivity::TInformMigrationAvailableAndSetHandshakingFlag::DoL()
+ {
+ S60MCPRLOGSTRING1("S60MCPR<%x>::TInformMigrationAvailableAndSetHandshakingFlag::DoL()",(TInt*)&iContext.Node())
+ __ASSERT_DEBUG(iContext.iNodeActivity, User::Panic(KS60MCprPanic, KPanicNoActivity));
+ CS60MobilityActivity& activity = static_cast<CS60MobilityActivity&>(*iContext.iNodeActivity);
+
+ //Inform the CPR that a potential migration is available. We only support a single data client
+ //in this implementation.
+ __ASSERT_DEBUG(activity.iPreferredAPId, User::Panic(KS60MCprPanic, KPanicNoServiceProvider));
+
+ //Compute all this here to keep EvaluatePreference() as fast as possible
+ activity.iCurrent = static_cast<RMetaServiceProviderInterface*>(
+ iContext.Node().GetFirstClient<TDefaultClientMatchPolicy>(
+ TClientType( TCFClientType::EServProvider, TCFClientType::EStarted )));
+
+ __ASSERT_DEBUG(activity.iCurrent, User::Panic(KS60MCprPanic, KPanicNoServiceProvider));
+/* Not valid ASSERT
+ __ASSERT_DEBUG(activity.iCurrent->ProviderInfo().APId() == activity.iCurrentAssumedAPId,
+ User::Panic(KS60MCprPanic, KPanicInConsistentMCPRState));
+*/
+ // Activity received the necessary information from the policy server earlier
+ // and now holds that information which we'll send to IPCPR.
+ TCFMobilityControlClient::TMigrationNotification msg( activity.iCurrentAssumedAPId,
+ //activity.iCurrent->ProviderInfo().APId(),
+ activity.iPreferredAPId,
+ activity.iIsUpgrade,
+ activity.iIsSeamless );
+
+ activity.PostToOriginators(msg);
+ activity.ClearPostedTo();
+ activity.SetHandshakingFlag();
+ }
+
+
+ // -----------------------------------------------------------------------------
+ // CS60MobilityActivity::TSendMigrationRejected::DoL
+ // -----------------------------------------------------------------------------
+ //
+ DEFINE_SMELEMENT( CS60MobilityActivity::TSendMigrationRejected,
+ NetStateMachine::MStateTransition,
+ CS60MobilityActivity::TContext )
+ void CS60MobilityActivity::TSendMigrationRejected::DoL()
+ {
+ S60MCPRLOGSTRING1("S60MCPR<%x>::TSendMigrationRejected::DoL()",(TInt*)&iContext.Node())
+ CS60MetaConnectionProvider& node = (CS60MetaConnectionProvider&)iContext.Node();
+ CS60MobilityActivity& activity = static_cast<CS60MobilityActivity&>(*iContext.iNodeActivity);
+ node.Policy()->ApplicationIgnoredTheCarrierL( activity.iPreferredAPId );
+ }
+
+
+ // -----------------------------------------------------------------------------
+ // CS60MobilityActivity::TSendMigrationAccepted::DoL
+ // -----------------------------------------------------------------------------
+ //
+ DEFINE_SMELEMENT( CS60MobilityActivity::TSendMigrationAccepted,
+ NetStateMachine::MStateTransition,
+ CS60MobilityActivity::TContext )
+ void CS60MobilityActivity::TSendMigrationAccepted::DoL()
+ {
+ S60MCPRLOGSTRING1("S60MCPR<%x>::TSendMigrationAccepted::DoL()",(TInt*)&iContext.Node())
+ CS60MetaConnectionProvider& node = (CS60MetaConnectionProvider&)iContext.Node();
+ CS60MobilityActivity& activity = static_cast<CS60MobilityActivity&>(*iContext.iNodeActivity);
+ node.Policy()->ApplicationMigratesToCarrierL( activity.iPreferredAPId );
+ }
+
+
+ // -----------------------------------------------------------------------------
+ // CS60MobilityActivity::TSendApplicationAccept::DoL
+ // -----------------------------------------------------------------------------
+ //
+ DEFINE_SMELEMENT( CS60MobilityActivity::TSendApplicationAccept,
+ NetStateMachine::MStateTransition,
+ CS60MobilityActivity::TContext )
+ void CS60MobilityActivity::TSendApplicationAccept::DoL()
+ {
+ S60MCPRLOGSTRING1("S60MCPR<%x>::TSendApplicationAccept::DoL()",(TInt*)&iContext.Node())
+ CS60MetaConnectionProvider& node = (CS60MetaConnectionProvider&)iContext.Node();
+ CS60MobilityActivity& activity = static_cast<CS60MobilityActivity&>(*iContext.iNodeActivity);
+ node.Policy()->ApplicationAcceptedTheCarrierL( activity.iPreferredAPId );
+ }
+
+
+ // -----------------------------------------------------------------------------
+ // CS60MobilityActivity::TSendApplicationReject::DoL
+ // -----------------------------------------------------------------------------
+ //
+ DEFINE_SMELEMENT( CS60MobilityActivity::TSendApplicationReject,
+ NetStateMachine::MStateTransition,
+ CS60MobilityActivity::TContext )
+ void CS60MobilityActivity::TSendApplicationReject::DoL()
+ {
+ S60MCPRLOGSTRING1("S60MCPR<%x>::TSendApplicationReject::DoL()",(TInt*)&iContext.Node())
+ CS60MetaConnectionProvider& node = (CS60MetaConnectionProvider&)iContext.Node();
+ CS60MobilityActivity& activity = static_cast<CS60MobilityActivity&>(*iContext.iNodeActivity);
+ node.Policy()->ApplicationRejectedTheCarrierL( activity.iPreferredAPId );
+ }
+
+
+ // -----------------------------------------------------------------------------
+ // CS60MobilityActivity::TClearHandshakingFlag::DoL
+ // -----------------------------------------------------------------------------
+ //
+ DEFINE_SMELEMENT( CS60MobilityActivity::TClearHandshakingFlag,
+ NetStateMachine::MStateTransition, CS60MobilityActivity::TContext )
+ void CS60MobilityActivity::TClearHandshakingFlag::DoL()
+ {
+ S60MCPRLOGSTRING1("S60MCPR<%x>::TClearHandshakingFlag::DoL()",(TInt*)&iContext.Node())
+ __ASSERT_DEBUG(iContext.iNodeActivity, User::Panic(KS60MCprPanic, KPanicNoActivity));
+ CS60MobilityActivity& activity = static_cast<CS60MobilityActivity&>(*iContext.iNodeActivity);
+ activity.ClearHandshakingFlag();
+ }
+
+
+ // -----------------------------------------------------------------------------
+ // CS60MobilityActivity::TInformMigrationCompleted::DoL
+ // -----------------------------------------------------------------------------
+ //
+ DEFINE_SMELEMENT( CS60MobilityActivity::TInformMigrationCompleted,
+ NetStateMachine::MStateTransition, CS60MobilityActivity::TContext )
+ void CS60MobilityActivity::TInformMigrationCompleted::DoL()
+ {
+ S60MCPRLOGSTRING1("S60MCPR<%x>::TInformMigrationCompleted::DoL()",(TInt*)&iContext.Node())
+ __ASSERT_DEBUG(iContext.iNodeActivity, User::Panic(KS60MCprPanic, KPanicNoActivity));
+ iContext.iNodeActivity->PostToOriginators(TCFMobilityProvider::TMigrationComplete().CRef());
+ iContext.iNodeActivity->ClearPostedTo();
+ }
+
+
+ // -----------------------------------------------------------------------------
+ // CS60MobilityActivity::TCancelMobilityActivity::DoL
+ // -----------------------------------------------------------------------------
+ //
+ DEFINE_SMELEMENT( CS60MobilityActivity::TCancelMobilityActivity,
+ NetStateMachine::MStateTransition, CS60MobilityActivity::TContext )
+ void CS60MobilityActivity::TCancelMobilityActivity::DoL()
+ {
+ S60MCPRLOGSTRING1("S60MCPR<%x>::TCancelAvailabilityRequest::DoL()",(TInt*)&iContext.Node())
+ CS60MetaConnectionProvider& node = (CS60MetaConnectionProvider&)iContext.Node();
+ // Unregister from preferred IAP Notifications.
+ //
+ node.Policy()->UnregisterPreferredIAPNotificationL();
+ // Clear the mobility handshaking flag.
+ //
+ CS60MobilityActivity& activity = static_cast<CS60MobilityActivity&>(*iContext.iNodeActivity);
+ activity.ClearHandshakingFlag();
+ // At last we must set the activity in error since we're ready to go down.
+ //
+ iContext.iNodeActivity->SetError( KErrCancel );
+ }
+
+
+ // -----------------------------------------------------------------------------
+ // CS60MobilityActivity::TAwaitingPreferredCarrierOrCancelOrRejected::Accept
+ // -----------------------------------------------------------------------------
+ //
+ DEFINE_SMELEMENT( CS60MobilityActivity::TAwaitingPreferredCarrierOrCancelOrRejected,
+ NetStateMachine::MState, TContext )
+ TBool CS60MobilityActivity::TAwaitingPreferredCarrierOrCancelOrRejected::Accept()
+ {
+ TBool result( EFalse );
+
+ if ( iContext.iMessage.IsMessage<TCFS60MCPRMessage::TMPMPreferredCarrierAvailableMsg>() )
+ {
+ CS60MobilityActivity& activity = static_cast<CS60MobilityActivity&>(*iContext.iNodeActivity);
+
+ TCFS60MCPRMessage::TMPMPreferredCarrierAvailableMsg* msg =
+ message_cast<TCFS60MCPRMessage::TMPMPreferredCarrierAvailableMsg>( &iContext.iMessage );
+
+ TMpmNotificationPrefIAPAvailable* notif = (TMpmNotificationPrefIAPAvailable*)msg->iPtr;
+
+ S60MCPRLOGSTRING4("S60MCPR<%x>::TAwaitingPreferredCarrierOrCancelOrRejected::Accept() TMPMPreferredCarrierAvailableMsg %d -> %d upgrade=%d",
+ (TInt*)&iContext.Node(), notif->iOldIapId, notif->iNewIapId, notif->iIsUpgrade)
+ // notif must be there.
+ ASSERT(notif);
+
+ // Message received ok, clear the pending preferred IAP.
+ //
+ ((CS60MetaConnectionProvider&)iContext.Node()).ClearPolicyNotification();
+
+ // Store the message preferences.
+ //
+ activity.iPreferredAPId = notif->iNewIapId;
+ activity.iCurrentAssumedAPId = notif->iOldIapId;
+ activity.iIsUpgrade = notif->iIsUpgrade;
+ activity.iIsSeamless = notif->iIsSeamless;
+
+ result = ETrue;
+ }
+ else if ( iContext.iMessage.IsMessage<TEBase::TCancel>() )
+ {
+ S60MCPRLOGSTRING1("S60MCPR<%x>::TAwaitingPreferredCarrierOrCancelOrRejected::Accept() TCancel",
+ (TInt*)&iContext.Node())
+
+ result = ETrue;
+ }
+ else if ( iContext.iMessage.IsMessage<TCFMobilityProvider::TMigrationRejected>() )
+ {
+ S60MCPRLOGSTRING1("S60MCPR<%x>::TAwaitingPreferredCarrierOrCancelOrRejected::Accept() TMigrationRejected",
+ (TInt*)&iContext.Node())
+
+ result = ETrue;
+ }
+
+ return result;
+ }
+
+
+ // -----------------------------------------------------------------------------
+ // CS60MobilityActivity::TAwaitingPreferredCarrierOrStartIAPNotificationOrErrorNotificationOrCancel::Accept
+ // -----------------------------------------------------------------------------
+ //
+ DEFINE_SMELEMENT( CS60MobilityActivity::TAwaitingPreferredCarrierOrStartIAPNotificationOrErrorNotificationOrCancel,
+ NetStateMachine::MState,
+ CS60MobilityActivity::TContext )
+ TBool CS60MobilityActivity::TAwaitingPreferredCarrierOrStartIAPNotificationOrErrorNotificationOrCancel::Accept()
+ {
+ CS60MetaConnectionProvider& node = (CS60MetaConnectionProvider&)iContext.Node();
+ // Clear the pending at the end if the msg was accepted.
+ //
+ TBool result( EFalse );
+
+ if ( iContext.iMessage.IsMessage<TCFS60MCPRMessage::TMPMErrorNotificationMsg>() )
+ {
+ CS60MobilityActivity& activity = static_cast<CS60MobilityActivity&>(*iContext.iNodeActivity);
+ TCFS60MCPRMessage::TMPMErrorNotificationMsg* msg =
+ message_cast<TCFS60MCPRMessage::TMPMErrorNotificationMsg>( &iContext.iMessage );
+ S60MCPRLOGSTRING2("S60MCPR<%x>::TAwaitingPreferredCarrierOrStartIAPNotificationOrErrorNotificationOrCancel::Accept() TMPMErrorNotificationMsg %d",(TInt*)&iContext.Node(),msg->iValue)
+ ASSERT( msg->iValue != KErrNone );
+ activity.SetError( msg->iValue );
+ result = ETrue;
+ }
+
+ if ( iContext.iMessage.IsMessage<TCFS60MCPRMessage::TMPMPreferredCarrierAvailableMsg>() )
+ {
+ CS60MobilityActivity& activity = static_cast<CS60MobilityActivity&>(*iContext.iNodeActivity);
+
+ TCFS60MCPRMessage::TMPMPreferredCarrierAvailableMsg* msg =
+ message_cast<TCFS60MCPRMessage::TMPMPreferredCarrierAvailableMsg>( &iContext.iMessage );
+
+ TMpmNotificationPrefIAPAvailable* notif = (TMpmNotificationPrefIAPAvailable*)msg->iPtr;
+
+ S60MCPRLOGSTRING4("S60MCPR<%x>::TAwaitingPreferredCarrierOrStartIAPNotificationOrErrorNotificationOrCancel::Accept() TMPMPreferredCarrierAvailableMsg %d -> %d upgrade=%d",
+ (TInt*)&iContext.Node(), notif->iOldIapId, notif->iNewIapId, notif->iIsUpgrade)
+
+ // info must be there.
+ ASSERT(notif);
+
+ activity.iPreferredAPId = notif->iNewIapId;
+ activity.iCurrentAssumedAPId = notif->iOldIapId;
+ activity.iIsUpgrade = notif->iIsUpgrade;
+ activity.iIsSeamless = notif->iIsSeamless;
+ result = ETrue;
+ }
+
+ if ( iContext.iMessage.IsMessage<TCFS60MCPRMessage::TMPMStartIAPNotificationMsg>() )
+ {
+ TCFS60MCPRMessage::TMPMStartIAPNotificationMsg* msg =
+ message_cast<TCFS60MCPRMessage::TMPMStartIAPNotificationMsg>( &iContext.iMessage );
+
+ CS60MetaConnectionProvider& node = (CS60MetaConnectionProvider&)iContext.Node();
+
+ S60MCPRLOGSTRING2("S60MCPR<%x>::TAwaitingPreferredCarrierOrStartIAPNotificationOrErrorNotificationOrCancel::Accept() TMPMStartIAPNotificationMsg IAP=%d NET=%d",(TInt*)&iContext.Node(), msg->iValue)
+
+ node.PolicyPrefs().SetIapId( msg->iValue );
+ result = ETrue;
+ }
+
+ if ( iContext.iMessage.IsMessage<TEBase::TCancel>() )
+ {
+ S60MCPRLOGSTRING1("S60MCPR<%x>::TAwaitingPreferredCarrierOrStartIAPNotificationOrErrorNotificationOrCancel::Accept() TCancel",(TInt*)&iContext.Node())
+ // There's nothing to cancel as we're waiting for notification only.
+ // Cancelling the notifications in standard cancel-transition is enough.
+ result = ETrue;
+ }
+
+ // Ok, we can clear the msg.
+ //
+ if ( result )
+ {
+ // Clear.
+ node.ClearPolicyNotification();
+ }
+
+ // other messages.
+ //
+ return result;
+ }
+
+
+ // -----------------------------------------------------------------------------
+ // CS60MobilityActivity::TNoTagOrErrorTagOrApplicationRejectedMigrationOrCancel::TransitionTag
+ // -----------------------------------------------------------------------------
+ //
+ DEFINE_SMELEMENT( CS60MobilityActivity::TNoTagOrApplicationRejectedMigrationOrCancel,
+ NetStateMachine::MStateFork, CS60MobilityActivity::TContext )
+ TInt CS60MobilityActivity::TNoTagOrApplicationRejectedMigrationOrCancel::TransitionTag()
+ {
+ if ( message_cast<TCFMobilityProvider::TMigrationRequested>(&iContext.iMessage) )
+ {
+ S60MCPRLOGSTRING1("S60MCPR<%x>::TNoTagOrApplicationRejectedMigrationOrCancel::TransitionTag() KNoTag",(TInt*)&iContext.Node())
+ return MeshMachine::KNoTag | NetStateMachine::EForward;
+ }
+ if ( message_cast<TCFMobilityProvider::TMigrationRejected>(&iContext.iMessage) )
+ {
+ S60MCPRLOGSTRING1("S60MCPR<%x>::TNoTagOrApplicationRejectedMigrationOrCancel::TransitionTag() KApplicationRejectedMigration",(TInt*)&iContext.Node())
+ return S60MCprStates::KApplicationRejectedMigration | NetStateMachine::EForward;
+ }
+ if ( message_cast<TEBase::TCancel>(&iContext.iMessage) )
+ {
+ S60MCPRLOGSTRING1("S60MCPR<%x>::TNoTagOrApplicationRejectedMigrationOrCancel::TransitionTag() KCancelTag Generating ApplicationIgnoredTheCarrier",(TInt*)&iContext.Node())
+
+ // Need to put MPM in consistent state and continue.
+ CS60MetaConnectionProvider& node = (CS60MetaConnectionProvider&)iContext.Node();
+ CS60MobilityActivity& activity = static_cast<CS60MobilityActivity&>(*iContext.iNodeActivity);
+ TRAP_IGNORE( node.Policy()->ApplicationIgnoredTheCarrierL( activity.iPreferredAPId ) );
+
+ return MeshMachine::KCancelTag | NetStateMachine::EForward;
+ }
+/* else
+ {
+ S60MCPRLOGSTRING1("S60MCPR<%x>::TNoTagOrErrorTagOrApplicationRejectedMigrationOrCancel::TransitionTag() Generating ApplicationIgnoredTheCarrier", (TInt*)&iContext.Node() );
+
+ // Need to put MPM in consistent state and continue.
+ CS60MetaConnectionProvider& node = (CS60MetaConnectionProvider&)iContext.Node();
+ CS60MobilityActivity& activity = static_cast<CS60MobilityActivity&>(*iContext.iNodeActivity);
+ TRAP_IGNORE( node.Policy()->ApplicationIgnoredTheCarrierL( activity.iPreferredAPId ) );
+
+ if ( iContext.iNodeActivity->Error() == KErrNone )
+ {
+ ASSERT(EFalse); // should not happend
+ iContext.iNodeActivity->SetError( KErrGeneral ); // doesn't have effect if already set.
+ return MeshMachine::KErrorTag | NetStateMachine::EForward;
+ }
+
+ return MeshMachine::KErrorTag | NetStateMachine::EForward;
+ }*/
+ S60MCPRLOGSTRING1("S60MCPR<%x>::TNoTagOrApplicationRejectedMigrationOrCancel::TransitionTag() KErrorTag ESock_IP Panic",(TInt*)&iContext.Node())
+ ASSERT(EFalse); // error, IPCPR should not send TError in this case.
+ return MeshMachine::KErrorTag | NetStateMachine::EForward;
+ }
+
+
+ // -----------------------------------------------------------------------------
+ // CS60MobilityActivity::ClearHandshakingFlag
+ // -----------------------------------------------------------------------------
+ //
+ void CS60MobilityActivity::SetHandshakingFlag()
+ {
+ static_cast<CS60MetaConnectionProvider&>(iNode).SetHandshakingFlag();
+ }
+
+
+ // -----------------------------------------------------------------------------
+ // CS60MobilityActivity::ClearHandshakingFlag
+ // -----------------------------------------------------------------------------
+ //
+ void CS60MobilityActivity::ClearHandshakingFlag()
+ {
+ static_cast<CS60MetaConnectionProvider&>(iNode).ClearHandshakingFlag();
+ }
+
+
+ // -----------------------------------------------------------------------------
+ // CS60MobilityActivity::TConnectionRecoveryOrMobilityPreferenceOrErrorMutex::IsBlocked
+ // -----------------------------------------------------------------------------
+ //
+ TBool CS60MobilityActivity::TConnectionRecoveryOrMobilityPreferenceOrErrorMutex::IsBlocked( MeshMachine::TNodeContextBase& aContext )
+ {
+ if ( aContext.iNode.CountActivities( ECFActivityConnectionStartRecovery ) != 0 ||
+ aContext.iNode.CountActivities( ECFActivityConnectionGoneDownRecovery ) != 0 )
+ {
+ S60MCPRLOGSTRING1("S60MCPR<%x>::TConnectionRecoveryOrMobilityPreferenceOrErrorMutex::IsBlocked() BLOCKED!",(TInt*)&aContext.Node())
+ return ETrue;
+ }
+ // In all other cases we have received a preferred carrier available from
+ // policy server and we need to act on it.
+ return EFalse;
+ }
+
+ } // namespace S60MCprMobilityActivity
+
+// End of File
+