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

**

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

    #include <ApAccessPointItem.h>

    #include <ApDataHandler.h>

#endif

#ifndef QT_NO_BEARERMANAGEMENT

QT_BEGIN_NAMESPACE

static const int KUserChoiceIAPId = 0;

SymbianNetworkConfigurationPrivate::SymbianNetworkConfigurationPrivate()

{

}

SymbianNetworkConfigurationPrivate::~SymbianNetworkConfigurationPrivate()

{

}

SymbianEngine::SymbianEngine(QObject *parent)

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

    iUpdatePending(false)

{

}

void SymbianEngine::initialize()

{

    QMutexLocker locker(&mutex);

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

#ifdef SNAP_FUNCTIONALITY_AVAILABLE

    TRAP_IGNORE(iConnectionMonitor.SetUintAttribute(EBearerIdAll, 0, KBearerGroupThreshold, 1));

#endif

    TRAP_IGNORE(iConnectionMonitor.NotifyEventL(*this));

#ifdef SNAP_FUNCTIONALITY_AVAILABLE

    TRAP(error, iCmManager.OpenL());

    if (error != KErrNone) {

        iInitOk = false;

        return;

    }

#endif

    SymbianNetworkConfigurationPrivate *cpPriv = new SymbianNetworkConfigurationPrivate;

    cpPriv->name = "UserChoice";

    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;

}

void SymbianEngine::delayedConfigurationUpdate()

{

    QMutexLocker locker(&mutex);

    if (iUpdatePending) {

#ifdef QT_BEARERMGMT_SYMBIAN_DEBUG

        qDebug("QNCM delayed configuration update (ECommit or ERecover occurred).");

#endif

        TRAPD(error, updateConfigurationsL());

        if (error == KErrNone) {

            updateStatesToSnaps();

        }

        iUpdatePending = false;

        // Start monitoring again.

        if (!IsActive()) {

            SetActive();

            // Start waiting for new notification

            ipCommsDB->RequestNotification(iStatus);

        }

    }

}

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

{

    if (!iInitOk)

        return;

    TRAP_IGNORE(updateConfigurationsL());

}

void SymbianEngine::updateConfigurationsL()

{

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

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

    // 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 = QT_BEARERMGMT_CONFIGURATION_IAP_PREFIX+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);

            }

        }

        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;

        CleanupClosePushL(destination);

        QString ident = QT_BEARERMGMT_CONFIGURATION_SNAP_PREFIX +

                        QString::number(qHash(destination.Id()));

        if (snapConfigurations.contains(ident)) {

            knownSnapConfigs.removeOne(ident);

        } else {

            SymbianNetworkConfigurationPrivate *cpPriv = new SymbianNetworkConfigurationPrivate;

            HBufC *pName = destination.NameLC();

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

        }

        // Loop through all connection methods in this SNAP

        QMap<unsigned int, QNetworkConfigurationPrivatePointer> connections;

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

            RCmConnectionMethod connectionMethod = destination.ConnectionMethodL(j);

            CleanupClosePushL(connectionMethod);

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

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

            // Check that IAP can be found from accessPointConfigurations list

            QNetworkConfigurationPrivatePointer ptr = accessPointConfigurations.value(iface);

                SymbianNetworkConfigurationPrivate *cpPriv = NULL;

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

                if (error == KErrNone) {

                    ptr = QNetworkConfigurationPrivatePointer(cpPriv);

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

                }

            }

            if (ptr) {

                unsigned int priority;

                TRAPD(error, priority = destination.PriorityL(connectionMethod));

                if (!error)

                    connections.insert(priority, ptr);

            }

            CleanupStack::PopAndDestroy(&connectionMethod);

        }

        QNetworkConfigurationPrivatePointer privSNAP = snapConfigurations.value(ident);

        QMutexLocker snapConfigLocker(&privSNAP->mutex);

        if (privSNAP->serviceNetworkMembers != connections) {

            privSNAP->serviceNetworkMembers = connections;

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

            privSNAP->roamingSupported = privSNAP->serviceNetworkMembers.count() > 1;

            snapConfigLocker.unlock();

            mutex.unlock();

            QT_TRYCATCH_LEAVING(emit configurationChanged(privSNAP));

            mutex.lock();

        }

        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 = QT_BEARERMGMT_CONFIGURATION_IAP_PREFIX+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);

            } else {

                delete cpPriv;

            }

        }

        retVal = pDbTView->GotoNextRecord();

    }

    CleanupStack::PopAndDestroy(pDbTView);

#endif

    QT_TRYCATCH_LEAVING(updateActiveAccessPoints());

    foreach (const QString &oldIface, knownConfigs) {

        //remove non existing IAP

        QNetworkConfigurationPrivatePointer ptr = accessPointConfigurations.take(oldIface);

        mutex.unlock();

        emit configurationRemoved(ptr);

        QT_TRYCATCH_LEAVING(emit configurationRemoved(ptr));

        mutex.lock();

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

            QMutexLocker snapConfigLocker(&ptr2->mutex);

            QMutableMapIterator<unsigned int, QNetworkConfigurationPrivatePointer> i(ptr2->serviceNetworkMembers);

            while (i.hasNext()) {

                i.next();

                if (toSymbianConfig(i.value())->numericIdentifier() ==

                    toSymbianConfig(ptr)->numericIdentifier()) {

                    i.remove();

                    break;

                }

            }

        }    

    }

    foreach (const QString &oldIface, knownSnapConfigs) {

        //remove non existing SNAPs

        QNetworkConfigurationPrivatePointer ptr = snapConfigurations.take(oldIface);

        mutex.unlock();

        emit configurationRemoved(ptr);

        QT_TRYCATCH_LEAVING(emit configurationRemoved(ptr));

        mutex.lock();

    }

    // find default configuration.

    stopCommsDatabaseNotifications();

    TRAP_IGNORE(defaultConfig = defaultConfigurationL());

    startCommsDatabaseNotifications();

}

#ifdef SNAP_FUNCTIONALITY_AVAILABLE

SymbianNetworkConfigurationPrivate *SymbianEngine::configFromConnectionMethodL(

        RCmConnectionMethod& connectionMethod)

{

    SymbianNetworkConfigurationPrivate *cpPriv = new SymbianNetworkConfigurationPrivate;

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

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

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

    CleanupStack::PushL(pName);

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

    CleanupStack::PopAndDestroy(pName);

    pName = NULL;

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

    switch (bearerId) {

    case KCommDbBearerCSD:

        break;

    case KCommDbBearerWcdma:

        break;

    case KCommDbBearerLAN:

        break;

    case KCommDbBearerVirtual:

        break;

    case KCommDbBearerPAN:

        break;

    case KCommDbBearerWLAN:

        break;

    default: