/*

* 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 <cmgenconnsettings.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 iCenRepObserver;

    delete iGpds;

    delete iRAUManager;

    delete iTimer;

    delete iConnectionManager;

    delete iSettings;

    iCustomAPI.Close();

    iMobilePhone.Close();

    iTelServer.UnloadPhoneModule( KMmTsyModuleName() );

    iTelServer.Close();

    }

// ---------------------------------------------------------------------------

// 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, *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 );

    iCenRepObserver = CAOCenRepObserver::NewL( *this );	

    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,

        &CAOServer::PDPPropertySubscriptionIssueRequest,

        &CAOServer::PDPPropertySubscriptionRunL,

        &CAOServer::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") );