/****************************************************************************

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the plugins of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include "symbianengine.h"

#include "qnetworksession_impl.h"

#include <commdb.h>

#include <cdbcols.h>

#include <d32dbms.h>

#include <nifvar.h>

#include <QEventLoop>

#include <QTimer>

#include <QTime>  // For randgen seeding

#include <QtCore> // For randgen seeding

#ifdef QT_BEARERMGMT_SYMBIAN_DEBUG

#include <QDebug>

#endif

#ifdef SNAP_FUNCTIONALITY_AVAILABLE

    #include <cmdestination.h>

    #include <cmconnectionmethod.h>

    #include <cmconnectionmethoddef.h>

    #include <cmpluginwlandef.h>

    #include <cmpluginpacketdatadef.h>

    #include <cmplugindialcommondefs.h>

#else

    #include <apaccesspointitem.h>

    #include <apdatahandler.h>

    #include <aputils.h> 

#endif

#ifndef QT_NO_BEARERMANAGEMENT

QT_BEGIN_NAMESPACE

#ifdef SNAP_FUNCTIONALITY_AVAILABLE

    static const int KValueThatWillBeAddedToSNAPId = 1000;

#endif

static const int KUserChoiceIAPId = 0;

SymbianNetworkConfigurationPrivate::SymbianNetworkConfigurationPrivate()

:   bearer(BearerUnknown), numericId(0), connectionId(0)

{

}

SymbianNetworkConfigurationPrivate::~SymbianNetworkConfigurationPrivate()

{

}

QString SymbianNetworkConfigurationPrivate::bearerName() const

{

    QMutexLocker locker(&mutex);

    switch (bearer) {

    case BearerEthernet:

        return QLatin1String("Ethernet");

    case BearerWLAN:

        return QLatin1String("WLAN");

    case Bearer2G:

        return QLatin1String("2G");

    case BearerCDMA2000:

        return QLatin1String("CDMA2000");

    case BearerWCDMA:

        return QLatin1String("WCDMA");

    case BearerHSPA:

        return QLatin1String("HSPA");

    case BearerBluetooth:

        return QLatin1String("Bluetooth");

    case BearerWiMAX:

        return QLatin1String("WiMAX");

    default:

        return QString();

    }

}

SymbianEngine::SymbianEngine(QObject *parent)

:   QBearerEngine(parent), CActive(CActive::EPriorityIdle), iFirstUpdate(true), iInitOk(true),

    iIgnoringUpdates(false), iTimeToWait(0), iIgnoreEventLoop(0)

{

    CActiveScheduler::Add(this);

    // Seed the randomgenerator

    qsrand(QTime(0,0,0).secsTo(QTime::currentTime()) + QCoreApplication::applicationPid());

    iIgnoreEventLoop = new QEventLoop(this);

    TRAPD(error, ipCommsDB = CCommsDatabase::NewL(EDatabaseTypeIAP));

    if (error != KErrNone) {

        iInitOk = false;

        return;

    }

    TRAP_IGNORE(iConnectionMonitor.ConnectL());

    TRAP_IGNORE(iConnectionMonitor.NotifyEventL(*this));

#ifdef SNAP_FUNCTIONALITY_AVAILABLE    

    TRAP(error, iCmManager.OpenL());

    if (error != KErrNone) {

        iInitOk = false;

        return;

    }

#endif

}

void SymbianEngine::initialize()

{

    QMutexLocker locker(&mutex);

    SymbianNetworkConfigurationPrivate *cpPriv = new SymbianNetworkConfigurationPrivate;

    cpPriv->name = "UserChoice";

    cpPriv->bearer = SymbianNetworkConfigurationPrivate::BearerUnknown;

    cpPriv->state = QNetworkConfiguration::Discovered;

    cpPriv->isValid = true;

    cpPriv->id = QString::number(qHash(KUserChoiceIAPId));

    cpPriv->numericId = KUserChoiceIAPId;

    cpPriv->connectionId = 0;

    cpPriv->type = QNetworkConfiguration::UserChoice;

    cpPriv->purpose = QNetworkConfiguration::UnknownPurpose;

    cpPriv->roamingSupported = false;

    QNetworkConfigurationPrivatePointer ptr(cpPriv);

    userChoiceConfigurations.insert(ptr->id, ptr);

    updateConfigurations();

    updateStatesToSnaps();

    updateAvailableAccessPoints(); // On first time updates synchronously (without WLAN scans)

    // Start monitoring IAP and/or SNAP changes in Symbian CommsDB

    startCommsDatabaseNotifications();

    iFirstUpdate = false;

}

SymbianEngine::~SymbianEngine()

{

    Cancel();

    iConnectionMonitor.CancelNotifications();

    iConnectionMonitor.Close();

#ifdef SNAP_FUNCTIONALITY_AVAILABLE    

    iCmManager.Close();

#endif

    delete ipAccessPointsAvailabilityScanner;

    // CCommsDatabase destructor uses cleanup stack. Since QNetworkConfigurationManager

    // is a global static, but the time we are here, E32Main() has been exited already and

    // the thread's default cleanup stack has been deleted. Without this line, a

    // 'E32USER-CBase 69' -panic will occur.

    CTrapCleanup* cleanup = CTrapCleanup::New();

    delete ipCommsDB;

    delete cleanup;

}

bool SymbianEngine::hasIdentifier(const QString &id)

{

    QMutexLocker locker(&mutex);

    return accessPointConfigurations.contains(id) ||

           snapConfigurations.contains(id) ||

           userChoiceConfigurations.contains(id);

}

QNetworkConfigurationManager::Capabilities SymbianEngine::capabilities() const

{

    QNetworkConfigurationManager::Capabilities capFlags;

    capFlags = QNetworkConfigurationManager::CanStartAndStopInterfaces |

               QNetworkConfigurationManager::DirectConnectionRouting |

               QNetworkConfigurationManager::SystemSessionSupport |

               QNetworkConfigurationManager::DataStatistics |

               QNetworkConfigurationManager::NetworkSessionRequired;

#ifdef SNAP_FUNCTIONALITY_AVAILABLE

    capFlags |= QNetworkConfigurationManager::ApplicationLevelRoaming |

                QNetworkConfigurationManager::ForcedRoaming;

#endif

    return capFlags;

}

QNetworkSessionPrivate *SymbianEngine::createSessionBackend()

{

    return new QNetworkSessionPrivateImpl(this);

}

void SymbianEngine::requestUpdate()

{

    QMutexLocker locker(&mutex);

    if (!iInitOk || iUpdateGoingOn) {

        return;

    }

    iUpdateGoingOn = true;

    stopCommsDatabaseNotifications();

    updateConfigurations(); // Synchronous call

    updateAvailableAccessPoints(); // Asynchronous call

}

void SymbianEngine::updateConfigurations()

{

    QMutexLocker locker(&mutex);

    if (!iInitOk) {

        return;

    }

    TRAP_IGNORE(updateConfigurationsL());

}

void SymbianEngine::updateConfigurationsL()

{

    QMutexLocker locker(&mutex);

    QList<QString> knownConfigs = accessPointConfigurations.keys();

    QList<QString> knownSnapConfigs = snapConfigurations.keys();

#ifdef SNAP_FUNCTIONALITY_AVAILABLE    

    // S60 version is >= Series60 3rd Edition Feature Pack 2

    TInt error = KErrNone;

    // Loop through all IAPs

    RArray<TUint32> connectionMethods; // IAPs

    CleanupClosePushL(connectionMethods);

    iCmManager.ConnectionMethodL(connectionMethods);

    for(int i = 0; i < connectionMethods.Count(); i++) {

        RCmConnectionMethod connectionMethod = iCmManager.ConnectionMethodL(connectionMethods[i]);

        CleanupClosePushL(connectionMethod);

        TUint32 iapId = connectionMethod.GetIntAttributeL(CMManager::ECmIapId);

        QString ident = QString::number(qHash(iapId));

        if (accessPointConfigurations.contains(ident)) {

            knownConfigs.removeOne(ident);

        } else {

            SymbianNetworkConfigurationPrivate* cpPriv = NULL;

            TRAP(error, cpPriv = configFromConnectionMethodL(connectionMethod));

            if (error == KErrNone) {

                QNetworkConfigurationPrivatePointer ptr(cpPriv);

                accessPointConfigurations.insert(ptr->id, ptr);

                locker.unlock();

                emit configurationAdded(ptr);

                locker.relock();

            }

        }

        CleanupStack::PopAndDestroy(&connectionMethod);

    }

    CleanupStack::PopAndDestroy(&connectionMethods);

    // Loop through all SNAPs

    RArray<TUint32> destinations;

    CleanupClosePushL(destinations);

    iCmManager.AllDestinationsL(destinations);

    for(int i = 0; i < destinations.Count(); i++) {

        RCmDestination destination;

        destination = iCmManager.DestinationL(destinations[i]);

        CleanupClosePushL(destination);

        QString ident = QString::number(qHash(destination.Id()+KValueThatWillBeAddedToSNAPId)); //TODO: Check if it's ok to add 1000 SNAP Id to prevent SNAP ids overlapping IAP ids

        if (snapConfigurations.contains(ident)) {

            knownSnapConfigs.removeOne(ident);

        } else {

            SymbianNetworkConfigurationPrivate *cpPriv = new SymbianNetworkConfigurationPrivate;

            CleanupStack::PushL(cpPriv);

            HBufC *pName = destination.NameLC();

            cpPriv->name = QString::fromUtf16(pName->Ptr(),pName->Length());

            CleanupStack::PopAndDestroy(pName);

            pName = NULL;

            cpPriv->isValid = true;

            cpPriv->id = ident;

            cpPriv->numericId = destination.Id();

            cpPriv->connectionId = 0;

            cpPriv->state = QNetworkConfiguration::Defined;

            cpPriv->type = QNetworkConfiguration::ServiceNetwork;

            cpPriv->purpose = QNetworkConfiguration::UnknownPurpose;

            cpPriv->roamingSupported = false;

            QNetworkConfigurationPrivatePointer ptr(cpPriv);

            snapConfigurations.insert(ident, ptr);

            locker.unlock();

            emit configurationAdded(ptr);

            locker.relock();

            CleanupStack::Pop(cpPriv);

        }

        QNetworkConfigurationPrivatePointer privSNAP = snapConfigurations.value(ident);

        for (int j=0; j < destination.ConnectionMethodCount(); j++) {

            RCmConnectionMethod connectionMethod = destination.ConnectionMethodL(j);

            CleanupClosePushL(connectionMethod);

            TUint32 iapId = connectionMethod.GetIntAttributeL(CMManager::ECmIapId);

            QString iface = QString::number(qHash(iapId));

            // Check that IAP can be found from accessPointConfigurations list

            QNetworkConfigurationPrivatePointer priv = accessPointConfigurations.value(iface);

            if (!priv) {

                SymbianNetworkConfigurationPrivate *cpPriv = NULL;

                TRAP(error, cpPriv = configFromConnectionMethodL(connectionMethod));

                if (error == KErrNone) {

                    QNetworkConfigurationPrivatePointer ptr(cpPriv);

                    toSymbianConfig(ptr)->serviceNetworkPtr = privSNAP;

                    accessPointConfigurations.insert(ptr->id, ptr);

                    locker.unlock();

                    emit configurationAdded(ptr);

                    locker.relock();

                    privSNAP->serviceNetworkMembers.append(ptr);

                }

            } else {

                knownConfigs.removeOne(iface);

                // Check that IAP can be found from related SNAP's configuration list

                bool iapFound = false;

                for (int i = 0; i < privSNAP->serviceNetworkMembers.count(); i++) {

                    if (toSymbianConfig(privSNAP->serviceNetworkMembers[i])->numericId == iapId) {

                        iapFound = true;

                        break;

                    }

                }

                if (!iapFound) {

                    toSymbianConfig(priv)->serviceNetworkPtr = privSNAP;

                    privSNAP->serviceNetworkMembers.append(priv);

                }

            }

            CleanupStack::PopAndDestroy(&connectionMethod);

        }

        if (privSNAP->serviceNetworkMembers.count() > 1) {

            // Roaming is supported only if SNAP contains more than one IAP

            privSNAP->roamingSupported = true;

        }

        CleanupStack::PopAndDestroy(&destination);

    }

    CleanupStack::PopAndDestroy(&destinations);

#else

    // S60 version is < Series60 3rd Edition Feature Pack 2

    CCommsDbTableView* pDbTView = ipCommsDB->OpenTableLC(TPtrC(IAP));

    // Loop through all IAPs

    TUint32 apId = 0;

    TInt retVal = pDbTView->GotoFirstRecord();

    while (retVal == KErrNone) {

        pDbTView->ReadUintL(TPtrC(COMMDB_ID), apId);

        QString ident = QString::number(qHash(apId));

        if (accessPointConfigurations.contains(ident)) {

            knownConfigs.removeOne(ident);

        } else {

            SymbianNetworkConfigurationPrivate *cpPriv = new SymbianNetworkConfigurationPrivate;

            if (readNetworkConfigurationValuesFromCommsDb(apId, cpPriv)) {

                QNetworkConfigurationPrivatePointer ptr(cpPriv);

                accessPointConfigurations.insert(ident, ptr);

                locker.unlock();

                emit configurationAdded(ptr);

                locker.relock();

            } else {

                delete cpPriv;

            }

        }

        retVal = pDbTView->GotoNextRecord();

    }

    CleanupStack::PopAndDestroy(pDbTView);

#endif

    updateActiveAccessPoints();

    foreach (const QString &oldIface, knownConfigs) {

        //remove non existing IAP

        QNetworkConfigurationPrivatePointer ptr = accessPointConfigurations.take(oldIface);

        locker.unlock();

        emit configurationRemoved(ptr);

        locker.relock();

        // Remove non existing IAP from SNAPs

        foreach (const QString &iface, snapConfigurations.keys()) {

            QNetworkConfigurationPrivatePointer ptr2 = snapConfigurations.value(iface);

            // => Check if one of the IAPs of the SNAP is active

            for (int i = 0; i < ptr2->serviceNetworkMembers.count(); ++i) {

                if (toSymbianConfig(ptr2->serviceNetworkMembers[i])->numericId ==

                    toSymbianConfig(ptr)->numericId) {

                    ptr2->serviceNetworkMembers.removeAt(i);

                    break;

                }

            }

        }    

    }

    foreach (const QString &oldIface, knownSnapConfigs) {

        //remove non existing SNAPs

        QNetworkConfigurationPrivatePointer ptr = snapConfigurations.take(oldIface);

        locker.unlock();

        emit configurationRemoved(ptr);

        locker.relock();

    }

}

#ifdef SNAP_FUNCTIONALITY_AVAILABLE

SymbianNetworkConfigurationPrivate *SymbianEngine::configFromConnectionMethodL(

        RCmConnectionMethod& connectionMethod)

{

    QMutexLocker locker(&mutex);

    SymbianNetworkConfigurationPrivate *cpPriv = new SymbianNetworkConfigurationPrivate;

    CleanupStack::PushL(cpPriv);

    TUint32 iapId = connectionMethod.GetIntAttributeL(CMManager::ECmIapId);

    QString ident = QString::number(qHash(iapId));

    HBufC *pName = connectionMethod.GetStringAttributeL(CMManager::ECmName);

    CleanupStack::PushL(pName);

    cpPriv->name = QString::fromUtf16(pName->Ptr(),pName->Length());

    CleanupStack::PopAndDestroy(pName);

    pName = NULL;

    TUint32 bearerId = connectionMethod.GetIntAttributeL(CMManager::ECmCommsDBBearerType);

    switch (bearerId) {

    case KCommDbBearerCSD:

        cpPriv->bearer = SymbianNetworkConfigurationPrivate::Bearer2G;

        break;

    case KCommDbBearerWcdma:

        cpPriv->bearer = SymbianNetworkConfigurationPrivate::BearerWCDMA;

        break;

    case KCommDbBearerLAN:

        cpPriv->bearer = SymbianNetworkConfigurationPrivate::BearerEthernet;

        break;

    case KCommDbBearerVirtual:

        cpPriv->bearer = SymbianNetworkConfigurationPrivate::BearerUnknown;

        break;

    case KCommDbBearerPAN:

        cpPriv->bearer = SymbianNetworkConfigurationPrivate::BearerUnknown;

        break;

    case KCommDbBearerWLAN:

        cpPriv->bearer = SymbianNetworkConfigurationPrivate::BearerWLAN;

        break;

    default:

        cpPriv->bearer = SymbianNetworkConfigurationPrivate::BearerUnknown;

        break;

    }

    TInt error = KErrNone;

    TUint32 bearerType = connectionMethod.GetIntAttributeL(CMManager::ECmBearerType);

    switch (bearerType) {

    case KUidPacketDataBearerType:

        // "Packet data" Bearer => Mapping is done using "Access point name"

        TRAP(error, pName = connectionMethod.GetStringAttributeL(CMManager::EPacketDataAPName));

        break;

    case KUidWlanBearerType:

        // "Wireless LAN" Bearer => Mapping is done using "WLAN network name" = SSID

        TRAP(error, pName = connectionMethod.GetStringAttributeL(CMManager::EWlanSSID));

        break;

    }

    if (!pName) {

        // "Data call" Bearer or "High Speed (GSM)" Bearer => Mapping is done using "Dial-up number"

        TRAP(error, pName = connectionMethod.GetStringAttributeL(CMManager::EDialDefaultTelNum));

    }

    if (error == KErrNone && pName) {

        CleanupStack::PushL(pName);

        cpPriv->mappingName = QString::fromUtf16(pName->Ptr(),pName->Length());

        CleanupStack::PopAndDestroy(pName);

        pName = NULL;

    }

    cpPriv->state = QNetworkConfiguration::Defined;

    TBool isConnected = connectionMethod.GetBoolAttributeL(CMManager::ECmConnected);

    if (isConnected) {

        cpPriv->state = QNetworkConfiguration::Active;

    }

    cpPriv->isValid = true;

    cpPriv->id = ident;

    cpPriv->numericId = iapId;

    cpPriv->connectionId = 0;

    cpPriv->type = QNetworkConfiguration::InternetAccessPoint;

    cpPriv->purpose = QNetworkConfiguration::UnknownPurpose;

    cpPriv->roamingSupported = false;

    CleanupStack::Pop(cpPriv);

    return cpPriv;

}

#else

bool SymbianEngine::readNetworkConfigurationValuesFromCommsDb(

        TUint32 aApId, SymbianNetworkConfigurationPrivate *apNetworkConfiguration)

{