/*

* Copyright (c) 2007 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:

*

*/

#include <centralrepository.h>

#include <commsdattypesv1_1.h>

#include <commdb.h>

#include <commdbconnpref.h>

#include <featdiscovery.h>

#include <features.hrh>

#include <ProfileEngineSDKCRKeys.h>

#include <httpstringconstants.h>

#include <StringLoader.h>

#include <data_caging_path_literals.hrh>

#include <extendedconnpref.h>

#include "irdebug.h"

#include "irfilteredapreader.h"

#include "irnetworkcontroller.h"

#include "irnetworkobserver.h"

#include "irsettings.h"

#include "iractivenetworkobserver.h"

const TInt KMaxIRUAProfLength = 250; // Max length of the UAProf string

const TInt KIRDefaultUAProfBufferSize = 0x80;

const TUint KIRESockMessageSlots = 16;

const TInt KArraySize = 5;

const TInt KWlanStringMaxLength = 9;

const TInt KTwo = 2;

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

//  define in WebUtilsSDKCRKeys.h

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

//

const TUid KCRUidWebUtils = {0x101F8731};//Web APIs removal and Internet Radio build break

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

// define in WebUtilsInternalCRKeys.h

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

//

// Compatability fragment of useragent string

const TUint32 KWebUtilsUsrAg2 =	0x00000001;

// PlatformVersion fragment of useragent string

const TUint32 KWebUtilsUsrAg3 =	0x00000002;

// MidPVersion fragment of useragent string

const TUint32 KWebUtilsUsrAg4 =	0x00000003;

// CLDConfiguration fragment of useragent string

const TUint32 KWebUtilsUsrAg5 =	0x00000004;

// Url to useragent profile

const TUint32 KWebUtilsUaProf =	0x00000008;

// To Format the UAProf string

_LIT( KIRUAProfSpace," " );

// WLan ( generic ) name string

_LIT( KIRWLanName,"Easy WLAN" );

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

//  Creates an Instance of CIRNetworkController

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

//

EXPORT_C CIRNetworkController* CIRNetworkController::OpenL( MIRNetworkController* aObserver )

    {

    IRLOG_DEBUG( "CIRNetworkController::OpenL - Entering" );

    CIRNetworkController* networkController = reinterpret_cast<CIRNetworkController*>( Dll::Tls() );

    if ( !networkController )

        {

        networkController = new ( ELeave ) CIRNetworkController;

        CleanupClosePushL( *networkController );

        networkController->iSingletonInstances = 1;

        networkController->ConstructL( aObserver );

        User::LeaveIfError( Dll::SetTls( networkController ) );

        networkController->iSingletonInstances = 0;

        CleanupStack::Pop( networkController );

        }

    networkController->iSingletonInstances++;

    if ( NULL != aObserver )

        {

        networkController->iObserver = aObserver;

        networkController->iIRNetworkObserver->SetObserver( aObserver );

        }

    IRLOG_DEBUG( "CIRNetworkController::OpenL - Exiting." );

    return networkController;

    }

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

// Conditionally destroys the IRNetworkController object

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

//

EXPORT_C void CIRNetworkController::Close()

    {

    IRLOG_DEBUG2( "CIRNetworkController::Close - singleton instances=%d", iSingletonInstances );

    iSingletonInstances--;

    if ( iSingletonInstances == 0 )

        {

        delete this;

        }

    IRLOG_DEBUG( "CIRNetworkController::Close - Exiting." );

    }

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

//  CIRNetworkController::GetIRConnection

//  Returns the instance of RConnection

//  The same RConnection object is used across the entire iRAPP components to

//  provide central arbiter and monitoring of Network Connection

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

//

EXPORT_C RConnection& CIRNetworkController::GetIRConnection()

    {

    IRLOG_DEBUG( "CIRNetworkController::GetIRConnection - Entering" );

    // If the RConnection is open return the reference

    switch ( iNetworkConnectionState )

        {

        case EIRNetworkConnectionActive:

            {

            // Connection is active and ready to use return the reference

            return ( *iIRNetworkConnection );

            }

        case EIRNetworkConnectionInActive:

            {

            // Connection is not active and application cannot continue hence panic

            _LIT( KComponentName,"NetworkController" );

            User::Panic( KComponentName,KErrCouldNotConnect );

            }

        break;

        default:

            {

            // no implementation

            }

        break;

        }

    // Inserted to remove the compiler warning

    IRLOG_DEBUG( "CIRNetworkController::GetIRConnection - Exiting." );

    return ( *iIRNetworkConnection );

    }

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

//  CIRNetworkController::GetIRSocketServer

//  Returns the instance of RSocketServ

//  The same RSocketServ object is used across the entire iRAPP components to

//  provide central arbiter and monitoring of Network Connection

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

//

EXPORT_C RSocketServ& CIRNetworkController::GetIRSocketServer()

    {

    IRLOG_DEBUG( "CIRNetworkController::GetIRSocketServer - Entering" );

    switch ( iSocketServerConnectionState )

        {

        case EIRSocketServerActive:

            {

            // Connection to Socket Server is active hence return the reference

            return iIRSocketServer;

            }

        case EIRSocketServerInActive:

            {

            // Connection to Socket Server not open hence open and return the reference

            // Connection is not active and application cannot continue hence panic

            _LIT( KComponentName,"NetworkController" );

            User::Panic( KComponentName,KErrCouldNotConnect );

            }

        break;

        default:

        {

            // no implemenatation

        }

        break;

        }

    // Inserted to remove the compiler warning

    IRLOG_DEBUG( "CIRNetworkController::GetIRSocketServer - Exiting." );

    return iIRSocketServer;

    }

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

//  CIRNetworkController::GetWapProfString

//  Returns a HBufC pointer to the x-wap-profile string

//  Transfers the ownership of the returned HBufC8 object

//  The caller must takecare of deleting the returned object

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

//

EXPORT_C HBufC8* CIRNetworkController::GetWapProfString()

    {

    IRLOG_DEBUG( "CIRNetworkController::GetWapProfString" );

    return iIRWapProf;

    }

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

//  CIRNetworkController::GetUAProfString

//  Returns a HBufC pointer to the UAProf string

//  Transfers the ownership of the returned HBufC8 object

//  The caller must takecare of deleting the returned object

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

//

EXPORT_C HBufC8* CIRNetworkController::GetUAProfString()

    {

    IRLOG_DEBUG( "CIRNetworkController::GetUAProfString" );

    return iIRUAProf;

    }

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

//  CIRNetworkController::GetNetworkStatus

//  Returns the variable which indicates if connection is active or not

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

//

EXPORT_C TBool CIRNetworkController::GetNetworkStatus() const

    {

    IRLOG_DEBUG( "CIRNetworkController::GetNetworkStatus" );

    return iIsConnectedToNetwork;

    }

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

// CIRNetworkController::GetIAPId

// Gets the IAP Id of the chosen IAP

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

//

EXPORT_C TInt CIRNetworkController::GetIAPId( TUint32& aIapId ) const

    {

    IRLOG_DEBUG( "CIRNetworkController::GetIAPId - Entering" );

    TInt retVal( KErrNone );

    if ( iIsConnectedToNetwork )

        {

        if ( iIRNetworkObserver->iIsIAPIdAvailable )

            {

            aIapId = iIRNetworkObserver->iIAPId;

            }

        }

    else

        {

        retVal = KErrNotFound;

        }

    IRLOG_DEBUG( "CIRNetworkController::GetIAPId - Exiting." );

    return retVal;

    }

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

//  CIRNetworkController::ChooseAccessPointL

//  Configures the Access Point which is used by all the components for network

//  connectivity

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

//

EXPORT_C void CIRNetworkController::ChooseAccessPointL(TBool aDefaultConnection)

    {

    IRLOG_DEBUG( "CIRNetworkController::ChooseAccessPointL - Entering" );

    if (iHandingOver)

        {

        if (iObserver)

            {

            iObserver->IRNetworkEventL(ENetworkConnectionConnecting);

            }

        IRLOG_DEBUG("CIRNetworkController::ChooseAccessPointL, ALR is handing over, Exiting");

        return;

        }

    iIRNetworkObserver->SetNetworkMonitoring( ETrue );

    iDefaultConnection = aDefaultConnection;

    // Always validate the Access Points status

    if ( ValidateAccessPointsL() )

        { 

        if ( NULL != iMobility )

		    {

            iMobility->Cancel();

            delete iMobility;

            iMobility = NULL;

            }

            // Connect to the Symbian Socket Server

        iIRNetworkConnection->Close();

        iIRSocketServer.Close();

        TInt ReturnErrorCode = iIRSocketServer.Connect( KIRESockMessageSlots );

        if(ReturnErrorCode != KErrNone )

            {

            // Error in opening the connection to SocketServer

            iSocketServerConnectionState = EIRSocketServerInActive;

            IRLOG_DEBUG( "CIRNetworkController::ChooseAccessPointL - Exiting ( 1 )." );

            return ;

            }

        // Connection to RSocketServ is sucessful

        iSocketServerConnectionState = EIRSocketServerActive;

        // Open the RConnection over the iIRSocketServer

        ReturnErrorCode = iIRNetworkConnection->Open(iIRSocketServer);

        if( ReturnErrorCode != KErrNone )

            {

            // Error in opening the connection

            iNetworkConnectionState = EIRNetworkConnectionInActive;

            IRLOG_DEBUG( "CIRNetworkController::ChooseAccessPointL - Exiting ( 2 )." );

            return ;

            }

        //Added for ALR/SNAP

        if ( !IsActive() )

            {

            if (iDefaultConnection)

                {

                TConnPrefList prefList;

                TExtendedConnPref extPrefs;

                extPrefs.SetSnapPurpose(CMManager::ESnapPurposeInternet);

                extPrefs.SetNoteBehaviour(TExtendedConnPref::ENoteBehaviourConnDisableNotes);

                prefList.AppendL(&extPrefs);

                iIRNetworkConnection->Start(prefList, iStatus);

                }

            else

                {

                TCommDbConnPref connPref;

                connPref.SetDialogPreference(ECommDbDialogPrefPrompt);

                iIRNetworkConnection->Start(connPref, iStatus) ;

                }

            // Set the NetworkController state

            iNetworkControllerState = EConnectingToNetwork;

            SetActive();

            iIsConnectRequestIssued = ETrue;

            if ( iObserver )

                {

                IRLOG_DEBUG( "CIRNetworkController::ChooseAccessPointL - notify ENetworkConnectionConnecting" );

                iObserver->IRNetworkEventL( ENetworkConnectionConnecting );

                }

            }

        IRLOG_DEBUG( "CIRNetworkController::ChooseAccessPointL - Exiting ( 3 )." );

        return ;

        }

    else

        {

        iObserver->IRNetworkEventL(EAccessPointSelectionCancelled );

        }

    IRLOG_DEBUG( "CIRNetworkController::ChooseAccessPointL - Exiting ( 4 )." );

    }

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

//  CIRNetworkController::CancelConnecting

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

//

EXPORT_C void CIRNetworkController::CancelConnecting()

    {

    IRLOG_DEBUG("CIRNetworkController::CancelConnecting(), Entering");

    iIRNetworkObserver->Cancel();

    Cancel();

    ResetConnectionStatus();

    IRLOG_DEBUG("CIRNetworkController::CancelConnecting(), Exiting");

    }

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

//  CIRNetworkController::IsOfflineMode

//  This api is used to determine if the phone is in offline mode

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

//

EXPORT_C TBool CIRNetworkController::IsOfflineMode()

    {

    IRLOG_DEBUG( "CIRNetworkController::IsOfflineMode" );

    // System defined value for offline mode is 5

    const TInt KOfflineMode = 5;

    TInt returnValue = 0;

    returnValue = DetermineCurrentProfile();

    if ( returnValue == KOfflineMode )

        {

        IRLOG_DEBUG( "CIRNetworkController::IsOfflineMode - Exiting ( 1 )." );

        return ETrue;            

        }

    IRLOG_DEBUG( "CIRNetworkController::IsOfflineMode - Exiting ( 2 )." );

    return EFalse;    

    }

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

//  CIRNetworkController::IsWlanSupported

//  This api is used to determine if the phone supports WLan usage

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

//

EXPORT_C TBool CIRNetworkController::IsWlanSupported() const

    {

    IRLOG_DEBUG( "CIRNetworkController::IsWlanSupported" );

    return iIsWlanSupported;

    }

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

// CIRNetworkController::ResetConnectionStatus

//  Reset the connection status to Disconnected statet

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

//

EXPORT_C void CIRNetworkController::ResetConnectionStatus()

    {

    IRLOG_DEBUG( "CIRNetworkController::ResetConnectionStatus - Entering" );

    iIsConnectRequestIssued = EFalse;

    iNetworkConnectionState = EIRNetworkConnectionInActive;

    iIsConnectedToNetwork = EFalse;

    iConnectionPresent = EFalse;

    IRLOG_DEBUG( "CIRNetworkController::ResetConnectionStatus - Exiting." );

    }

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

// CIRNetworkController::IdentifyConnectionType

// Used to determine the type of connection

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

//

EXPORT_C TIRConnectionType CIRNetworkController::IdentifyConnectionType() const

    {

    IRLOG_DEBUG( "CIRNetworkController::IdentifyConnectionType" );

    IRRDEBUG2( "CIRNetworkController::IdentifyConnectionType - Entering iConnectionType = %d", iIRNetworkObserver->iIRConnectionType );

    return iIRNetworkObserver->iIRConnectionType;

    }

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

// CIRNetworkController::DetermineCurrentProfile

// Used to determine the current profile

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

//

TInt CIRNetworkController::DetermineCurrentProfile() const

    {

    IRLOG_DEBUG( "CIRNetworkController::DetermineCurrentProfile" );

    TInt value = KErrNone;

    TRAPD( err,

    CRepository* cRepositoryHandle = CRepository::NewLC( KCRUidProfileEngine );

    cRepositoryHandle->Get( KProEngActiveProfile,value );

    CleanupStack::PopAndDestroy( cRepositoryHandle ); )

    if ( err != KErrNone )

        {

        value = err;

        }

    IRLOG_DEBUG( "CIRNetworkController::DetermineCurrentProfile - Exiting." );

    return value;

    }

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

// CIRNetworkController::CheckFeatureL

// Pops up the access point list.

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

//

TBool CIRNetworkController::CheckFeatureL( TInt aFeatureId ) const

    {

    IRLOG_DEBUG( "CIRNetworkController::CheckFeatureL" );

    return CFeatureDiscovery::IsFeatureSupportedL( aFeatureId );

    }

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

// CIRNetworkController::CIRNetworkController

// Default C++ Constructor

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

//

CIRNetworkController::CIRNetworkController(): CActive(

    CActive::EPriorityHigh )

    {

    // Add the AO to the ActiveScheduler

    IRLOG_DEBUG( "CIRNetworkController::CIRNetworkController- Entering" );

    CActiveScheduler::Add( this );

    // Initialize the states

    iNetworkConnectionState = EIRNetworkConnectionInActive;

    iSocketServerConnectionState = EIRSocketServerInActive;

    iNetworkControllerState = EInActive;

    IRLOG_DEBUG( "CIRNetworkController::CIRNetworkController - Exiting." );

    }

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

//  CIRNetworkController::~CIRNetworkController

//  Default C++ Destructor

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

//

CIRNetworkController::~CIRNetworkController()

    {

    IRLOG_DEBUG( "CIRNetworkController::~CIRNetworkController- Entering" );

    _LIT( KErrorMsg,"Method Close not called" );

    __ASSERT_ALWAYS( iSingletonInstances == 0, User::Panic( KErrorMsg, KErrCorrupt ) );

    if ( NULL != iMobility )

        {

        iMobility->Cancel();

        delete iMobility;

        iMobility = NULL;

        }

    if ( IsActive() )

        {

        Cancel();

        }

    if ( iIRNetworkConnection )

        {

        iIRNetworkConnection->Close();

        delete iIRNetworkConnection;

        }

    // Set all the state variables to indicate network connection is closed

    delete iIRUAProf;

    delete iIRWapProf;

    if ( iIRSettings )

        {

        iIRSettings->Close();

        iIRSettings = NULL;

        }

    delete iIRNetworkObserver;

    iIRSocketServer.Close();

    if ( iIapList )

        {

        iIapList->Reset();

        delete iIapList;

        iIapList = NULL;

        }

    if ( iDataTransferTracker )

        {

        delete iDataTransferTracker;