diff -r 000000000000 -r 5a93021fdf25 alwayson_net_plugin/pdpcontextmanager2/src/caoserver.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/alwayson_net_plugin/pdpcontextmanager2/src/caoserver.cpp	Thu Dec 17 08:55:21 2009 +0200
@@ -0,0 +1,1003 @@
+/*
+* Copyright (c) 2004,2006 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:  Implements the CAOServer class
+*
+*/
+
+
+// INCLUDE FILES
+#include <mmtsy_names.h>
+
+#include "caoserver.h"
+#include "caoconnectionmanager.h"
+#include "caotimer.h"
+#include "caoraumanager.h"
+#include "caosettings.h"
+#include "caogpds.h"
+#include "taostateinit.h"
+#include "taostatestarting.h"
+#include "taostatedisabled.h"
+#include "taostateconnecting.h"
+#include "taostateconnected.h"
+#include "taostatedisconnected.h"
+#include "taostatewaiting.h"
+#include "taostateunconnected.h"
+#include "taostateresetfactorysettings.h"
+#include "taostateexternalconnection.h"
+#include "logger.h"
+#include "pdpcontextmanagerpskeys.h"
+
+#ifdef LOGGING_ENABLED
+#ifdef LOGGING_MODE_FILE
+#include <f32file.h>
+#endif // LOGGING_MODE_FILE
+#endif // LOGGING_ENABLED
+
+// UNNAMED NAMESPACE FOR LOCAL DEFINITIONS
+namespace
+    {
+    // CONSTANTS
+#ifdef LOGGING_ENABLED
+
+    _LIT( KStateNone,           "None" );
+    _LIT( KStateInit,           "Init" );
+    _LIT( KStateStarting,       "Starting" );
+    _LIT( KStateDisabled,       "Disabled" );
+    _LIT( KStateConnecting,     "Connecting" );
+    _LIT( KStateConnected,      "Connected" );
+    _LIT( KStateDisconnected,   "Disconnected" );
+    _LIT( KStateWaiting,        "Waiting" );
+    _LIT( KStateUnconnected,    "Unconnected" );
+    _LIT( KStateRfs,            "ResetFactorySettings" );
+    _LIT( KStateExtConn,        "ExternalConnection" );
+    _LIT( KStateUnexpected,     "Unexpected" );
+
+#endif // LOGGING_ENABLED
+
+    const TInt KReactivationDelay = 25000000; // 25 seconds
+    const TInt KSetupDelay = 2000000; // 2 seconds
+    _LIT_SECURITY_POLICY_PASS( KPDPAlwaysPass );
+
+#ifdef _DEBUG
+    _LIT( KPanicCat, "AOServ" );
+    
+    // DATA TYPES
+    enum TPanicReason
+        {
+        ENoReason,
+        EPDPAlreadySubscribed,
+        ESetupAlreadyInitiated
+        };
+
+    // LOCAL FUNCTIONS
+    LOCAL_C void Panic( TPanicReason aReason )
+        {
+        User::Panic( KPanicCat, aReason );
+        }
+#endif // _DEBUG
+    
+    
+#ifdef LOGGING_ENABLED
+    LOCAL_C const TDesC& StateToDesC( TAOState::TAOStateName aState )
+        {
+        switch ( aState )
+            {
+            case TAOState::EStateInit:
+                {
+                return KStateInit;
+                }
+            case TAOState::EStateStarting:
+                {
+                return KStateStarting;
+                }
+            case TAOState::EStateDisabled:
+                {
+                return KStateDisabled;
+                }
+            case TAOState::EStateConnecting:
+                {
+                return KStateConnecting;
+                }
+            case TAOState::EStateConnected:
+                {
+                return KStateConnected;
+                }
+            case TAOState::EStateDisconnected:
+                {
+                return KStateDisconnected;
+                }
+            case TAOState::EStateWaiting:
+                {
+                return KStateWaiting;
+                }
+            case TAOState::EStateUnconnected:
+                {
+                return KStateUnconnected;
+                }
+            case TAOState::EStateResetFactorySettings:
+                {
+                return KStateRfs;
+                }
+            case TAOState::EStateExternalConnection:
+                {
+                return KStateExtConn;
+                }
+            default:
+                {
+                return KStateUnexpected;
+                }
+            }
+        }
+#endif // LOGGING_ENABLED
+    }
+
+// METHODS
+
+// ---------------------------------------------------------------------------
+// CAOServer::NewL
+// ---------------------------------------------------------------------------
+//
+CAOServer* CAOServer::NewL()
+    {
+    LOG_1( _L("CAOServer::NewL") );
+    
+    CAOServer* self = new( ELeave ) CAOServer;
+    
+    CleanupStack::PushL( self );
+    self->ConstructL();
+    CleanupStack::Pop( self );
+    
+    return self;
+    }
+
+// ---------------------------------------------------------------------------
+// CAOServer::~CAOServer
+// ---------------------------------------------------------------------------
+//
+CAOServer::~CAOServer()
+    {
+    LOG_1( _L("CAOServer::~CAOServer") );
+
+    delete iAsyncSetup;
+    ReleasePDPProperty();    
+    delete iAsyncReactivation;
+    
+    if ( iPointerStatePool )
+        {
+        iPointerStatePool->ResetAndDestroy();
+        delete iPointerStatePool;    
+        }
+    
+    delete iGpds;
+    delete iRAUManager;
+    delete iTimer;
+    delete iConnectionManager;
+    delete iSettings;
+    
+    iCustomAPI.Close();
+    iMobilePhone.Close();
+    iTelServer.UnloadPhoneModule( KMmTsyModuleName() );
+    iTelServer.Close();
+    }
+
+// ---------------------------------------------------------------------------
+// CAOServer::CAOServer
+// ---------------------------------------------------------------------------
+//
+CAOServer::CAOServer()
+    {
+    LOG_1( _L("CAOServer::CAOServer") );
+    }
+
+// ---------------------------------------------------------------------------
+// CAOServer::ConstructL
+// ---------------------------------------------------------------------------
+//
+void CAOServer::ConstructL()
+    {
+    LOG_1( _L("CAOServer::ConstructL") );
+    
+    // Configure Custom API
+    ConfigureCustomAPIL();
+    
+    // Create services
+    iSettings = CAOSettings::NewL( *this );
+    iConnectionManager = CAOConnectionManager::NewL( *this, *iSettings );
+    iTimer = CAOTimer::NewL( *this, *iSettings );
+
+#ifdef __ALWAYS_ON_CUSTOM_API
+
+    iRAUManager = CAORAUManager::NewL( *this, iCustomAPI );
+    
+#else
+
+    iRAUManager = CAORAUManager::NewL( *this );
+
+#endif // __ALWAYS_ON_CUSTOM_API
+    
+    iGpds = CAOGpds::NewL( iCustomAPI );
+    
+    InitStatePoolL();
+        
+    // Set current state to 'init'
+    iCurrentState = ChangeState( TAOState::EStateInit );
+    
+    // Init timers
+    iAsyncReactivation = CPeriodic::NewL( CActive::EPriorityStandard );
+    iAsyncSetup = CPeriodic::NewL( CActive::EPriorityStandard );
+    
+    // Create PDP property observer
+    CreatePDPPropertyAndSubscribeL();
+    
+    // Setup Always-On server
+    Setup();
+    }
+
+// ---------------------------------------------------------------------------
+// CAOServer::Setup
+// ---------------------------------------------------------------------------
+//
+void CAOServer::Setup()
+    {
+    LOG_1( _L("CAOServer::SetupL") );
+    
+    __ASSERT_DEBUG( !iAsyncSetup->IsActive(), 
+                    Panic( ESetupAlreadyInitiated ) );
+    
+    TCallBack cb( SetupCallBack, this );
+    iAsyncSetup->Start( KSetupDelay, KSetupDelay, cb );
+    }
+
+// ---------------------------------------------------------------------------
+// CAOServer::ReactivationCallBack
+// ---------------------------------------------------------------------------
+//
+TInt CAOServer::ReactivationCallBack( TAny* aSelf )
+    {
+    LOG_1( _L("CAOServer::ReactivationCallBack") );
+    
+    TRAP_IGNORE( static_cast<CAOServer*>( aSelf )->HandleReactivationL() );
+    return KErrNone;
+    }
+
+// ---------------------------------------------------------------------------
+// CAOServer::HandleReactivationL
+// ---------------------------------------------------------------------------
+//
+void CAOServer::HandleReactivationL()
+    {
+    LOG_1( _L("CAOServer::HandleReactivationL") );
+    
+    iAsyncReactivation->Cancel();
+    
+    TAOState* newState =
+        iCurrentState->HandleSwitchFromDisconnectedL( iFailure );
+    if ( newState )
+        {
+        iCurrentState = newState;
+        }
+    }
+
+// ---------------------------------------------------------------------------
+// CAOServer::DoReactivation
+// ---------------------------------------------------------------------------
+//
+void CAOServer::DoReactivation( MAOConnectionManager::TFailureReason aReason )
+    {
+    LOG_1( _L("CAOServer::DoReactivation") );
+    
+    // If we are not already re-activating
+    if ( !iAsyncReactivation->IsActive() )
+        {
+        iFailure = aReason;
+        TCallBack cb( ReactivationCallBack, this );
+        iAsyncReactivation->Start(
+            KReactivationDelay, KReactivationDelay, cb );
+        }
+    }
+
+// ---------------------------------------------------------------------------
+// CAOServer::IssuePDPPropertySubscription
+// ---------------------------------------------------------------------------
+//
+void CAOServer::IssuePDPPropertySubscription()
+    {
+    LOG_1( _L("CAOServer::IssuePDPPropertySubscription") );
+    
+    __ASSERT_DEBUG( !iPDPPropertySubscriber->IsActive(),
+        Panic( EPDPAlreadySubscribed ) );
+    
+    iPDPPropertySubscriber->IssueRequest();
+    }
+// ---------------------------------------------------------------------------
+// CAOServer::PDPPropertySubscriptionIssueRequest
+// ---------------------------------------------------------------------------
+//
+void CAOServer::PDPPropertySubscriptionIssueRequest( TRequestStatus& aStatus )
+    {
+    LOG_1( _L("CAOServer::PDPPropertySubscriptionIssueRequest") );
+    
+    iPDPProperty.Subscribe( aStatus );
+    }
+
+// ---------------------------------------------------------------------------
+// CAOServer::PDPPropertySubscriptionRunL
+// ---------------------------------------------------------------------------
+//
+void CAOServer::PDPPropertySubscriptionRunL( TInt aStatus )
+    {
+    LOG_2( _L("CAOServer::PDPPropertySubscriptionRunL: aStatus: %d"),
+        aStatus );
+    
+    if ( aStatus == KErrNone )
+        {
+        TInt val = 0;
+        TInt err = iPDPProperty.Get(
+            KPDPContextManager2,
+            KPDPContextManagerFactorySettingsReset,
+            val );
+            
+        TAOState* newState = NULL;
+        if ( err == KErrNone )
+            {
+            if ( val == EPDPContextManagerFactorySettingsResetStart )
+                {
+                newState =
+                    iCurrentState->HandleResetFactorySettingsL( ETrue );
+                }
+            else if ( val == EPDPContextManagerFactorySettingsResetStop )
+                {
+                newState =
+                    iCurrentState->HandleResetFactorySettingsL( EFalse );
+                }
+            }
+        if ( newState )
+            {
+            iCurrentState = newState;
+            }
+        }
+    IssuePDPPropertySubscription();
+    }
+
+// ---------------------------------------------------------------------------
+// CAOServer::PDPPropertySubscriptionDoCancel
+// ---------------------------------------------------------------------------
+//
+void CAOServer::PDPPropertySubscriptionDoCancel()
+    {
+    LOG_1( _L("CAOServer::PDPPropertySubscriptionDoCancel") );
+    
+    iPDPProperty.Cancel();
+    }
+
+// ---------------------------------------------------------------------------
+// CAOServer::ReleasePDPProperty
+// ---------------------------------------------------------------------------
+//
+void CAOServer::ReleasePDPProperty()
+    {
+    LOG_1( _L("CAOServer::ReleasePDPProperty") );
+    
+    delete iPDPPropertySubscriber;
+    iPDPProperty.Delete(
+        KPDPContextManager2,
+        KPDPContextManagerFactorySettingsReset );
+    iPDPProperty.Close();
+    }
+
+// ---------------------------------------------------------------------------
+// CAOServer::CreatePDPPropertyAndSubscribeL
+// ---------------------------------------------------------------------------
+//
+void CAOServer::CreatePDPPropertyAndSubscribeL()
+    {
+    LOG_1( _L("CAOServer::CreatePDPPropertyAndSubscribeL") );
+
+    // Define PDP property
+    TInt err = iPDPProperty.Define(
+        KPDPContextManager2,
+        KPDPContextManagerFactorySettingsReset,
+        RProperty::EInt,
+        KPDPAlwaysPass,
+        KPDPAlwaysPass,
+        0 );
+    LOG_2( _L("> Property define: %d"), err );
+    if ( err != KErrAlreadyExists )
+        {
+        User::LeaveIfError( err );
+        }
+    
+    // Attach to property
+    err = iPDPProperty.Attach(
+        KPDPContextManager2,
+        KPDPContextManagerFactorySettingsReset );
+    LOG_2( _L("> Property attach: %d"), err );
+    User::LeaveIfError( err );
+        
+    // Create property subscriber
+    iPDPPropertySubscriber = CAOAsyncWrapper<CAOServer>::NewL(
+        this,
+        &PDPPropertySubscriptionIssueRequest,
+        &PDPPropertySubscriptionRunL,
+        &PDPPropertySubscriptionDoCancel,
+        NULL );
+        
+    // Subscribe
+    IssuePDPPropertySubscription();
+    }
+
+// ---------------------------------------------------------------------------
+// CAOServer::SetupCallBack
+// ---------------------------------------------------------------------------
+//
+TInt CAOServer::SetupCallBack( TAny* aSelf )
+    {
+    LOG_1( _L("CAOServer::SetupCallBack") );
+    
+    CAOServer* server = static_cast<CAOServer*>( aSelf );
+    TRAPD( err, server->HandleSetup() );
+    return err;
+    }
+
+// ---------------------------------------------------------------------------
+// CAOServer::HandleSetupL
+// ---------------------------------------------------------------------------
+//
+void CAOServer::HandleSetup()
+    {
+    LOG_1( _L("CAOServer::HandleSetup") );
+    
+    iAsyncSetup->Cancel();
+    
+    // Fetch settings and network registration status
+    iSettings->FetchSettings();
+    iConnectionManager->FetchNetworkRegistrationStatus();
+    }
+
+// ---------------------------------------------------------------------------
+// CAOServer::ConfigureCustomAPIL
+// ---------------------------------------------------------------------------
+//
+void CAOServer::ConfigureCustomAPIL()
+    {
+    LOG_1( _L("CAOServer::ConfigureCustomAPIL") );
+    
+    // Connect tel server
+    // If not possible to load module and if it not already loaded
+    // no way to recover.
+    User::LeaveIfError( iTelServer.Connect() );
+    TInt err = iTelServer.LoadPhoneModule( KMmTsyModuleName() );
+    if ( err != KErrNone && err != KErrAlreadyExists )
+        {
+        User::Leave( KErrGeneral );
+        }
+
+    // Open mobile phone and custom API
+    User::LeaveIfError( iMobilePhone.Open( iTelServer, KMmTsyPhoneName() ) );
+    User::LeaveIfError( iCustomAPI.Open( iMobilePhone ) );
+    }
+
+// ---------------------------------------------------------------------------
+// CAOServer::ConnectionManager
+// ---------------------------------------------------------------------------
+//
+MAOConnectionManager& CAOServer::ConnectionManager() const
+    {
+    LOG_1( _L("CAOServer::ConnectionManager") );
+    
+    return *iConnectionManager;
+    }
+
+// ---------------------------------------------------------------------------
+// CAOServer::Timer
+// ---------------------------------------------------------------------------
+//
+MAOTimer& CAOServer::Timer() const
+    {
+    LOG_1( _L("CAOServer::Timer") );
+    
+    return *iTimer;
+    }
+
+// ---------------------------------------------------------------------------
+// CAOServer::RAUManager
+// ---------------------------------------------------------------------------
+//
+MAORAUManager& CAOServer::RAUManager() const
+    {
+    LOG_1( _L("CAOServer::RAUManager") );
+    
+    return *iRAUManager;
+    }
+
+// ---------------------------------------------------------------------------
+// CAOServer::Settings
+// ---------------------------------------------------------------------------
+//
+MAOSettings& CAOServer::Settings() const
+    {
+    LOG_1( _L("CAOServer::Settings") );
+    
+    return *iSettings;
+    }
+
+// ---------------------------------------------------------------------------
+// CAOServer::Gpds
+// ---------------------------------------------------------------------------
+//
+MAOGpds& CAOServer::Gpds() const
+    {
+    LOG_1( _L("CAOServer::Gpds") );
+    
+    return *iGpds;
+    }
+
+// ---------------------------------------------------------------------------
+// CAOServer::ChangeState
+// ---------------------------------------------------------------------------
+//
+TAOState* CAOServer::ChangeState( TAOState::TAOStateName aState )
+    {
+    if ( !iCurrentState )
+        {
+        LOG_3( _L(
+            ">>>> CAOServer::ChangeState: Old state %S > New state %S <<<<" ),
+            &KStateNone, &StateToDesC( aState ) );
+        }
+    else
+        {
+        LOG_3( _L(
+            ">>>> CAOServer::ChangeState: Old state %S > New state %S <<<<" ),
+            &StateToDesC( CurrentState()->StateName() ),
+            &StateToDesC( aState ) );
+        }
+    
+    return (*iPointerStatePool)[aState];
+    }
+
+// ---------------------------------------------------------------------------
+// CAOServer::CurrentState
+// ---------------------------------------------------------------------------
+//
+TAOState* CAOServer::CurrentState() const
+    {
+    LOG_1( _L("CAOServer::CurrentState") );
+    
+    if( !iCurrentState )
+        {
+        LOG_1( _L("CAOServer::CurrentState is NULL !") );
+        }
+    
+    return iCurrentState;
+    }
+
+// ---------------------------------------------------------------------------
+// CAOServer::HandlePDPContextActivatedL
+// ---------------------------------------------------------------------------
+//
+void CAOServer::HandlePDPContextActivatedL()
+    {
+    LOG_1( _L("CAOServer::HandlePDPContextActivatedL") );
+    LOG_2( _L("> Current state: %S"),
+        &StateToDesC( CurrentState()->StateName() ) );
+    
+    TAOState* newState = iCurrentState->HandlePDPContextActivatedL();
+    if ( newState )
+        {
+        iCurrentState = newState;
+        }
+    }
+
+// ---------------------------------------------------------------------------
+// CAOServer::HandlePDPContextActivationFailedL
+// ---------------------------------------------------------------------------
+//
+void CAOServer::HandlePDPContextActivationFailedL(
+    MAOConnectionManager::TFailureReason aReason )
+    {
+    LOG_1( _L("CAOServer::HandlePDPContextActivationFailedL") );
+    LOG_2( _L("> Current state: %S"),
+        &StateToDesC( CurrentState()->StateName() ) );
+        
+    iActivationFailure = ETrue;
+    
+    TAOState* newState = iCurrentState->HandlePDPContextActivationFailedL();
+    if ( newState )
+        {
+        iCurrentState = newState;
+        
+        // If new state is disconnected we need synchronously change to new
+        // state depending from the failure reason
+        if ( CurrentState()->StateName() == TAOState::EStateDisconnected )
+            {
+            newState = iCurrentState->HandleSwitchFromDisconnectedL( 
+                                                                aReason );
+            }
+            
+        // Change state if new state received
+        if ( newState )
+            {
+            iCurrentState = newState;
+            }
+        }
+    }
+
+// ---------------------------------------------------------------------------
+// CAOServer::HandlePDPContextDisconnectedL
+// ---------------------------------------------------------------------------
+//
+void CAOServer::HandlePDPContextDisconnectedL(
+    MAOConnectionManager::TFailureReason aReason )
+    {
+    LOG_1( _L("CAOServer::HandlePDPContextDisconnectedL") );
+    LOG_2( _L("> Current state: %S"),
+        &StateToDesC( CurrentState()->StateName() ) );
+    
+    TAOState* newState =
+        iCurrentState->HandlePDPContextDisconnectedL( aReason );
+    if ( newState )
+        {
+        iCurrentState = newState;
+        
+        // If new state is disconnected we need synchronously change to new
+        // state depending from the failure reason
+        if ( CurrentState()->StateName() == TAOState::EStateDisconnected )
+            {
+            // Do asnyc re-activation to ensure old connection
+            // has really been closed
+            DoReactivation( aReason );
+            }
+        }
+    }
+
+// ---------------------------------------------------------------------------
+// CAOServer::HandlePDPContextTemporarilyBlockedL
+// ---------------------------------------------------------------------------
+//
+void CAOServer::HandlePDPContextTemporarilyBlockedL()
+    {
+    LOG_1( _L("CAOServer::HandlePDPContextTemporarilyBlockedL") );
+    LOG_2( _L("> Current state: %S"),
+        &StateToDesC( CurrentState()->StateName() ) );
+    
+    TAOState* newState = iCurrentState->HandlePDPContextTemporarilyBlockedL();
+    if ( newState )
+        {
+        iCurrentState = newState;
+        }
+    }
+
+// ---------------------------------------------------------------------------
+// CAOServer::HandleNWRegistrationStatusChangedL
+// ---------------------------------------------------------------------------
+//
+void CAOServer::HandleNWRegistrationStatusChangedL(
+    CTelephony::TRegistrationStatus /*aNetworkRegistration*/ )
+    {
+    LOG_1( _L("CAOServer::HandleNWRegistrationStatusChangedL") );
+    LOG_2( _L("> Current state: %S"),
+        &StateToDesC( CurrentState()->StateName() ) );
+    
+    // Get current network type from connection manager
+    MAOConnectionManager::TNetworkType nwType =
+        iConnectionManager->NetworkType();
+        
+    TAOState* newState = iCurrentState->HandleNetworkChangedL( nwType );
+    if ( newState )
+        {
+        iCurrentState = newState;
+        
+        // New state is 'starting'
+        if ( CurrentState()->StateName() == TAOState::EStateStarting )
+            {
+            newState = iCurrentState->HandleEnableAlwaysOnL();
+            }
+        // New state is 'disconnected'
+        else if ( CurrentState()->StateName() == TAOState::EStateDisconnected )
+            {
+            newState = iCurrentState->HandleSwitchFromDisconnectedL(
+                MAOConnectionManager::ETemporary );
+            }
+            
+        // Change state if new state received
+        if ( newState )
+            {
+            iCurrentState = newState;
+            }
+        }
+    }
+
+// ---------------------------------------------------------------------------
+// CAOServer::HandleConnectionDeletedL
+// ---------------------------------------------------------------------------
+//
+void CAOServer::HandleConnectionDeletedL( const TUint /*aConnectionId*/,
+                                          const TBool /*aForward*/ )
+    {
+    LOG_1( _L("CAOServer::HandleConnectionDeletedL") );
+    LOG_2( _L("> Current state: %S"),
+        &StateToDesC( CurrentState()->StateName() ) );
+        
+    // If we currently tried to activate PDP context and it has failed
+    // due temporary or permanent reason do not do anything with
+    // connection deleted notification since notification concerns
+    // the same connection that just failed to activate
+    if ( iActivationFailure )
+        {
+        LOG_1( _L("> Activation failure -> ignore") );
+        iActivationFailure = EFalse;
+        }
+    // If we have not already received disconnect message
+    else if ( !iAsyncReactivation->IsActive() )
+        {
+        LOG_1( _L("> Not an activation failure -> process") );
+        TAOState* newState = iCurrentState->HandleConnectionDeletedL();
+        if ( newState )
+            {
+            iCurrentState = newState;
+            
+            // If new state is disconnected
+            if ( CurrentState()->StateName() == TAOState::EStateDisconnected )
+                {
+                // Do async re-activation
+                DoReactivation( MAOConnectionManager::EDisconnected );
+                }
+            }
+        }
+    // Just to log
+    else
+        {
+        LOG_1( _L("> Already re-activating -> ignore") );
+        }
+    }
+
+// ---------------------------------------------------------------------------
+// CAOServer::HandleExternalConnectionCreatedL
+// ---------------------------------------------------------------------------
+//
+void CAOServer::HandleExternalConnectionCreatedL()
+    {
+    LOG_1( _L("CAOServer::HandleExternalConnectionCreatedL") );
+    LOG_2( _L("> Current state: %S"),
+        &StateToDesC( CurrentState()->StateName() ) );
+        
+    // End possible re-activation
+    iAsyncReactivation->Cancel();
+    TAOState* newState = iCurrentState->HandleExternalConnectionCreatedL();
+    if( newState )
+        {
+        iCurrentState = newState;
+        }
+    }
+    
+// ---------------------------------------------------------------------------
+// CAOServer::HandleInternalConnectionCreatedL
+// ---------------------------------------------------------------------------
+//    
+void CAOServer::HandleInternalConnectionCreatedL( const TUint /*aConnectionId*/,
+                                                  const TUint /*aIapId*/, 
+                                                  const TUint /*aNetId*/ )
+    {
+    }    
+
+// ---------------------------------------------------------------------------
+// CAOServer::HandleError
+// ---------------------------------------------------------------------------
+//
+void CAOServer::HandleError( TInt /*aError*/ )
+    {
+    LOG_1( _L("CAOServer::HandleError") );
+    LOG_2( _L("> Current state: %S"),
+        &StateToDesC( CurrentState()->StateName() ) );
+    
+    TAOState* newState = iCurrentState->HandleGeneralError();
+    if ( newState )
+        {
+        iCurrentState = newState;
+        }
+    }
+
+// ---------------------------------------------------------------------------
+// CAOServer::HandleRetryTimerExpiredL
+// ---------------------------------------------------------------------------
+//
+void CAOServer::HandleRetryTimerExpiredL()
+    {
+    LOG_1( _L("CAOServer::HandleRetryTimerExpiredL") );
+    LOG_2( _L("> Current state: %S"),
+        &StateToDesC( CurrentState()->StateName() ) );
+    
+    TAOState* newState = iCurrentState->HandleRetryTimerTriggeredL();
+    if ( newState )
+        {
+        iCurrentState = newState;
+        }
+    }
+
+// ---------------------------------------------------------------------------
+// CAOServer::HandleConnectionTimerExpiredL
+// ---------------------------------------------------------------------------
+//
+void CAOServer::HandleConnectionTimerExpiredL()
+    {
+    LOG_1( _L("CAOServer::HandleConnectionTimerExpiredL") );
+    LOG_2( _L("> Current state: %S"),
+        &StateToDesC( CurrentState()->StateName() ) );
+    
+    TAOState* newState = iCurrentState->HandleConnectionTimerTriggeredL();
+    if ( newState )
+        {
+        iCurrentState = newState;
+        
+        // Connection timer has trigered maximum amount -> start retry timer
+        if ( iCurrentState->StateName() == TAOState::EStateDisconnected )
+            {
+            newState = iCurrentState->HandleSwitchFromDisconnectedL(
+                MAOConnectionManager::ETemporary );
+            }
+            
+        // Change state if new state received
+        if ( newState )
+            {
+            iCurrentState = newState;
+            }
+        }
+    }
+
+// ---------------------------------------------------------------------------
+// CAOServer::HandleUnconnectTimerExpiredL
+// ---------------------------------------------------------------------------
+//
+void CAOServer::HandleUnconnectTimerExpiredL()
+    {
+    LOG_1( _L("CAOServer::HandleUnconnectTimerExpiredL") );
+    
+    TAOState* newState = iCurrentState->HandleUnconnectTimerExpiredL();
+    if( newState )
+        {
+        iCurrentState = newState;
+        }
+    }
+
+// ---------------------------------------------------------------------------
+// CAOServer::HandleSettingsChangedL
+// ---------------------------------------------------------------------------
+//
+void CAOServer::HandleSettingsChangedL()
+    {
+    LOG_1( _L("CAOServer::HandleSettingsChangedL") );
+
+    // Update retry timer value
+    iTimer->HandleSettingsChangedL();
+    
+    // Handle notification
+    TAOState* newState = iCurrentState->HandleSettingsReceivedL();
+
+    if ( newState )
+        {
+
+        LOG_2( _L("> newState1: %d"), newState->StateName() );
+    
+        iCurrentState = newState;
+        
+        if ( iCurrentState->StateName() == TAOState::EStateStarting )
+            {
+            // If new state is starting check if Always On should be enabled
+            // in current network
+            newState = iCurrentState->HandleEnableAlwaysOnL();
+            }
+            
+        // Change state if new state received
+        if ( newState )
+            {
+            LOG_2( _L("> newState2: %d"), newState->StateName() );
+            iCurrentState = newState;
+            }
+        else
+            {
+            LOG_1( _L("> New state is null2.") );
+            }
+        }
+     else
+        {
+        LOG_1( _L("> New state is null1.") );
+        }
+       
+    // Update linger objects    
+    iConnectionManager->HandleSettingsChangedL();    
+    }
+
+// ---------------------------------------------------------------------------
+// CAOServer::HandleSuccesfulRAUL
+// ---------------------------------------------------------------------------
+//
+void CAOServer::HandleSuccesfulRAUL( TRAUType /*aType*/ )
+    {
+    LOG_1( _L("CAOServer::HandleSuccesfulRAUL") );
+    LOG_2( _L("> Current state: %S"),
+        &StateToDesC( CurrentState()->StateName() ) );
+    
+    TAOState* newState = iCurrentState->HandleSuccesfulRAUEventL();
+    if ( newState )
+        {
+        iCurrentState = newState;
+        }
+    }
+
+
+// ---------------------------------------------------------------------------
+// CAOServer::InitStatePoolL
+// ---------------------------------------------------------------------------
+//
+void CAOServer::InitStatePoolL()
+    {
+    LOG_1( _L("CAOServer::InitStatePoolL") );
+
+    iPointerStatePool = new (ELeave) CArrayPtrFlat<TAOState>( TAOState::EStateLastItem );
+    
+    
+    TAOStateInit *stateInit = new (ELeave) TAOStateInit( *this, *this );
+    CleanupStack::PushL( stateInit );
+    iPointerStatePool->InsertL( TAOState::EStateInit, stateInit );
+    CleanupStack::Pop( stateInit );
+
+    TAOStateStarting *stateStarting = new (ELeave) TAOStateStarting( *this, *this );
+    CleanupStack::PushL( stateStarting );
+    iPointerStatePool->InsertL( TAOState::EStateStarting, stateStarting );
+    CleanupStack::Pop( stateStarting );
+
+    TAOStateDisabled *stateDisabled = new (ELeave) TAOStateDisabled( *this, *this );
+    CleanupStack::PushL( stateDisabled );
+    iPointerStatePool->InsertL( TAOState::EStateDisabled, stateDisabled );
+    CleanupStack::Pop( stateDisabled );
+    
+    TAOStateConnecting *stateConnecting = new (ELeave) TAOStateConnecting( *this, *this );
+    CleanupStack::PushL( stateConnecting );
+    iPointerStatePool->InsertL( TAOState::EStateConnecting, stateConnecting );
+    CleanupStack::Pop( stateConnecting );
+    
+    TAOState *stateConnected = new (ELeave) TAOStateConnected( *this, *this );
+    CleanupStack::PushL( stateConnected );
+    iPointerStatePool->InsertL( TAOState::EStateConnected, stateConnected );
+    CleanupStack::Pop( stateConnected );
+    
+    TAOState *stateDisconnected = new (ELeave) TAOStateDisconnected( *this, *this );
+    CleanupStack::PushL( stateDisconnected );
+    iPointerStatePool->InsertL( TAOState::EStateDisconnected, stateDisconnected );
+    CleanupStack::Pop( stateDisconnected );
+    
+    TAOState *stateWaiting = new (ELeave) TAOStateWaiting( *this, *this );
+    CleanupStack::PushL( stateWaiting );
+    iPointerStatePool->InsertL( TAOState::EStateWaiting, stateWaiting );
+    CleanupStack::Pop( stateWaiting );
+    
+    TAOState *stateUnconnected = new (ELeave) TAOStateUnconnected( *this, *this );
+    CleanupStack::PushL( stateUnconnected );
+    iPointerStatePool->InsertL( TAOState::EStateUnconnected, stateUnconnected );
+    CleanupStack::Pop( stateUnconnected );
+    
+    TAOState *stateResetFactorySettings = new (ELeave) TAOStateResetFactorySettings( *this, *this );
+    CleanupStack::PushL( stateResetFactorySettings );
+    iPointerStatePool->InsertL( TAOState::EStateResetFactorySettings, stateResetFactorySettings );
+    CleanupStack::Pop( stateResetFactorySettings );
+    
+    TAOState *stateExternalConnection = new (ELeave) TAOStateExternalConnection( *this, *this );
+    CleanupStack::PushL( stateExternalConnection );
+    iPointerStatePool->InsertL( TAOState::EStateExternalConnection, stateExternalConnection );
+    CleanupStack::Pop( stateExternalConnection );
+    
+    }
+
+
+// End of file