/*

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

 * This is a source file for following classes:

 * ConnMonScanWlanAps,

 * ConnMonConnInfo,

 * ConnMonConnDisconnect

 */

// INCLUDE FILES

#include <cmconnectionmethodext.h>

#include <rconnmon.h>

#include <nifvar.h>

#include "wlanqtutilscommon.h"

#include "wlanqtutilswlanap.h"

#include "wlanqtutilsactiveconn.h"

#include "wlanqtutilsconmonwrapper.h"

#include "wlanqtutilsconmonwrapper_s60_p.h"

#ifdef WLANQTUTILS_NO_OST_TRACES_FLAG

#include <opensystemtrace.h>

#else

#include "OstTraceDefinitions.h"

#endif

#ifdef OST_TRACE_COMPILER_IN_USE

#include "wlanqtutilsconmonwrapper_s60Traces.h"

#endif

// =========== PRIVATE CLASS MEMBER FUNCTIONS ===============

//

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

// ConnMonScanWlanAps::ConnMonScanWlanAps()

// Constructor

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

//

ConnMonScanWlanAps::ConnMonScanWlanAps(ConMonWrapper *wrapper) :

    CActive(EPriorityStandard), q_ptr(wrapper), wlanPtr(0, 0)

    {

    OstTraceFunctionEntry1( CONNMONSCANWLANAPS_CONNMONSCANWLANAPS_ENTRY, this );

    CActiveScheduler::Add(this);

    // TBD: What if this leaves?

    // Beware! iConnMon.ConnectL() can

    // both leave AND return an error code..

    // User::LeaveIfError( iMonitor.ConnectL() );

    iMonitor.ConnectL();

    OstTraceFunctionExit1( CONNMONSCANWLANAPS_CONNMONSCANWLANAPS_EXIT, this );

    }

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

// ConnMonScanWlanAps::ConnMonScanWlanAps()

// Destructor

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

//

ConnMonScanWlanAps::~ConnMonScanWlanAps()

    {

    OstTraceFunctionEntry1( CONNMONSCANWLANAPS_CONNMONSCANWLANAPSDESTR_ENTRY, this );

    Cancel();

    // Cancel notifications and close connection monitor session

    iMonitor.Close();

    if (wlanBuf)

        {

        delete wlanBuf;

        }

    OstTraceFunctionExit1( CONNMONSCANWLANAPS_CONNMONSCANWLANAPSDESTR_EXIT, this );

    }

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

// ConnMonScanWlanAps::DoCancel()

// 

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

//

void ConnMonScanWlanAps::DoCancel()

    {

    OstTraceFunctionEntry1( CONNMONSCANWLANAPS_DOCANCEL_ENTRY, this );

    // TODO: error handling

    OstTraceFunctionExit1( CONNMONSCANWLANAPS_DOCANCEL_EXIT, this );

    }

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

// ConnMonScanWlanAps::RunL()

// Called when scan is ready. Emits scan results in a signal.

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

//

void ConnMonScanWlanAps::RunL()

    {

    OstTraceFunctionEntry1( CONNMONSCANWLANAPS_RUNL_ENTRY, this );

    if (iStatus == KErrNone)

        {

        RConnMonWlanNetworksPtrArray wlanPtrArray;

        wlanBuf->UnpackToL(wlanPtrArray);

        QList<WlanQtUtilsWlanAp*> wlanScanResult;

        for (TInt i = 0; i < wlanPtrArray.Count(); i++)

            {

            WlanQtUtilsWlanAp *ap = new WlanQtUtilsWlanAp();

            // Security mode values defined in enum TConnMonSecurityMode, rconnmon.h.

            TUint connMonWlanSecMode;

            WlanQtUtilsWlanSecMode wlanQtUtilsWlanSecMode;

            TBuf<CConnMonWlanNetwork::KMaxNameLength> wlanName =

                    wlanPtrArray[i]->Name();

            QString wlanNameInQt = QString::fromUtf16(wlanName.Ptr(),

                    wlanName.Length());

            if (wlanNameInQt.length() == 1 && wlanNameInQt.at(0).unicode()

                    == 0)

                {

                // QString handles empty strings (single \0 char) strangely,

                // so let's initialize them in a different way:

                wlanNameInQt = "";

                }

            ap->setSsid(wlanNameInQt);

            // TODO: Won't compile to ARMV5 for some reason. Commented for awhile. 

            //TBuf8<CConnMonWlanNetwork::KWlanBssId> wlanBssid = wlanPtrArray[i]->WlanBssid();

            //ap->setBssid(QString::fromUtf8(wlanBssid.Ptr(), wlanBssid.Length()));

            ap->setBssid("addMAC");

            TUint wlanConnectionMode = wlanPtrArray[i]->ConnectionMode();

            ap->setConnectionMode(wlanConnectionMode);

            TUint wlanSignalStrength = wlanPtrArray[i]->SignalStrength();

            ap->setSignalStrength(wlanSignalStrength);

            connMonWlanSecMode = wlanPtrArray[i]->SecurityMode();

            wlanQtUtilsWlanSecMode = conMon2WlanQtUtilsSecModeMap(connMonWlanSecMode);

            ap->setSecurityMode(wlanQtUtilsWlanSecMode);

            wlanScanResult.append(ap);

            delete wlanPtrArray[i];

            }

        q_ptr->emitAvailableWlans(wlanScanResult);

        wlanPtrArray.Close();

        delete wlanBuf;

        wlanBuf = NULL;

        // TODO: Is this enough for clearing QList containing ConnUtilsWlanAps?

        wlanScanResult.clear();

        }

    else

        {

        // TODO: add error handling

        }

    OstTraceFunctionExit1( CONNMONSCANWLANAPS_RUNL_EXIT, this );

    }

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

// ConnMonScanWlanAps::scanAvailableWlanAPs()

// Gets APs from Connection Monitor

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

//

int ConnMonScanWlanAps::scanAvailableWlanAPs()

    {

    OstTraceFunctionEntry1( CONNMONSCANWLANAPS_SCANAVAILABLEWLANAPS_ENTRY, this );

    if (!IsActive())

        {

        // TODO: What size for wlanBuf? How to know exact size?

        // 2560 ~ 35 wlan APs

        wlanBuf = new (ELeave) CConnMonWlanNetworksPtrArrayPckg(2560);

        wlanPtr.Set(wlanBuf->Buf()->Des());

        iMonitor.GetPckgAttribute(EBearerIdWLAN, 0, KWlanNetworks, wlanPtr,

                iStatus);

        SetActive();            

        }

    OstTraceFunctionExit1( CONNMONSCANWLANAPS_SCANAVAILABLEWLANAPS_EXIT, this );

    return KErrNone;

    }

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

// ConMonScanWlanAps::connMon2WlanQtUtilsSecModeMap()

// Map security mode from Connection Monitor into WlanQtUtilsWlanSecMode.

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

//

WlanQtUtilsWlanSecMode ConnMonScanWlanAps::conMon2WlanQtUtilsSecModeMap(TUint connMonSecMode)

    {

    WlanQtUtilsWlanSecMode ret = WlanQtUtilsWlanSecModeNone;

    switch (connMonSecMode)

        {

        case EConnMonSecurityWep:

            ret = WlanQtUtilsWlanSecModeWep;

            break;

        case EConnMonSecurity802d1x:

            ret = WlanQtUtilsWlanSecMode802_1x;

            break;

        case EConnMonSecurityWpa:

            ret = WlanQtUtilsWlanSecModeWpa;

            break;

        case EConnMonSecurityWpaPsk:

            ret = WlanQtUtilsWlanSecModeWpa2;

            break;

        default:

            // TODO: should default be None/unknown or should there be assert against EConnMonSecurityOpen.

            ret = WlanQtUtilsWlanSecModeOpen;

            break;

        }

    return ret;

    }

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

// ConnMonConnInfo::ConnMonConnInfo()

// Constructor

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

//

ConnMonConnInfo::ConnMonConnInfo(ConMonWrapper *wrapper) :

    q_ptr(wrapper)

    {

    OstTraceFunctionEntry1( CONNMONCONNINFO_CONNMONCONNINFO_ENTRY, this );

    iMonitor.ConnectL();

    StartMonitoringL();

    OstTraceFunctionExit1( CONNMONCONNINFO_CONNMONCONNINFO_EXIT, this );

    }

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

// ConnMonConnInfo::~ConnMonConnInfo()

// Destructor

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

//

ConnMonConnInfo::~ConnMonConnInfo()

    {

    OstTraceFunctionEntry1( CONNMONCONNINFO_CONNMONCONNINFODESTR_ENTRY, this );

    StopMonitoring();

    iMonitor.Close();

    OstTraceFunctionExit1( CONNMONCONNINFO_CONNMONCONNINFODESTR_EXIT, this );

    }

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

// ConnMonConnInfo::StartMonitoringL()

// Starts monitoring of Connection Monitor Server events

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

//

void ConnMonConnInfo::StartMonitoringL()

    {

    OstTraceFunctionEntry1( CONNMONCONNINFO_STARTMONITORINGL_ENTRY, this );

    iMonitoring = ETrue;

    iMonitor.NotifyEventL(*this);

    OstTraceFunctionExit1( CONNMONCONNINFO_STARTMONITORINGL_EXIT, this );

    }

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

// ConnMonConnInfo::StopMonitoring()

// Stops monitoring of Connection Monitor Server events

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

//

void ConnMonConnInfo::StopMonitoring()

    {

    OstTraceFunctionEntry1( CONNMONCONNINFO_STOPMONITORING_ENTRY, this );

    iMonitoring = EFalse;

    iMonitor.CancelNotifications();

    OstTraceFunctionExit1( CONNMONCONNINFO_STOPMONITORING_EXIT, this );

    }

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

// ConnMonConnInfo::EventL()

// Handler of Connection Monitor Server events

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

//

void ConnMonConnInfo::EventL(const CConnMonEventBase& aConnMonEvent)

    {

    OstTraceFunctionEntry1( CONNMONCONNINFO_EVENTL_ENTRY, this );

    TUint connectionId = aConnMonEvent.ConnectionId();

    OstTraceExt2(

        TRACE_NORMAL,

        CONNMONCONNINFO_EVENTL_EVENTTYPE,

        "ConnMonConnInfo::EventL;connectionId=%u;aConnMonEvent.EventType()=%d", connectionId, aConnMonEvent.EventType() );

    // Note: Conversions from CConnMonEventBase to sub classes cannot be made to use dynamic_cast

    // because constructors of CConnMonEventBase and its sub classes are not public in

    // connmon library's interface.

    switch (aConnMonEvent.EventType())

        {

        case EConnMonCreateConnection:

            q_ptr->emitConnCreatedEvent( connectionId );

            break;

        case EConnMonDeleteConnection:

            // TODO: take the following into use.

            // const CConnMonDeleteConnection* eventDelete; 

            // eventDelete = static_cast< const CConnMonDeleteConnection*>( &aConnMonEvent );

            //TUint totalDlVolume = eventDelete->DownlinkData();

            //TUint totalUlVolume = eventDelete->UplinkData();

            //TBool authDelete    = eventDelete->AuthoritativeDelete();

            q_ptr->emitConnDeletedEvent( connectionId );

            break;

        case EConnMonConnectionStatusChange:

            const CConnMonConnectionStatusChange* eventConnectionStatusChange;

            eventConnectionStatusChange =

                static_cast< const CConnMonConnectionStatusChange* >( &aConnMonEvent );

            WlanQtUtilsConnectionStatus connectionStatus;

            connectionStatus = connMon2WlanQtUtilsConnectionStatusMap(

                eventConnectionStatusChange->ConnectionStatus() );

            OstTraceExt2(

                TRACE_NORMAL,

                CONNMONCONNINFO_EVENTL_CONNSTATUS,

                "ConnMonConnInfo::EventL;connectionId=%u;eventConnectionStatusChange->ConnectionStatus()=%d",

                connectionId,

                eventConnectionStatusChange->ConnectionStatus() );

            if (connectionStatus != WlanQtUtilsConnectionStatusNone) {

                q_ptr->emitConnStatusEvent( connectionId, connectionStatus );

            }

            break;

        default:

            break;

        }

    OstTraceFunctionExit1( CONNMONCONNINFO_EVENTL_EXIT, this );

    }

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

// ConnMonConnInfo::activeConnection()

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

//

WlanQtUtilsActiveConn *ConnMonConnInfo::activeConnection()

    {

    OstTraceFunctionEntry1( CONNMONCONNINFO_ACTIVECONNECTION_ENTRY, this );

    // Get number of active connections

    TRequestStatus status;

    TUint numConnections = 0;

    iMonitor.GetConnectionCount( numConnections, status );

    User::WaitForRequest( status );

    if ( status.Int() == KErrNone )

        {

        // Get connection info of this connection

        for ( TUint i = 1; i <= numConnections; i++ )

            {

            TUint numSubConnections = 0;

            TUint connectionId = 0;

            TInt ret = iMonitor.GetConnectionInfo( i, connectionId, numSubConnections );

            Q_ASSERT( ret == KErrNone ); // TODO: error handling

            WlanQtUtilsActiveConn* activeConn = connectionInfo( connectionId );

            if ( activeConn != NULL )

                {

                // connectionInfo() only returns WLAN connections, and there may be only

                // one active WLAN connection, so this is the one we want to return

                OstTraceFunctionExit1( CONNMONCONNINFO_ACTIVECONNECTION_EXIT, this );

                return activeConn;

                }

            }

        }

    OstTraceFunctionExit1( DUP1_CONNMONCONNINFO_ACTIVECONNECTION_EXIT, this );

    return NULL;

    }

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

// ConnMonConnInfo::connectionInfo()

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

//

WlanQtUtilsActiveConn *ConnMonConnInfo::connectionInfo( uint connectionId )

    {

    OstTraceFunctionEntry1( CONNMONCONNINFO_CONNECTIONINFO_ENTRY, this );

    TRequestStatus status;

    WlanQtUtilsActiveConn *activeConn = NULL;

    // Get the connection bearer.

    TInt bearer = 0;

    iMonitor.GetIntAttribute(

            connectionId,

            0,

            KBearer,

            bearer,

            status );

    User::WaitForRequest( status );

    if ( status.Int() == KErrNone )

        {

        // We are only interested in WLAN connections. 

        WlanQtUtilsBearerType bearerType = connMon2WlanQtUtilsBearerTypeMap( bearer );

        if ( bearerType == WlanQtUtilsBearerTypeWlan )

            {

            activeConn = new WlanQtUtilsActiveConn();

            activeConn->setConnectionId( connectionId );

            activeConn->setBearerType( bearerType );

            activeConnInfoUpdate( activeConn );

            }

        }

    OstTraceFunctionExit1( CONNMONCONNINFO_CONNECTIONINFO_EXIT, this );

    return activeConn;

    }

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

// ConnMonConnInfo::activeConnInfoUpdate()

// Requests active connection info from Connection Monitor Server

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

//

// TODO: divide this function into smaller pieces depending on the need.

// TODO: optimize so that all the information is not always requested from connmon.

//       Only information that is missing is requested.

void ConnMonConnInfo::activeConnInfoUpdate( WlanQtUtilsActiveConn *activeConn )

    {

    OstTraceFunctionEntry1( CONNMONCONNINFO_ACTIVECONNINFOUPDATE_ENTRY, this );

    Q_ASSERT( activeConn != NULL );

    Q_ASSERT( activeConn->bearerType() != WlanQtUtilsBearerTypeNone );

    TUint connectionId = activeConn->connectionId();

    TRequestStatus status;

    // Get connection IAP ID.

    TUint iapId = 0;

    iMonitor.GetUintAttribute(

            connectionId,

            0,

            KIAPId,

            iapId,

            status );

    User::WaitForRequest( status );

    if ( status.Int() == KErrNone )

        {

        activeConn->setIapId( iapId );

        }

    // Get connection status.

    TInt connectionStatus = 0;

    iMonitor.GetIntAttribute(

            connectionId,

            0,

            KConnectionStatus,

            connectionStatus,

            status );

    User::WaitForRequest( status );

    if ( status.Int() == KErrNone ) {

        activeConn->setConnectionStatus( connMon2WlanQtUtilsConnectionStatusMap( connectionStatus ) );

    }

    OstTraceFunctionExit1( CONNMONCONNINFO_ACTIVECONNINFOUPDATE_EXIT, this );

    }

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

// ConnMonConnInfo::connMon2WlanQtUtilsConnectionStatusMap()

// Maps connection status of Connection Monitor Server to connection

// status of Wlan Qt Utilities.

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

//

WlanQtUtilsConnectionStatus ConnMonConnInfo::connMon2WlanQtUtilsConnectionStatusMap( TInt aConnectionStatus )

    {    

    // TODO: This mapping is not specific to current status which is unknown to wrapper.

    // TODO: This is only current implementation and will need serious modifications and

    //       verification from connmon guys.

    WlanQtUtilsConnectionStatus connUtilsConnectionStatus = WlanQtUtilsConnectionStatusNone;

    switch (aConnectionStatus)

        {

        // KConnectionOpen is not final status for WLAN, because DHCP is run after that

        case KConnectionOpen:

        case KStartingConnection:

            connUtilsConnectionStatus = WlanQtUtilsConnectionStatusConnecting;

            break;

        case KLinkLayerOpen:

            connUtilsConnectionStatus = WlanQtUtilsConnectionStatusConnected;

            break;

        case KConnectionClosed:

        case KLinkLayerClosed:

            connUtilsConnectionStatus = WlanQtUtilsConnectionStatusDisconnected;

            break;

        default:

            // Ignore all other values

            connUtilsConnectionStatus = WlanQtUtilsConnectionStatusNone;

            break;

        }

    return connUtilsConnectionStatus;

    }

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

// ConnMonConnInfo::connMon2WlanQtUtilsBearerTypeMap()

// Maps bearer type of Connection Monitor Server to bearer

// type of Wlan Qt Utilities.

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

//

WlanQtUtilsBearerType ConnMonConnInfo::connMon2WlanQtUtilsBearerTypeMap( TInt aBearerType )

    {    

    WlanQtUtilsBearerType connUtilsBearerType = WlanQtUtilsBearerTypeNone;

    switch ( aBearerType ) {

    case EBearerWCDMA:

    case EBearerGPRS:

    case EBearerEdgeGPRS:

        connUtilsBearerType = WlanQtUtilsBearerTypeCellular;

        break;

    case EBearerWLAN:

        connUtilsBearerType = WlanQtUtilsBearerTypeWlan;

        break;

    default:

        break;

    }

    return connUtilsBearerType;