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

**

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

#include "qsysteminfo_maemo_p.h"

#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 :

        {

            QSystemDeviceInfoPrivate d;

            featureSupported = (d.simStatus() != QSystemDeviceInfo::SimNotAvailable);

        }

        break;

    case QSystemInfo::LocationFeature :

        {

#if defined(Q_WS_MAEMO_6)

            GConfItem satellitePositioning("/system/osso/location/settings/satellitePositioning");

            GConfItem networkPositioning("/system/osso/location/settings/networkPositioning");

            bool satellitePositioningAvailable = satellitePositioning.value(false).toBool();

            bool networkPositioningAvailable   = networkPositioning.value(false).toBool();

            featureSupported = (satellitePositioningAvailable || networkPositioningAvailable);

#else /* Maemo 5 */

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

            const QStringList locationKeys = locationValues.listEntries();

            if(locationKeys.count()) {

                featureSupported = true;

            }

#endif /* Maemo 5 */

        }

        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)

{

    csStatusMaemo6["Unknown"]    = -1;  // Current registration status is unknown.

    csStatusMaemo6["Home"]       = 0;   // Registered with the home network.

    csStatusMaemo6["Roaming"]    = 1;   // Registered with a roaming network.

    csStatusMaemo6["Offline"]    = 3;   // Not registered.

    csStatusMaemo6["Searching"]  = 4;   // Offline, but currently searching for network.

    csStatusMaemo6["NoSim"]      = 6;   // Offline because no SIM is present.

    csStatusMaemo6["PowerOff"]   = 8;   // Offline because the CS is powered off.

    csStatusMaemo6["PowerSave"]  = 9;   // Offline and in power save mode.

    csStatusMaemo6["NoCoverage"] = 10;  // Offline and in power save mode because of poor coverage.

    csStatusMaemo6["Rejected"]   = 11;  // Offline because SIM was rejected by the network.

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

{

    QSystemDeviceInfoPrivate d;

    QString imsi = d.imsi();

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

        return imsi.left(3);

    }

    return "";

}

QString QSystemNetworkInfoPrivate::homeMobileNetworkCode()

{

#if !defined(QT_NO_DBUS)

    #if defined(Q_WS_MAEMO_6)

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

                                       "/com/nokia/csd/sim",

                                       "com.nokia.csd.SIM.Identity",

                                       QDBusConnection::systemBus());

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

    if (reply.errorName().isEmpty()) {

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

        // The first attribute should be MCC and the 2nd one MNC

        if (args.size() == 2) {

            return args.at(1).toString();

        }

    }

    #else

    /* Maemo 5 */

    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

#endif

    return "";

}

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 = -1;

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

    #if defined(Q_WS_MAEMO_6)

        const QString service = "com.nokia.csd.CSNet";

        const QString servicePath = "/com/nokia/csd/csnet";

        /* CSD: network cell */

        QDBusInterface ifc(service, servicePath, "com.nokia.csd.CSNet.NetworkCell", systemDbusConnection);

        QVariant cellLac = ifc.property("CellLac");

        currentLac = cellLac.isValid() ? cellLac.value<int>() : -1;

        QVariant cellId = ifc.property("CellId");

        currentCellId =  cellId.isValid() ? cellId.value<int>() : -1;

        QVariant cellType = ifc.property("CellType");

        QString currentCellType = cellType.isValid() ? cellType.value<QString>() : "";

        if (currentCellType == "GSM")

            radioAccessTechnology = 1;

        else if (currentCellType == "WCDMA")

            radioAccessTechnology = 2;

        /* CSD: network operator */

        QDBusInterface ifc2(service, servicePath, "com.nokia.csd.CSNet.NetworkOperator", systemDbusConnection);

        QVariant mcc = ifc2.property("OperatorMCC");

        currentMCC = mcc.isValid() ? mcc.value<QString>() : "";

        QVariant mnc = ifc2.property("OperatorMNC");

        currentMNC = mnc.isValid() ? mnc.value<QString>() : "";

        QVariant operatorName = ifc2.property("OperatorName");

        currentOperatorName = operatorName.isValid() ? operatorName.value<QString>() : "";

        /* CSD: signal strength */