/*

* Copyright (c) 2006-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:  ?Description

*

*/

#include <centralrepository.h>

#include <commsdattypesv1_1.h>

#include <commdb.h>

#include <commdbconnpref.h>

#include <featdiscovery.h>

#include <features.hrh>

#include <ProfileEngineSDKCRKeys.h>

#include <WebUtilsInternalCRKeys.h>

#include <httpstringconstants.h>

#include <StringLoader.h>

#include <data_caging_path_literals.hrh>

#include "irdebug.h"

#include "irfilteredapreader.h"

#include "irnetworkcontroller.h"

#include "irnetworkobserver.h"

#include "irsettings.h"

#include "iractivenetworkobserver.h"

//for ALR/SNAP

#include <cmmanager.h>

#include <cmdestination.h>

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

const TInt KIRDefaultUAProfBufferSize = 0x80;

const TUint KIRESockMessageSlots = 16;

const TUint32 KIRUniqueWlanId = 0x2000883F; // Just to make it unique

const TInt KArraySize = 5;

const TInt KWlanStringMaxLength = 9;

const TInt KTwo = 2;

// 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++;

    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::GetAccessPointList

// Reset the connection status to Disconnected statet

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

//

EXPORT_C const CDesCArray* CIRNetworkController::GetAccessPointList() const

{

    IRLOG_DEBUG( "CIRNetworkController::GetAccessPointList" );

    return iIapList;

}

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

// CIRNetworkController::GetBearerList

// Reset the connection status to Disconnected statet

//

EXPORT_C const RArray<TUint32> CIRNetworkController::GetBearerList() const

{

    IRLOG_DEBUG( "CIRNetworkController::GetBearerList" );

    return iBearerList;

}

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

// CIRNetworkController::GetNetworkList

// Reset the connection status to Disconnected statet

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

//

EXPORT_C const RArray<TUint32> CIRNetworkController::GetNetworkList() const

{

    IRLOG_DEBUG( "CIRNetworkController::GetNetworkList" );

    return iNetworkList;

}

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

// CIRNetworkController::GetApList

// Reset the connection status to Disconnected statet

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

//

EXPORT_C const RArray<TUint32> CIRNetworkController::GetApList() const

{

    IRLOG_DEBUG( "CIRNetworkController::GetApList" );

    return iIapIdList;

}

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

//  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() )

    { 

        // 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)

            {

            }

            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)." );

}

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));

    delete iMobility;

    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;