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

**

** 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 "qnetworkmanagerengine.h"

#include "qnetworkmanagerservice.h"

#include "../qnetworksession_impl.h"

#include <QtNetwork/private/qnetworkconfiguration_p.h>

#include <QtNetwork/qnetworksession.h>

#include <QtCore/qdebug.h>

#include <QtDBus>

#include <QDBusConnection>

#include <QDBusError>

#include <QDBusInterface>

#include <QDBusMessage>

#include <QDBusReply>

#ifndef QT_NO_BEARERMANAGEMENT

#ifndef QT_NO_DBUS

QT_BEGIN_NAMESPACE

QNetworkManagerEngine::QNetworkManagerEngine(QObject *parent)

:   QBearerEngineImpl(parent),

    interface(new QNetworkManagerInterface(this)),

    systemSettings(new QNetworkManagerSettings(NM_DBUS_SERVICE_SYSTEM_SETTINGS, this)),

    userSettings(new QNetworkManagerSettings(NM_DBUS_SERVICE_USER_SETTINGS, this))

{

    if (!interface->isValid())

        return;

    interface->setConnections();

    connect(interface, SIGNAL(deviceAdded(QDBusObjectPath)),

            this, SLOT(deviceAdded(QDBusObjectPath)));

    connect(interface, SIGNAL(deviceRemoved(QDBusObjectPath)),

            this, SLOT(deviceRemoved(QDBusObjectPath)));

#if 0

    connect(interface, SIGNAL(stateChanged(const QString,quint32)),

            this, SIGNAL(configurationsChanged()));

#endif

    connect(interface, SIGNAL(activationFinished(QDBusPendingCallWatcher*)),

            this, SLOT(activationFinished(QDBusPendingCallWatcher*)));

    connect(interface, SIGNAL(propertiesChanged(QString,QMap<QString,QVariant>)),

            this, SLOT(interfacePropertiesChanged(QString,QMap<QString,QVariant>)));

    qDBusRegisterMetaType<QNmSettingsMap>();

    systemSettings->setConnections();

    connect(systemSettings, SIGNAL(newConnection(QDBusObjectPath)),

            this, SLOT(newConnection(QDBusObjectPath)));

    userSettings->setConnections();

    connect(userSettings, SIGNAL(newConnection(QDBusObjectPath)),

            this, SLOT(newConnection(QDBusObjectPath)));

}

QNetworkManagerEngine::~QNetworkManagerEngine()

{

}

void QNetworkManagerEngine::initialize()

{

    QMutexLocker locker(&mutex);

    // Get current list of access points.

        deviceAdded(devicePath);

    // Get connections.

        newConnection(settingsPath, systemSettings);

        newConnection(settingsPath, userSettings);

    // Get active connections.

    foreach (const QDBusObjectPath &acPath, interface->activeConnections()) {

        QNetworkManagerConnectionActive *activeConnection =

            new QNetworkManagerConnectionActive(acPath.path());

        activeConnections.insert(acPath.path(), activeConnection);

        activeConnection->setConnections();

        connect(activeConnection, SIGNAL(propertiesChanged(QString,QMap<QString,QVariant>)),

                this, SLOT(activeConnectionPropertiesChanged(QString,QMap<QString,QVariant>)));

    }

}

bool QNetworkManagerEngine::networkManagerAvailable() const

{

    QMutexLocker locker(&mutex);

    return interface->isValid();

}

QString QNetworkManagerEngine::getInterfaceFromId(const QString &id)

{

    QMutexLocker locker(&mutex);

    foreach (const QDBusObjectPath &acPath, interface->activeConnections()) {

        QNetworkManagerConnectionActive activeConnection(acPath.path());

        const QString identifier = QString::number(qHash(activeConnection.serviceName() + ' ' +

                                                         activeConnection.connection().path()));

        if (id == identifier) {

            QList<QDBusObjectPath> devices = activeConnection.devices();

            if (devices.isEmpty())

                continue;

            QNetworkManagerInterfaceDevice device(devices.at(0).path());

            return device.networkInterface();

        }

    }

    return QString();

}

bool QNetworkManagerEngine::hasIdentifier(const QString &id)

{

    QMutexLocker locker(&mutex);

    if (connectionFromId(id))

        return true;

    for (int i = 0; i < accessPoints.count(); ++i) {

        QNetworkManagerInterfaceAccessPoint *accessPoint = accessPoints.at(i);

        const QString identifier =

            QString::number(qHash(accessPoint->connectionInterface()->path()));

        if (id == identifier)

            return true;

    }

    return false;

}

void QNetworkManagerEngine::connectToId(const QString &id)

{

    QMutexLocker locker(&mutex);

    QNetworkManagerSettingsConnection *connection = connectionFromId(id);

    if (!connection)

        return;

    QNmSettingsMap map = connection->getSettings();

    const QString connectionType = map.value("connection").value("type").toString();

    QString dbusDevicePath;

    foreach (const QDBusObjectPath &devicePath, interface->getDevices()) {

        QNetworkManagerInterfaceDevice device(devicePath.path());

        if (device.deviceType() == DEVICE_TYPE_802_3_ETHERNET &&

            connectionType == QLatin1String("802-3-ethernet")) {

            dbusDevicePath = devicePath.path();

            break;

        } else if (device.deviceType() == DEVICE_TYPE_802_11_WIRELESS &&

                   connectionType == QLatin1String("802-11-wireless")) {

            dbusDevicePath = devicePath.path();

            break;

        }

    }

    const QString service = connection->connectionInterface()->service();

    const QString settingsPath = connection->connectionInterface()->path();

    interface->activateConnection(service, QDBusObjectPath(settingsPath),

                                  QDBusObjectPath(dbusDevicePath), QDBusObjectPath("/"));

}

void QNetworkManagerEngine::disconnectFromId(const QString &id)

{

    QMutexLocker locker(&mutex);

    foreach (const QDBusObjectPath &acPath, interface->activeConnections()) {

        QNetworkManagerConnectionActive activeConnection(acPath.path());

        const QString identifier = QString::number(qHash(activeConnection.serviceName() + ' ' +

                                                         activeConnection.connection().path()));

        if (id == identifier && accessPointConfigurations.contains(id)) {

            interface->deactivateConnection(acPath);

            break;

        }

    }

}

void QNetworkManagerEngine::requestUpdate()

{

}

void QNetworkManagerEngine::interfacePropertiesChanged(const QString &path,

                                                       const QMap<QString, QVariant> &properties)

{

    QMutexLocker locker(&mutex);

    Q_UNUSED(path)

    QMapIterator<QString, QVariant> i(properties);

    while (i.hasNext()) {

        i.next();

        if (i.key() == QLatin1String("ActiveConnections")) {

            // Active connections changed, update configurations.

            QList<QDBusObjectPath> activeConnections =

                qdbus_cast<QList<QDBusObjectPath> >(i.value().value<QDBusArgument>());

            QStringList identifiers = accessPointConfigurations.keys();

            foreach (const QString &id, identifiers)

                QNetworkConfigurationPrivatePointer ptr = accessPointConfigurations.value(id);

            QStringList priorActiveConnections = this->activeConnections.keys();

            foreach (const QDBusObjectPath &acPath, activeConnections) {

                priorActiveConnections.removeOne(acPath.path());

                QNetworkManagerConnectionActive *activeConnection =

                    this->activeConnections.value(acPath.path());

                if (!activeConnection) {

                    activeConnection = new QNetworkManagerConnectionActive(acPath.path());

                    this->activeConnections.insert(acPath.path(), activeConnection);

                    activeConnection->setConnections();

                    connect(activeConnection, SIGNAL(propertiesChanged(QString,QMap<QString,QVariant>)),

                            this, SLOT(activeConnectionPropertiesChanged(QString,QMap<QString,QVariant>)));

                }

                const QString id = QString::number(qHash(activeConnection->serviceName() + ' ' +

                                                         activeConnection->connection().path()));

                identifiers.removeOne(id);

                QNetworkConfigurationPrivatePointer ptr = accessPointConfigurations.value(id);

                if (ptr) {

                    ptr->mutex.lock();

                    if (activeConnection->state() == 2 &&

                        ptr->state != QNetworkConfiguration::Active) {

                        ptr->state = QNetworkConfiguration::Active;

                        ptr->mutex.unlock();

                        locker.unlock();

                        emit configurationChanged(ptr);

                        locker.relock();

                    } else {

                        ptr->mutex.unlock();

                    }

                }

            }

            while (!priorActiveConnections.isEmpty())

                delete this->activeConnections.take(priorActiveConnections.takeFirst());

            while (!identifiers.isEmpty()) {

                // These configurations are not active

                QNetworkConfigurationPrivatePointer ptr =

                    accessPointConfigurations.value(identifiers.takeFirst());

                ptr->mutex.lock();

                if ((ptr->state & QNetworkConfiguration::Active) == QNetworkConfiguration::Active) {

                    ptr->state = QNetworkConfiguration::Discovered;

                    ptr->mutex.unlock();

                    locker.unlock();

                    emit configurationChanged(ptr);

                    locker.relock();

                } else {

                    ptr->mutex.unlock();

                }

            }

        }

    }

}

void QNetworkManagerEngine::activeConnectionPropertiesChanged(const QString &path,

                                                              const QMap<QString, QVariant> &properties)

{

    QMutexLocker locker(&mutex);

    Q_UNUSED(properties)

    QNetworkManagerConnectionActive *activeConnection = activeConnections.value(path);

    if (!activeConnection)

        return;

    const QString id = QString::number(qHash(activeConnection->serviceName() + ' ' +

                                             activeConnection->connection().path()));

    QNetworkConfigurationPrivatePointer ptr = accessPointConfigurations.value(id);

    if (ptr) {

        ptr->mutex.lock();

        if (activeConnection->state() == 2 &&

            ptr->state != QNetworkConfiguration::Active) {

            ptr->state = QNetworkConfiguration::Active;

            ptr->mutex.unlock();

            locker.unlock();

            emit configurationChanged(ptr);

            locker.relock();

        } else {

            ptr->mutex.unlock();

        }

    }

}

void QNetworkManagerEngine::devicePropertiesChanged(const QString &path,

                                                    const QMap<QString, QVariant> &properties)

{

    Q_UNUSED(path);

    Q_UNUSED(properties);

}

void QNetworkManagerEngine::deviceAdded(const QDBusObjectPath &path)

{

    QNetworkManagerInterfaceDevice device(path.path());

    if (device.deviceType() == DEVICE_TYPE_802_11_WIRELESS) {

        QNetworkManagerInterfaceDeviceWireless *wirelessDevice =

            new QNetworkManagerInterfaceDeviceWireless(device.connectionInterface()->path());

        wirelessDevice->setConnections();

        connect(wirelessDevice, SIGNAL(accessPointAdded(QString,QDBusObjectPath)),

                this, SLOT(newAccessPoint(QString,QDBusObjectPath)));

        connect(wirelessDevice, SIGNAL(accessPointRemoved(QString,QDBusObjectPath)),

                this, SLOT(removeAccessPoint(QString,QDBusObjectPath)));

        connect(wirelessDevice, SIGNAL(propertiesChanged(QString,QMap<QString,QVariant>)),

                this, SLOT(devicePropertiesChanged(QString,QMap<QString,QVariant>)));

        foreach (const QDBusObjectPath &apPath, wirelessDevice->getAccessPoints())

            newAccessPoint(QString(), apPath);

    }

}

void QNetworkManagerEngine::deviceRemoved(const QDBusObjectPath &path)

{

    QMutexLocker locker(&mutex);

    delete wirelessDevices.value(path.path());

}

void QNetworkManagerEngine::newConnection(const QDBusObjectPath &path,

                                          QNetworkManagerSettings *settings)

{

    QMutexLocker locker(&mutex);

    if (!settings)

        settings = qobject_cast<QNetworkManagerSettings *>(sender());

    if (!settings)

        return;

    QNetworkManagerSettingsConnection *connection =

        new QNetworkManagerSettingsConnection(settings->connectionInterface()->service(),

                                              path.path());

    connections.append(connection);

    connect(connection, SIGNAL(removed(QString)), this, SLOT(removeConnection(QString)));

    connect(connection, SIGNAL(updated(const QNmSettingsMap&)),

            this, SLOT(updateConnection(const QNmSettingsMap&)));

    const QString service = connection->connectionInterface()->service();

    const QString settingsPath = connection->connectionInterface()->path();

    QNetworkConfigurationPrivate *cpPriv =

        parseConnection(service, settingsPath, connection->getSettings());

    // Check if connection is active.

    foreach (const QDBusObjectPath &acPath, interface->activeConnections()) {

        QNetworkManagerConnectionActive activeConnection(acPath.path());

        if (activeConnection.serviceName() == service &&

            activeConnection.connection().path() == settingsPath &&

            activeConnection.state() == 2) {

            cpPriv->state |= QNetworkConfiguration::Active;

            break;

        }

    }

    QNetworkConfigurationPrivatePointer ptr(cpPriv);

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

    locker.unlock();

    emit configurationAdded(ptr);

}

void QNetworkManagerEngine::removeConnection(const QString &path)

{

    QMutexLocker locker(&mutex);

    Q_UNUSED(path)

    QNetworkManagerSettingsConnection *connection =

        qobject_cast<QNetworkManagerSettingsConnection *>(sender());

    if (!connection)

        return;

    connections.removeAll(connection);

    const QString id = QString::number(qHash(connection->connectionInterface()->service() + ' ' +

                                             connection->connectionInterface()->path()));

    QNetworkConfigurationPrivatePointer ptr = accessPointConfigurations.take(id);

    locker.unlock();

    emit configurationRemoved(ptr);

}

void QNetworkManagerEngine::updateConnection(const QNmSettingsMap &settings)

{

    QMutexLocker locker(&mutex);

    QNetworkManagerSettingsConnection *connection =

        qobject_cast<QNetworkManagerSettingsConnection *>(sender());

    if (!connection)

        return;

    const QString service = connection->connectionInterface()->service();

    const QString settingsPath = connection->connectionInterface()->path();

    QNetworkConfigurationPrivate *cpPriv = parseConnection(service, settingsPath, settings);

    // Check if connection is active.

    foreach (const QDBusObjectPath &acPath, interface->activeConnections()) {

        QNetworkManagerConnectionActive activeConnection(acPath.path());

        if (activeConnection.serviceName() == service &&

            activeConnection.connection().path() == settingsPath &&

            activeConnection.state() == NM_ACTIVE_CONNECTION_STATE_ACTIVATED) {

            cpPriv->state |= QNetworkConfiguration::Active;

            break;

        }

    }

    QNetworkConfigurationPrivatePointer ptr = accessPointConfigurations.value(cpPriv->id);

    ptr->mutex.lock();

    ptr->isValid = cpPriv->isValid;

    ptr->name = cpPriv->name;

    ptr->id = cpPriv->id;

    ptr->state = cpPriv->state;

    ptr->mutex.unlock();

    locker.unlock();

    emit configurationChanged(ptr);

    delete cpPriv;

}

void QNetworkManagerEngine::activationFinished(QDBusPendingCallWatcher *watcher)

{

    QMutexLocker locker(&mutex);

    QDBusPendingReply<QDBusObjectPath> reply = *watcher;

    if (!reply.isError()) {

        QDBusObjectPath result = reply.value();

        QNetworkManagerConnectionActive activeConnection(result.path());

        const QString id = QString::number(qHash(activeConnection.serviceName() + ' ' +

                                                 activeConnection.connection().path()));

        QNetworkConfigurationPrivatePointer ptr = accessPointConfigurations.value(id);

        if (ptr) {

            ptr->mutex.lock();

            if (activeConnection.state() == 2 &&

                ptr->state != QNetworkConfiguration::Active) {

                ptr->state = QNetworkConfiguration::Active;

                ptr->mutex.unlock();

                locker.unlock();

                emit configurationChanged(ptr);