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

**

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

#endif

#ifndef QT_NO_BEARERMANAGEMENT

QT_BEGIN_NAMESPACE

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)

{

    CActiveScheduler::Add(this);

    // Seed the randomgenerator

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

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

    if (error != KErrNone) {

        iInitOk = false;

        return;

    }

    TRAP_IGNORE(iConnectionMonitor.ConnectL());

    TRAP_IGNORE(iConnectionMonitor.NotifyEventL(*this));

    TRAP(error, iCmManager.OpenL());

    if (error != KErrNone) {

        iInitOk = false;

        return;

    }

#endif

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

{

        return;

    TRAP_IGNORE(updateConfigurationsL());

}

void SymbianEngine::updateConfigurationsL()

{

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

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

            }

        }

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

        if (snapConfigurations.contains(ident)) {

            knownSnapConfigs.removeOne(ident);

        } else {

            SymbianNetworkConfigurationPrivate *cpPriv = new SymbianNetworkConfigurationPrivate;

            HBufC *pName = destination.NameLC();

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

        }

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

            RCmConnectionMethod connectionMethod = destination.ConnectionMethodL(j);

            CleanupClosePushL(connectionMethod);

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

            // Check that IAP can be found from accessPointConfigurations list

                SymbianNetworkConfigurationPrivate *cpPriv = NULL;

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

                if (error == KErrNone) {

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

                }

            }

            CleanupStack::PopAndDestroy(&connectionMethod);

        }

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

        }

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

        if (accessPointConfigurations.contains(ident)) {

            knownConfigs.removeOne(ident);

        } else {

            SymbianNetworkConfigurationPrivate *cpPriv = new SymbianNetworkConfigurationPrivate;

            if (readNetworkConfigurationValuesFromCommsDb(apId, cpPriv)) {

                QNetworkConfigurationPrivatePointer ptr(cpPriv);

                accessPointConfigurations.insert(ident, ptr);

            } else {

                delete cpPriv;

            }

        }

        retVal = pDbTView->GotoNextRecord();

    }

    CleanupStack::PopAndDestroy(pDbTView);

#endif

    foreach (const QString &oldIface, knownConfigs) {

        //remove non existing IAP

        QNetworkConfigurationPrivatePointer ptr = accessPointConfigurations.take(oldIface);

        emit configurationRemoved(ptr);

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

                    break;

                }

            }

        }    

    }

    foreach (const QString &oldIface, knownSnapConfigs) {

        //remove non existing SNAPs

        QNetworkConfigurationPrivatePointer ptr = snapConfigurations.take(oldIface);

        emit configurationRemoved(ptr);

    }

}

#ifdef SNAP_FUNCTIONALITY_AVAILABLE

SymbianNetworkConfigurationPrivate *SymbianEngine::configFromConnectionMethodL(

        RCmConnectionMethod& connectionMethod)

{

    SymbianNetworkConfigurationPrivate *cpPriv = new SymbianNetworkConfigurationPrivate;

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

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

    CleanupStack::PushL(pName);

    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"