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

**

** All rights reserved.

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

**

** This file is part of the Qt Mobility Components.

**

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

#include <QSize>

#include <QFile>

#include <QTextStream>

#include <QLocale>

#include <QLibraryInfo>

//#include <QtGui>

#include <QDesktopWidget>

#include <QDebug>

#include <QTimer>

#include <QDir>

#include <QTimer>

#include <QMapIterator>

#if !defined(QT_NO_DBUS)

#include "gconfitem_p.h" // Temporarily here.

#endif

#ifdef Q_WS_X11

#include <QX11Info>

#include <X11/Xlib.h>

#endif

#include <QDBusInterface>

#if !defined(QT_NO_DBUS)

QDBusArgument &operator<<(QDBusArgument &argument, const ProfileDataValue &value)

{

  argument.beginStructure();

  argument << value.key << value.val << value.type;

  argument.endStructure();

  return argument;

}

const QDBusArgument &operator>>(const QDBusArgument &argument, ProfileDataValue &value)

{

  argument.beginStructure();

  argument >> value.key >> value.val >> value.type;

  argument.endStructure();

  return argument;

}

#endif

QTM_BEGIN_NAMESPACE

QSystemInfoPrivate::QSystemInfoPrivate(QSystemInfoLinuxCommonPrivate *parent)

 : QSystemInfoLinuxCommonPrivate(parent)

{

}

QSystemInfoPrivate::~QSystemInfoPrivate()

{

}

QStringList QSystemInfoPrivate::availableLanguages() const

{

    QStringList languages;

    GConfItem languagesItem("/apps/osso/inputmethod/available_languages");

    const QStringList locales = languagesItem.value().toStringList();

    foreach(const QString locale, locales) {

        languages << locale.mid(0,2);

    }

    languages << currentLanguage();

    languages.removeDuplicates();

    return languages;

}

QString QSystemInfoPrivate::version(QSystemInfo::Version type,

                                    const QString &parameter)

{

    QString errorStr = "Not Available";

    switch(type) {

        case QSystemInfo::Firmware :

        {

            QDBusInterface connectionInterface("com.nokia.SystemInfo",

                                               "/com/nokia/SystemInfo",

                                               "com.nokia.SystemInfo",

                                               QDBusConnection::systemBus());

            if(!connectionInterface.isValid()) {

                qWarning() << "interfacenot valid";

            } else {

                QDBusReply< QByteArray > reply =

                    connectionInterface.call("GetConfigValue",

                                             "/device/sw-release-ver");

                if(reply.isValid())

                    return reply.value();

            }

            break;

        }

        default:

            return QSystemInfoLinuxCommonPrivate::version(type, parameter);

            break;

    };

    return errorStr;

}

bool QSystemInfoPrivate::hasFeatureSupported(QSystemInfo::Feature feature)

{

    bool featureSupported = false;

    switch (feature) {

    case QSystemInfo::SimFeature :

        {

            GConfItem locationValues("/system/nokia/location");

            const QStringList locationKeys = locationValues.listEntries();

            foreach (const QString str, locationKeys) {

                if (str.contains("sim_imsi"))

                    featureSupported = true;

                break;

            }

        }

        break;

    case QSystemInfo::LocationFeature :

        {

            GConfItem locationValues("/system/nokia/location");

            const QStringList locationKeys = locationValues.listEntries();

            if(locationKeys.count()) {

                featureSupported = true;

            }

        }

        break;

    case QSystemInfo::HapticsFeature:

        {

           // if(halIsAvailable) {

                QHalInterface iface;

                const QStringList touchSupport =

                        iface.findDeviceByCapability("input.touchpad");

                if(touchSupport.count()) {

                    featureSupported = true;

                } else {

                    featureSupported = false;

                }

            }

      //  }

        break;

    default:

        featureSupported = QSystemInfoLinuxCommonPrivate::hasFeatureSupported(feature);

        break;

    };

    return featureSupported;

}

QSystemNetworkInfoPrivate::QSystemNetworkInfoPrivate(QSystemNetworkInfoLinuxCommonPrivate *parent)

        : QSystemNetworkInfoLinuxCommonPrivate(parent)

{

    setupNetworkInfo();

}

QSystemNetworkInfoPrivate::~QSystemNetworkInfoPrivate()

{

    if(wlanSignalStrengthTimer->isActive())

        wlanSignalStrengthTimer->stop();

}

QSystemNetworkInfo::NetworkStatus QSystemNetworkInfoPrivate::networkStatus(QSystemNetworkInfo::NetworkMode mode)

{

    switch(mode) {

    case QSystemNetworkInfo::GsmMode:

    case QSystemNetworkInfo::CdmaMode:

    case QSystemNetworkInfo::WcdmaMode:

        {    

            switch(currentCellNetworkStatus) {

                case 0: return QSystemNetworkInfo::HomeNetwork; // CS is registered to home network

                case 1: return QSystemNetworkInfo::Roaming; // CS is registered to some other network than home network

                case 2: return QSystemNetworkInfo::Roaming; // CS is registered to non-home system in a non-home area

                case 3: return QSystemNetworkInfo::NoNetworkAvailable; // CS is not in service

                case 4: return QSystemNetworkInfo::Searching; // CS is not in service, but is currently searching for service

                case 5: return QSystemNetworkInfo::NoNetworkAvailable; // CS is not in service and it is not currently searching for service

                case 6: return QSystemNetworkInfo::NoNetworkAvailable; // CS is not in service due to missing SIM or missing subscription

                case 8: return QSystemNetworkInfo::NoNetworkAvailable; // CS is in power off state

                case 9: return QSystemNetworkInfo::NoNetworkAvailable; // CS is in No Service Power Save State (currently not listening to any cell)

                case 10: return QSystemNetworkInfo::NoNetworkAvailable; // CS is in No Service Power Save State (CS is entered to this state

                                                                        // because there is no network coverage)

                case 11: return QSystemNetworkInfo::Denied; // CS is not in service due to missing subscription

                default:

                    break;

            };

        }

        break;

    case QSystemNetworkInfo::EthernetMode:

        if(currentEthernetState == "up") {

            return QSystemNetworkInfo::Connected;

        } else {

            return QSystemNetworkInfo::NoNetworkAvailable;

        }

        break;

    case QSystemNetworkInfo::WlanMode:

    case QSystemNetworkInfo::BluetoothMode:

        {

            return QSystemNetworkInfoLinuxCommonPrivate::networkStatus(mode);

        }

        break;

    default:

        break;

    };

    return QSystemNetworkInfo::UndefinedStatus;

}

qint32 QSystemNetworkInfoPrivate::networkSignalStrength(QSystemNetworkInfo::NetworkMode mode)

{ 

    switch(mode) {

    case QSystemNetworkInfo::GsmMode:

    case QSystemNetworkInfo::CdmaMode:

    case QSystemNetworkInfo::WcdmaMode:

    {

            return cellSignalStrength;

    }

    case QSystemNetworkInfo::EthernetMode: {

        QString result;

        QString baseSysDir = "/sys/class/net/";

        QString interface = QSystemNetworkInfoLinuxCommonPrivate::interfaceForMode(mode).humanReadableName();

        if (interface == "usb0") {

            QString dir = QSystemNetworkInfoLinuxCommonPrivate::interfaceForMode(mode).name();

            QString devFile = baseSysDir + dir;

            QFileInfo fi(devFile + "/carrier");

            if(fi.exists()) {

                QFile rx(fi.absoluteFilePath());

                if(rx.exists() && rx.open(QIODevice::ReadOnly | QIODevice::Text)) {

                    QTextStream stream(&rx);

                    stream >> result;

                    rx.close();

                    return result.toInt() * 100;

                    break;

                }

            }

        }

        return QSystemNetworkInfoLinuxCommonPrivate::networkSignalStrength(mode);

        break;

    }

    case QSystemNetworkInfo::WlanMode:

    case QSystemNetworkInfo::BluetoothMode:

        return QSystemNetworkInfoLinuxCommonPrivate::networkSignalStrength(mode);

        break;

    default:

        break;

    };

    return -1;

}

int QSystemNetworkInfoPrivate::cellId()

{

    return currentCellId;

}

int QSystemNetworkInfoPrivate::locationAreaCode()

{

    return currentLac;

}

QString QSystemNetworkInfoPrivate::currentMobileCountryCode()

{

    return currentMCC;

}

QString QSystemNetworkInfoPrivate::currentMobileNetworkCode()

{

    return currentMNC;

}

QString QSystemNetworkInfoPrivate::homeMobileCountryCode()

{

    QString imsi = GConfItem("/system/nokia/location/sim_imsi").value().toString();

    if (imsi.length() >= 3) {

        return imsi.left(3);

    }

        return QString();

}

QString QSystemNetworkInfoPrivate::homeMobileNetworkCode()

{

#if !defined(QT_NO_DBUS)

    QDBusInterface connectionInterface("com.nokia.phone.SIM",

                                       "/com/nokia/phone/SIM",

                                       "Phone.Sim",

                                       QDBusConnection::systemBus());

    if (!connectionInterface.isValid()) {

        qWarning() << "interface not valid";

        return QString();

    }

    QDBusReply<QByteArray> reply = connectionInterface.call(QLatin1String("read_hplmn"));

    // The MNC and MCC are split into Hex numbers in the received byte array.

    // The MNC can be 2 or 3 digits long. If it is 2 digits long, it ends with 0xF.

    // The order of the Hex numbers in the reply is:

    // mcc2 mcc1 mnc3 mcc3 mnc2 mnc1

    QString homeMobileNetworkCode;

    if (reply.isValid()) {

        QString temp = reply.value().toHex();

        QString mnc1 = temp.right(1);

        temp.chop(1);

        QString mnc2 = temp.right(1);

        temp.chop(2);

        QString mnc3 = temp.right(1);

        if (mnc3 != "f") {

            homeMobileNetworkCode.prepend(mnc3);

        }

        homeMobileNetworkCode.prepend(mnc2);

        homeMobileNetworkCode.prepend(mnc1);

        return homeMobileNetworkCode;

    }

#endif

    return QString();

}

QString QSystemNetworkInfoPrivate::networkName(QSystemNetworkInfo::NetworkMode mode)

{

    QString netname = "";

    switch(mode) {

    case QSystemNetworkInfo::CdmaMode:

    case QSystemNetworkInfo::GsmMode:

    case QSystemNetworkInfo::WcdmaMode:

        return currentOperatorName;

        break;

    case QSystemNetworkInfo::WimaxMode:

        break;

    default:

        return QSystemNetworkInfoLinuxCommonPrivate::networkName(mode);

        break;

    };

    return netname;

}

QString QSystemNetworkInfoPrivate::macAddress(QSystemNetworkInfo::NetworkMode mode)

{

    switch(mode) {

    case QSystemNetworkInfo::CdmaMode:

    case QSystemNetworkInfo::GsmMode:

    case QSystemNetworkInfo::WcdmaMode:

    case QSystemNetworkInfo::WimaxMode:

        break;

    case QSystemNetworkInfo::EthernetMode: {

        QString address;

        QString baseSysDir = "/sys/class/net/";

        QString interface = QSystemNetworkInfoLinuxCommonPrivate::interfaceForMode(mode).humanReadableName();

        if (interface == "usb0") {

            QString dir = QSystemNetworkInfoLinuxCommonPrivate::interfaceForMode(mode).name();

            QString devFile = baseSysDir + dir;

            QFileInfo fi(devFile + "/address");

            if(fi.exists()) {

                QFile rx(fi.absoluteFilePath());

                if(rx.exists() && rx.open(QIODevice::ReadOnly | QIODevice::Text)) {

                    QTextStream stream(&rx);

                    stream >> address;

                    rx.close();

                    return address;

                    break;

                }

            }

        }

        return QSystemNetworkInfoLinuxCommonPrivate::macAddress(mode);

        break;

    }

    default:

        return QSystemNetworkInfoLinuxCommonPrivate::macAddress(mode);

        break;

    };

    return QString();

}

QNetworkInterface QSystemNetworkInfoPrivate::interfaceForMode(QSystemNetworkInfo::NetworkMode mode)

{

#if !defined(QT_NO_DBUS)

    switch(mode) {

    case QSystemNetworkInfo::CdmaMode:

    case QSystemNetworkInfo::GsmMode:

    case QSystemNetworkInfo::WcdmaMode:

    case QSystemNetworkInfo::WimaxMode:

        break;

    default:

        return QSystemNetworkInfoLinuxCommonPrivate::interfaceForMode(mode);

        break;

    };

#endif

    return QNetworkInterface();

}

void QSystemNetworkInfoPrivate::setupNetworkInfo()

{

    currentCellNetworkStatus = QSystemNetworkInfo::UndefinedStatus;

    currentBluetoothNetworkStatus = networkStatus(QSystemNetworkInfo::BluetoothMode);

    currentEthernetState = "down";

    currentEthernetSignalStrength = networkSignalStrength(QSystemNetworkInfo::EthernetMode);

    currentWlanSignalStrength = networkSignalStrength(QSystemNetworkInfo::WlanMode);

    currentLac = -1;

    currentCellId = -1;

    currentMCC = "";

    currentMNC = "";

    cellSignalStrength = 0;

    currentOperatorName = "";

    radioAccessTechnology = 0;

    iWlanStrengthCheckEnabled = 0;

    wlanSignalStrengthTimer = new QTimer(this);

    connect(wlanSignalStrengthTimer, SIGNAL(timeout()), this, SLOT(wlanSignalStrengthCheck()));

    QString devFile = "/sys/class/net/usb0/operstate";

    QFileInfo fi(devFile);

    if (fi.exists()) {

        QFile rx(fi.absoluteFilePath());

        if (rx.exists() && rx.open(QIODevice::ReadOnly | QIODevice::Text)) {

            QTextStream stream(&rx);

            stream >> currentEthernetState;

            rx.close();

        }

    }

#if !defined(QT_NO_DBUS)

    QDBusConnection systemDbusConnection = QDBusConnection::systemBus();

    QDBusInterface connectionInterface("com.nokia.phone.net",

                                       "/com/nokia/phone/net",

                                       "Phone.Net",

                                       systemDbusConnection);

    if (!connectionInterface.isValid()) {

        qWarning() << "setupNetworkInfo(): interface not valid";

        return;

    }

    QDBusMessage reply = connectionInterface.call(QLatin1String("get_registration_status"));

    if (reply.type() == QDBusMessage::ReplyMessage) {

        QList<QVariant> argList = reply.arguments();

        currentCellNetworkStatus = argList.at(STATUS_INDEX).toInt();

        currentLac = argList.at(LAC_INDEX).value<ushort>();

        currentCellId = argList.at(CELLID_INDEX).value<uint>();

        currentMCC.setNum(argList.at(MCC_INDEX).value<uint>());

        currentMNC.setNum(argList.at(MNC_INDEX).value<uint>());

    } else {

        qWarning() << reply.errorMessage();

    }

    if (!systemDbusConnection.connect("com.nokia.phone.net",

                       "/com/nokia/phone/net",

                       "Phone.Net",

                       "registration_status_change",

                       this, SLOT(registrationStatusChanged(uchar,ushort,uint,uint,uint,uchar,uchar)))) {

        qWarning() << "unable to connect to registration_status_change";

    }

    reply = connectionInterface.call(QLatin1String("get_signal_strength"));

    if (reply.type() == QDBusMessage::ReplyMessage) {

        QList<QVariant> argList = reply.arguments();

        cellSignalStrength = argList.at(0).toInt();

    } else {

        qWarning() << reply.errorMessage();

    }

    if (!systemDbusConnection.connect("com.nokia.phone.net",

                       "/com/nokia/phone/net",

                       "Phone.Net",

                       "signal_strength_change",

                       this, SLOT(cellNetworkSignalStrengthChanged(uchar,uchar)))) {

        qWarning() << "unable to connect to signal_strength_change";

    }

    uchar type = 0;

    QList<QVariant> argumentList;

    argumentList << qVariantFromValue(type) << qVariantFromValue(currentMNC.toUInt()) << qVariantFromValue(currentMCC.toUInt());

    reply = connectionInterface.callWithArgumentList(QDBus::Block, QLatin1String("get_operator_name"), argumentList);

    if (reply.type() == QDBusMessage::ReplyMessage) {

        QList<QVariant> argList = reply.arguments();

        currentOperatorName = argList.at(0).toString();