diff -r cfcbf08528c4 -r 2b40d63a9c3d qtmobility/src/systeminfo/qsysteminfo_maemo.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/qtmobility/src/systeminfo/qsysteminfo_maemo.cpp	Fri Apr 16 15:51:22 2010 +0300
@@ -0,0 +1,724 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 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.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");
+    QStringList locales = languagesItem.value().toStringList();
+
+    foreach(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");
+            QStringList locationKeys = locationValues.listEntries();
+
+            foreach (QString str, locationKeys) {
+                if (str.contains("sim_imsi"))
+                    featureSupported = true;
+                break;
+            }
+        }
+        break;
+    case QSystemInfo::LocationFeature :
+        {
+            GConfItem locationValues("/system/nokia/location");
+            QStringList locationKeys = locationValues.listEntries();
+            if(locationKeys.count()) {
+                featureSupported = true;
+            }
+        }
+        break;
+    case QSystemInfo::VideoOutFeature :
+        {
+            QString sysPath = "/sys/class/video4linux/";
+            QDir sysDir(sysPath);
+            QStringList filters;
+            filters << "*";
+            QStringList sysList = sysDir.entryList( filters ,QDir::Dirs, QDir::Name);
+            if(sysList.contains("video0")) {
+                featureSupported = true;
+            }
+        }
+        break;
+    case QSystemInfo::HapticsFeature:
+        {
+           // if(halIsAvailable) {
+                QHalInterface iface;
+                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)
+{
+}
+
+QSystemNetworkInfoPrivate::~QSystemNetworkInfoPrivate()
+{
+}
+
+
+QSystemNetworkInfo::NetworkStatus QSystemNetworkInfoPrivate::networkStatus(QSystemNetworkInfo::NetworkMode mode)
+{
+    qWarning() << __PRETTY_FUNCTION__ << mode;
+
+    switch(mode) {
+    case QSystemNetworkInfo::GsmMode:
+    case QSystemNetworkInfo::CdmaMode:
+    case QSystemNetworkInfo::WcdmaMode:
+        {
+            qWarning() << __FUNCTION__<< "GSM" << mode;
+//#if 0
+//#if !defined(QT_NO_DBUS)
+//            QDBusInterface connectionInterface("com.nokia.phone.net",
+//                                               "/com/nokia/phone/net",
+//                                               "com.nokia.SystemInfo",
+//                                                QDBusConnection::systemBus());
+//            if(!connectionInterface.isValid()) {
+//                qWarning() << "interfacenot valid";
+//            }
+//            QDBusReply< QByteArray > reply = connectionInterface.call("GetConfigValue", "/device/sw-release-ver");
+//            return reply.value();
+//#endif
+//#endif
+        }
+        break;
+    case QSystemNetworkInfo::EthernetMode:
+    case QSystemNetworkInfo::WlanMode:
+    case QSystemNetworkInfo::BluetoothMode:
+        {
+            return QSystemNetworkInfoLinuxCommonPrivate::networkStatus(mode);
+        }
+        break;
+    };
+    return QSystemNetworkInfo::UndefinedStatus;
+}
+
+int QSystemNetworkInfoPrivate::networkSignalStrength(QSystemNetworkInfo::NetworkMode mode)
+{
+    switch(mode) {
+    case QSystemNetworkInfo::GsmMode:
+    case QSystemNetworkInfo::CdmaMode:
+    case QSystemNetworkInfo::WcdmaMode:
+        break;
+    case QSystemNetworkInfo::EthernetMode:
+    case QSystemNetworkInfo::WlanMode:
+    case QSystemNetworkInfo::BluetoothMode:
+        return QSystemNetworkInfoLinuxCommonPrivate::networkSignalStrength(mode);
+        break;
+    };
+
+    return -1;
+}
+
+int QSystemNetworkInfoPrivate::cellId()
+{
+    return -1;
+}
+
+int QSystemNetworkInfoPrivate::locationAreaCode()
+{
+    return -1;
+}
+
+QString QSystemNetworkInfoPrivate::currentMobileCountryCode()
+{
+    return QString();
+}
+
+QString QSystemNetworkInfoPrivate::currentMobileNetworkCode()
+{
+    return QString();
+}
+
+QString QSystemNetworkInfoPrivate::homeMobileCountryCode()
+{
+    return QString();
+}
+
+QString QSystemNetworkInfoPrivate::homeMobileNetworkCode()
+{
+    return QString();
+}
+
+QString QSystemNetworkInfoPrivate::networkName(QSystemNetworkInfo::NetworkMode mode)
+{
+    QString netname = "";
+
+    switch(mode) {
+
+    case QSystemNetworkInfo::CdmaMode:
+    case QSystemNetworkInfo::GsmMode:
+    case QSystemNetworkInfo::WcdmaMode:
+    case QSystemNetworkInfo::WimaxMode:
+        break;
+        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;
+    default:
+        return QSystemNetworkInfoLinuxCommonPrivate::networkName(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();
+}
+
+QSystemDisplayInfoPrivate::QSystemDisplayInfoPrivate(QSystemDisplayInfoLinuxCommonPrivate *parent)
+        : QSystemDisplayInfoLinuxCommonPrivate(parent)
+{
+}
+
+QSystemDisplayInfoPrivate::~QSystemDisplayInfoPrivate()
+{
+}
+
+int QSystemDisplayInfoPrivate::displayBrightness(int screen)
+{
+    Q_UNUSED(screen);
+    GConfItem currentBrightness("/system/osso/dsm/display/display_brightness");
+    GConfItem maxBrightness("/system/osso/dsm/display/max_display_brightness_levels");
+    if(maxBrightness.value().toInt()) {
+        float retVal = 100 * (currentBrightness.value().toFloat() /
+                              maxBrightness.value().toFloat());
+        return retVal;
+    }
+
+    return -1;
+}
+
+QSystemStorageInfoPrivate::QSystemStorageInfoPrivate(QSystemStorageInfoLinuxCommonPrivate *parent)
+        : QSystemStorageInfoLinuxCommonPrivate(parent)
+{
+}
+
+QSystemStorageInfoPrivate::~QSystemStorageInfoPrivate()
+{
+}
+
+QSystemDeviceInfoPrivate::QSystemDeviceInfoPrivate(QSystemDeviceInfoLinuxCommonPrivate *parent)
+        : QSystemDeviceInfoLinuxCommonPrivate(parent)
+{
+    setConnection();
+    flightMode = false;
+ #if !defined(QT_NO_DBUS)
+    previousPowerState = QSystemDeviceInfo::UnknownPower;
+    setupBluetooth();
+    setupProfile();
+#endif
+}
+
+QSystemDeviceInfoPrivate::~QSystemDeviceInfoPrivate()
+{
+}
+
+#if !defined(QT_NO_DBUS)
+void QSystemDeviceInfoPrivate::halChanged(int,QVariantList map)
+{
+    for(int i=0; i < map.count(); i++) {
+//       qWarning() << __FUNCTION__ << map.at(i).toString();
+       if(map.at(i).toString() == "battery.charge_level.percentage") {
+            int level = batteryLevel();
+            emit batteryLevelChanged(level);
+            if(level < 4) {
+                emit batteryStatusChanged(QSystemDeviceInfo::BatteryCritical);
+            } else if(level < 11) {
+                emit batteryStatusChanged(QSystemDeviceInfo::BatteryVeryLow);
+            } else if(level < 41) {
+                emit batteryStatusChanged(QSystemDeviceInfo::BatteryLow);
+            } else if(level > 40) {
+                emit batteryStatusChanged(QSystemDeviceInfo::BatteryNormal);
+            }
+            else {
+                emit batteryStatusChanged(QSystemDeviceInfo::NoBatteryLevel);
+            }
+        }
+        if((map.at(i).toString() == "maemo.charger.connection_status")
+        || (map.at(i).toString() == "maemo.rechargeable.charging_status")) {
+            QSystemDeviceInfo::PowerState state = currentPowerState();
+            if (previousPowerState != state)
+                emit powerStateChanged(state);
+            previousPowerState = state;
+       }} //end map
+}
+#endif
+
+QSystemDeviceInfo::Profile QSystemDeviceInfoPrivate::currentProfile()
+{
+#if !defined(QT_NO_DBUS)
+    if (flightMode)
+        return QSystemDeviceInfo::OfflineProfile;
+
+    if (silentProfile )
+        return vibratingAlertEnabled ? QSystemDeviceInfo::VibProfile : QSystemDeviceInfo::SilentProfile;
+
+    if (ringingAlertVolume > 75)
+        return QSystemDeviceInfo::LoudProfile;
+
+    return QSystemDeviceInfo::NormalProfile;
+#endif
+
+    return QSystemDeviceInfo::UnknownProfile;
+}
+
+QString QSystemDeviceInfoPrivate::imei()
+{
+ #if !defined(QT_NO_DBUS)
+    QDBusInterface connectionInterface("com.nokia.phone.SIM",
+                                       "/com/nokia/csd/info",
+                                       "com.nokia.csd.Info",
+                                        QDBusConnection::systemBus());
+    if(!connectionInterface.isValid()) {
+        qWarning() << "interfacenot valid";
+    }
+
+    QDBusReply< QString > reply = connectionInterface.call("GetIMEINumber");
+    return reply.value();
+
+#endif
+        return "Not Available";
+}
+
+QString QSystemDeviceInfoPrivate::imsi()
+{
+    return GConfItem("/system/nokia/location/sim_imsi").value().toString();
+}
+
+QSystemDeviceInfo::SimStatus QSystemDeviceInfoPrivate::simStatus()
+{
+    GConfItem locationValues("/system/nokia/location");
+    QStringList locationKeys = locationValues.listEntries();
+    QStringList result;
+    int count = 0;
+    foreach (QString str, locationKeys) {
+        if (str.contains("sim_imsi"))
+            count++;
+    }
+
+    if(count == 1) {
+        return QSystemDeviceInfo::SingleSimAvailable;
+    } else if (count == 2) {
+        return QSystemDeviceInfo::DualSimAvailable;
+    }
+    return QSystemDeviceInfo::SimNotAvailable;
+}
+
+bool QSystemDeviceInfoPrivate::isDeviceLocked()
+{
+#if !defined(QT_NO_DBUS)
+    QDBusConnection systemDbusConnection = QDBusConnection::systemBus();
+
+    QDBusInterface mceConnectionInterface("com.nokia.mce",
+                                      "/com/nokia/mce/request",
+                                      "com.nokia.mce.request",
+                                      systemDbusConnection);
+    if (mceConnectionInterface.isValid()) {
+        QDBusReply<QString> tkLockModeReply = mceConnectionInterface.call("get_tklock_mode");
+        return tkLockModeReply.value() == "locked";
+    }
+
+    qWarning() << "mce interface not valid";
+#endif
+    return false;
+}
+
+QSystemDeviceInfo::PowerState QSystemDeviceInfoPrivate::currentPowerState()
+{
+#if !defined(QT_NO_DBUS)
+        QHalInterface iface;
+        QStringList list = iface.findDeviceByCapability("battery");
+        if(!list.isEmpty()) {
+            foreach(QString dev, list) {
+                QHalDeviceInterface ifaceDevice(dev);
+                if (iface.isValid()) {
+                    if (ifaceDevice.getPropertyString("maemo.charger.connection_status") == "connected") {
+                        if (ifaceDevice.getPropertyString("maemo.rechargeable.charging_status") == "full")
+                            return QSystemDeviceInfo::WallPower;
+                        return QSystemDeviceInfo::WallPowerChargingBattery;
+                    }
+                    return QSystemDeviceInfo::BatteryPower;
+                }
+            }
+        }
+#endif
+    return QSystemDeviceInfo::UnknownPower;
+}
+
+#if !defined(QT_NO_DBUS)
+ void QSystemDeviceInfoPrivate::setupBluetooth()
+ {
+     QDBusConnection dbusConnection = QDBusConnection::systemBus();
+     QDBusInterface *connectionInterface;
+     connectionInterface = new QDBusInterface("org.bluez",
+                                              "/",
+                                              "org.bluez.Manager",
+                                              dbusConnection);
+     if (connectionInterface->isValid()) {
+
+         QDBusReply<  QDBusObjectPath > reply = connectionInterface->call("DefaultAdapter");
+         if (reply.isValid()) {
+             QDBusInterface *adapterInterface;
+             adapterInterface = new QDBusInterface("org.bluez",
+                                                   reply.value().path(),
+                                                   "org.bluez.Adapter",
+                                                   dbusConnection);
+             if (adapterInterface->isValid()) {
+                 if (!dbusConnection.connect("org.bluez",
+                                           reply.value().path(),
+                                            "org.bluez.Adapter",
+                                            "PropertyChanged",
+                                            this,SLOT(bluezPropertyChanged(QString, QDBusVariant)))) {
+                     qWarning() << "bluez could not connect signal";
+                 }
+             }
+         }
+     }
+ }
+#endif
+
+#if !defined(QT_NO_DBUS)
+ void QSystemDeviceInfoPrivate::bluezPropertyChanged(const QString &str, QDBusVariant v)
+ {
+     qWarning() << str << v.variant().toBool();
+     emit bluetoothStateChanged(v.variant().toBool());
+ }
+#endif
+
+#if !defined(QT_NO_DBUS)
+
+void QSystemDeviceInfoPrivate::setupProfile()
+{
+    QDBusConnection systemDbusConnection = QDBusConnection::systemBus();
+
+    QDBusInterface mceConnectionInterface("com.nokia.mce",
+                                      "/com/nokia/mce/request",
+                                      "com.nokia.mce.request",
+                                      systemDbusConnection);
+    if (!mceConnectionInterface.isValid()) {
+        qWarning() << "mce interface not valid";
+        return;
+    } else {
+        QDBusReply<QString> deviceModeReply = mceConnectionInterface.call("get_device_mode");
+        flightMode = deviceModeReply.value() == "flight";
+    }
+
+    if (!systemDbusConnection.connect("com.nokia.mce",
+                           "/com/nokia/mce/signal",
+                           "com.nokia.mce.signal",
+                           "sig_device_mode_ind",
+                           this, SLOT(deviceModeChanged(QString)))) {
+        qWarning() << "unable to connect to sig_device_mode_ind";
+    }
+
+
+    QDBusInterface connectionInterface("com.nokia.profiled",
+                                      "/com/nokia/profiled",
+                                      "com.nokia.profiled",
+                                      QDBusConnection::sessionBus());
+    if(!connectionInterface.isValid()) {
+       qWarning() << "profiled interface not valid";
+       return;
+    }
+
+    QDBusReply<QString> profileNameReply = connectionInterface.call("get_profile");
+    if (profileNameReply.isValid())
+        profileName = profileNameReply.value();
+
+    QDBusReply<QString> ringingAlertTypeReply = connectionInterface.call("get_value", profileName, "ringing.alert.type");
+    if (ringingAlertTypeReply.isValid())
+        silentProfile = ringingAlertTypeReply.value() == "silent";
+
+    QDBusReply<QString> vibratingAlertEnabledReply = connectionInterface.call("get_value", profileName, "vibrating.alert.enabled");
+    if (vibratingAlertEnabledReply.isValid())
+        vibratingAlertEnabled = vibratingAlertEnabledReply.value() == "On";
+
+    QDBusReply<QString> ringingAlertVolumeReply = connectionInterface.call("get_value", profileName, "ringing.alert.volume");
+    if (ringingAlertVolumeReply.isValid())
+        ringingAlertVolume = ringingAlertVolumeReply.value().toInt();
+
+    qDBusRegisterMetaType<ProfileDataValue>();
+    qDBusRegisterMetaType<QList<ProfileDataValue> >();
+
+    QDBusConnection sessionDbusConnection = QDBusConnection::sessionBus();
+    if (!sessionDbusConnection.connect("com.nokia.profiled",
+                           "/com/nokia/profiled",
+                           "com.nokia.profiled",
+                           "profile_changed",
+                           this, SLOT(profileChanged(bool, bool, QString, QList<ProfileDataValue>)))) {
+        qWarning() << "unable to connect to profile_changed";
+    }
+
+}
+
+void QSystemDeviceInfoPrivate::deviceModeChanged(QString newMode)
+{
+    bool previousFlightMode = flightMode;
+    flightMode = newMode == "flight";
+    if (previousFlightMode != flightMode)
+        emit currentProfileChanged(currentProfile());
+}
+
+void QSystemDeviceInfoPrivate::profileChanged(bool changed, bool active, QString profile, QList<ProfileDataValue> values)
+{
+    QSystemDeviceInfo::Profile previousProfile = currentProfile();
+
+    profileName = profile;
+    foreach (ProfileDataValue value, values) {
+        if (value.key == "ringing.alert.type")
+            silentProfile = value.val == "silent";
+        else if (value.key == "vibrating.alert.enabled")
+            vibratingAlertEnabled = value.val == "On";
+        else if (value.key == "ringing.alert.volume")
+            ringingAlertVolume = value.val.toInt();
+    }
+
+    QSystemDeviceInfo::Profile newProfile = currentProfile();
+    if (previousProfile != newProfile)
+        emit currentProfileChanged(newProfile);
+}
+
+#endif
+
+//////////////
+///////
+QSystemScreenSaverPrivate::QSystemScreenSaverPrivate(QObject *parent)
+        : QSystemScreenSaverLinuxCommonPrivate(parent), m_screenSaverInhibited(false)
+
+{
+    ssTimer = new QTimer(this);
+}
+
+QSystemScreenSaverPrivate::~QSystemScreenSaverPrivate()
+{
+     if(ssTimer->isActive())
+         ssTimer->stop();
+
+     m_screenSaverInhibited = false;
+}
+
+bool QSystemScreenSaverPrivate::screenSaverInhibited()
+{
+    return m_screenSaverInhibited;
+}
+
+bool QSystemScreenSaverPrivate::setScreenSaverInhibit()
+{
+    if (m_screenSaverInhibited)
+        return true;
+
+     m_screenSaverInhibited = true;
+     display_blanking_pause();
+     connect(ssTimer, SIGNAL(timeout()), this, SLOT(display_blanking_pause()));
+     ssTimer->start(3000); //3 seconds interval
+     return true;
+}
+
+void QSystemScreenSaverPrivate::display_blanking_pause()
+{
+#if !defined(QT_NO_DBUS)
+    QDBusInterface connectionInterface("com.nokia.mce",
+                                       "/com/nokia/mce/request",
+                                       "com.nokia.mce.request",
+                                       QDBusConnection::systemBus());
+    if (!connectionInterface.isValid()) {
+        qWarning() << "interface not valid";
+        return;
+    }
+    connectionInterface.call("req_display_blanking_pause");
+#endif
+}
+
+bool QSystemScreenSaverPrivate::isScreenLockEnabled()
+{
+   return false;
+}
+
+bool QSystemScreenSaverPrivate::isScreenSaverActive()
+{
+    return false;
+}
+
+#include "moc_qsysteminfo_maemo_p.cpp"
+
+QTM_END_NAMESPACE