First steps towards QBatteryInfo Refactorization

-Remove the QML wrapper registration temporarily
-Change the public API to lock it to one index
-Change the Linux private API to lock it to one index
-Change the Mac private API to lock it to one index
-Change the Windows private API to lock it to one index
-Change the tests to use the new API
-Change the Simulator private API to lock it to one index

Change-Id: I5b3d36a3baad339623281d79014c411c59dd1b59
Reviewed-by: Andrew Wooster <awooster@blackberry.com>
Reviewed-by: Alex Blasche <alexander.blasche@digia.com>

17 files changed, 548 insertions, 125 deletions

diff --git a/src/imports/systeminfo/qsysteminfo.cpp b/src/imports/systeminfo/qsysteminfo.cpp
index 1e70ece3..c3fb9bbd 100644
--- a/src/imports/systeminfo/qsysteminfo.cpp
+++ b/src/imports/systeminfo/qsysteminfo.cpp
@@ -42,7 +42,6 @@
 #include <QtQml/qqmlextensionplugin.h>
 #include <QtQml/qqml.h>
 
-#include "qdeclarativebatteryinfo_p.h"
 #include "qdeclarativedeviceinfo_p.h"
 #include "qdeclarativenetworkinfo_p.h"
 #include <qscreensaver.h>
@@ -62,7 +61,6 @@ public:
 
         int major = 5;
         int minor = 0;
-        qmlRegisterType<QDeclarativeBatteryInfo>(uri, major, minor, "BatteryInfo");
         qmlRegisterType<QDeclarativeDeviceInfo>(uri, major, minor, "DeviceInfo");
         qmlRegisterType<QDeclarativeNetworkInfo>(uri, major, minor, "NetworkInfo");
         qmlRegisterType<QScreenSaver>(uri, major, minor, "ScreenSaver");
diff --git a/src/imports/systeminfo/systeminfo.pro b/src/imports/systeminfo/systeminfo.pro
index 4de880d5..a3ce2ae3 100644
--- a/src/imports/systeminfo/systeminfo.pro
+++ b/src/imports/systeminfo/systeminfo.pro
@@ -2,13 +2,11 @@ QT += qml systeminfo
 QT -= gui
 
 HEADERS += \
-    qdeclarativebatteryinfo_p.h \
     qdeclarativedeviceinfo_p.h \
     qdeclarativenetworkinfo_p.h \
     qdeclarativestorageinfo_p.h
 
 SOURCES += \
-    qdeclarativebatteryinfo.cpp \
     qdeclarativedeviceinfo.cpp \
     qdeclarativenetworkinfo.cpp \
     qdeclarativestorageinfo.cpp \
diff --git a/src/systeminfo/linux/qbatteryinfo_linux.cpp b/src/systeminfo/linux/qbatteryinfo_linux.cpp
index 66be9f77..c2579281 100644
--- a/src/systeminfo/linux/qbatteryinfo_linux.cpp
+++ b/src/systeminfo/linux/qbatteryinfo_linux.cpp
@@ -72,6 +72,29 @@ QBatteryInfoPrivate::QBatteryInfoPrivate(QBatteryInfo *parent)
     , watchVoltage(false)
     , watchBatteryStatus(false)
     , batteryCounts(-1)
+    , index(0)
+    , currentChargerType(QBatteryInfo::UnknownCharger)
+#if !defined(QT_NO_UDEV)
+    , uDevWrapper(0)
+#else
+    , timer(0)
+#endif // QT_NO_UDEV
+{
+}
+
+QBatteryInfoPrivate::QBatteryInfoPrivate(int batteryIndex, QBatteryInfo *parent)
+    : QObject(parent)
+    , q_ptr(parent)
+    , watchBatteryCount(false)
+    , watchChargerType(false)
+    , watchChargingState(false)
+    , watchCurrentFlow(false)
+    , watchRemainingCapacity(false)
+    , watchRemainingChargingTime(false)
+    , watchVoltage(false)
+    , watchBatteryStatus(false)
+    , batteryCounts(-1)
+    , index(batteryIndex)
     , currentChargerType(QBatteryInfo::UnknownCharger)
 #if !defined(QT_NO_UDEV)
     , uDevWrapper(0)
@@ -96,6 +119,19 @@ int QBatteryInfoPrivate::batteryCount()
     return batteryCounts;
 }
 
+int QBatteryInfoPrivate::batteryIndex() const
+{
+    return index;
+}
+
+void QBatteryInfoPrivate::setBatteryIndex(int batteryIndex)
+{
+    if (index != batteryIndex) {
+        index = batteryIndex;
+        emit batteryIndexChanged(index);
+    }
+}
+
 int QBatteryInfoPrivate::currentFlow(int battery)
 {
     if (!watchCurrentFlow)
@@ -104,6 +140,11 @@ int QBatteryInfoPrivate::currentFlow(int battery)
     return currentFlows.value(battery);
 }
 
+int QBatteryInfoPrivate::currentFlow()
+{
+    return currentFlow(index);
+}
+
 int QBatteryInfoPrivate::maximumCapacity(int battery)
 {
     if (maximumCapacities[battery] == 0) {
@@ -123,6 +164,11 @@ int QBatteryInfoPrivate::maximumCapacity(int battery)
     return maximumCapacities[battery];
 }
 
+int QBatteryInfoPrivate::maximumCapacity()
+{
+    return maximumCapacity(index);
+}
+
 int QBatteryInfoPrivate::remainingCapacity(int battery)
 {
     if (!watchRemainingCapacity)
@@ -131,6 +177,11 @@ int QBatteryInfoPrivate::remainingCapacity(int battery)
     return remainingCapacities.value(battery);
 }
 
+int QBatteryInfoPrivate::remainingCapacity()
+{
+    return remainingCapacity(index);
+}
+
 int QBatteryInfoPrivate::remainingChargingTime(int battery)
 {
     if (!watchRemainingChargingTime)
@@ -139,6 +190,11 @@ int QBatteryInfoPrivate::remainingChargingTime(int battery)
     return remainingChargingTimes.value(battery);
 }
 
+int QBatteryInfoPrivate::remainingChargingTime()
+{
+    return remainingChargingTime(index);
+}
+
 int QBatteryInfoPrivate::voltage(int battery)
 {
     if (!watchVoltage)
@@ -147,6 +203,11 @@ int QBatteryInfoPrivate::voltage(int battery)
     return voltages.value(battery);
 }
 
+int QBatteryInfoPrivate::voltage()
+{
+    return voltage(index);
+}
+
 QBatteryInfo::ChargerType QBatteryInfoPrivate::chargerType()
 {
     if (!watchChargerType)
@@ -163,6 +224,11 @@ QBatteryInfo::ChargingState QBatteryInfoPrivate::chargingState(int battery)
     return chargingStates.value(battery);
 }
 
+QBatteryInfo::ChargingState QBatteryInfoPrivate::chargingState()
+{
+    return chargingState(index);
+}
+
 QBatteryInfo::EnergyUnit QBatteryInfoPrivate::energyUnit()
 {
     return QBatteryInfo::UnitmAh;
@@ -176,6 +242,11 @@ QBatteryInfo::BatteryStatus QBatteryInfoPrivate::batteryStatus(int battery)
     return batteryStatuses.value(battery);
 }
 
+QBatteryInfo::BatteryStatus QBatteryInfoPrivate::batteryStatus()
+{
+    return batteryStatus(index);
+}
+
 void QBatteryInfoPrivate::connectNotify(const QMetaMethod &signal)
 {
     static const QMetaMethod batteryCountChangedSignal = QMetaMethod::fromSignal(&QBatteryInfoPrivate::batteryCountChanged);
@@ -331,7 +402,8 @@ void QBatteryInfoPrivate::onBatteryDataChanged(int battery, const QByteArray &at
             state = QBatteryInfo::Full;
         if (chargingStates.value(battery) != state) {
             chargingStates[battery] = state;
-            emit chargingStateChanged(battery, state);
+            if (battery == index)
+                emit chargingStateChanged(state);
         }
     }
 
@@ -340,7 +412,8 @@ void QBatteryInfoPrivate::onBatteryDataChanged(int battery, const QByteArray &at
             int remainingCapacity = value.toInt() / 1000;
             if (remainingCapacities.value(battery) != remainingCapacity) {
                 remainingCapacities[battery] = remainingCapacity;
-                emit remainingCapacityChanged(battery, remainingCapacity);
+                if (battery == index)
+                    emit remainingCapacityChanged(remainingCapacity);
             }
         }
     }
@@ -350,7 +423,8 @@ void QBatteryInfoPrivate::onBatteryDataChanged(int battery, const QByteArray &at
             int remainingChargingTime = value.toInt();
             if (remainingChargingTimes.value(battery) != remainingChargingTime) {
                 remainingChargingTimes[battery] = remainingChargingTime;
-                emit remainingChargingTimeChanged(battery, remainingChargingTime);
+                if (battery == index)
+                    emit remainingChargingTimeChanged(remainingChargingTime);
             }
         }
     }
@@ -360,7 +434,8 @@ void QBatteryInfoPrivate::onBatteryDataChanged(int battery, const QByteArray &at
             int voltage = value.toInt() / 1000;
             if (voltages.value(battery) != voltage) {
                 voltages[battery] = voltage;
-                emit voltageChanged(battery, voltage);
+                if (battery == index)
+                    emit voltageChanged(voltage);
             }
         }
     }
@@ -373,7 +448,8 @@ void QBatteryInfoPrivate::onBatteryDataChanged(int battery, const QByteArray &at
 
             if (currentFlows.value(battery) != currentFlow) {
                 currentFlows[battery] = currentFlow;
-                emit currentFlowChanged(battery, currentFlow);
+                if (battery == index)
+                    emit currentFlowChanged(currentFlow);
             }
         }
     }
@@ -390,7 +466,8 @@ void QBatteryInfoPrivate::onBatteryDataChanged(int battery, const QByteArray &at
             batteryStatus = QBatteryInfo::BatteryFull;
         if (batteryStatuses.value(battery) != batteryStatus) {
             batteryStatuses[battery] = batteryStatus;
-            emit batteryStatusChanged(battery, batteryStatus);
+            if (battery == index)
+                emit batteryStatusChanged(batteryStatus);
         }
     }
 }
@@ -433,7 +510,8 @@ void QBatteryInfoPrivate::onTimeout()
             value = getCurrentFlow(i);
             if (currentFlows.value(i) != value) {
                 currentFlows[i] = value;
-                emit currentFlowChanged(i, value);
+                if (i == index)
+                    emit currentFlowChanged(value);
             }
         }
 
@@ -441,7 +519,8 @@ void QBatteryInfoPrivate::onTimeout()
             value = getVoltage(i);
             if (voltages.value(i) != value) {
                 voltages[i] = value;
-                emit voltageChanged(i, value);
+                if (i == index)
+                    emit voltageChanged(value);
             }
         }
 
@@ -449,7 +528,8 @@ void QBatteryInfoPrivate::onTimeout()
             value = getRemainingCapacity(i);
             if (remainingCapacities.value(i) != value) {
                 remainingCapacities[i] = value;
-                emit remainingCapacityChanged(i, value);
+                if (i == index)
+                    emit remainingCapacityChanged(value);
             }
         }
 
@@ -457,7 +537,8 @@ void QBatteryInfoPrivate::onTimeout()
             value = getRemainingChargingTime(i);
             if (remainingChargingTimes.value(i) != value) {
                 remainingChargingTimes[i] = value;
-                emit remainingChargingTimeChanged(i, value);
+                if (i == index)
+                    emit remainingChargingTimeChanged(value);
             }
         }
 
@@ -473,7 +554,8 @@ void QBatteryInfoPrivate::onTimeout()
             QBatteryInfo::ChargingState state = getChargingState(i);
             if (chargingStates.value(i) != state) {
                 chargingStates[i] = state;
-                emit chargingStateChanged(i, state);
+                if (i == index)
+                    emit chargingStateChanged(state);
             }
         }
 
@@ -481,7 +563,8 @@ void QBatteryInfoPrivate::onTimeout()
             QBatteryInfo::BatteryStatus batteryStatus = getBatteryStatus(i);
             if (batteryStatuses.value(i) != batteryStatus) {
                 batteryStatuses[i] = batteryStatus;
-                emit batteryStatusChanged(i, batteryStatus);
+                if (i == index)
+                    emit batteryStatusChanged(batteryStatus);
             }
         }
     }
diff --git a/src/systeminfo/linux/qbatteryinfo_linux_p.h b/src/systeminfo/linux/qbatteryinfo_linux_p.h
index 1d5761a1..9db394a4 100644
--- a/src/systeminfo/linux/qbatteryinfo_linux_p.h
+++ b/src/systeminfo/linux/qbatteryinfo_linux_p.h
@@ -71,28 +71,40 @@ class QBatteryInfoPrivate : public QObject
 
 public:
     QBatteryInfoPrivate(QBatteryInfo *parent);
+    QBatteryInfoPrivate(int batteryIndex, QBatteryInfo *parent);
     ~QBatteryInfoPrivate();
 
     int batteryCount();
+    int batteryIndex() const;
     int currentFlow(int battery);
+    int currentFlow();
     int maximumCapacity(int battery);
+    int maximumCapacity();
     int remainingCapacity(int battery);
+    int remainingCapacity();
     int remainingChargingTime(int battery);
+    int remainingChargingTime();
     int voltage(int battery);
+    int voltage();
     QBatteryInfo::ChargerType chargerType();
     QBatteryInfo::ChargingState chargingState(int battery);
+    QBatteryInfo::ChargingState chargingState();
     QBatteryInfo::EnergyUnit energyUnit();
     QBatteryInfo::BatteryStatus batteryStatus(int battery);
+    QBatteryInfo::BatteryStatus batteryStatus();
+
+    void setBatteryIndex(int batteryIndex);
 
 Q_SIGNALS:
     void batteryCountChanged(int count);
+    int batteryIndexChanged(int batteryIndex);
     void chargerTypeChanged(QBatteryInfo::ChargerType type);
-    void chargingStateChanged(int battery, QBatteryInfo::ChargingState state);
-    void currentFlowChanged(int battery, int flow);
-    void remainingCapacityChanged(int battery, int capacity);
-    void remainingChargingTimeChanged(int battery, int seconds);
-    void voltageChanged(int battery, int voltage);
-    void batteryStatusChanged(int battery, QBatteryInfo::BatteryStatus);
+    void chargingStateChanged(QBatteryInfo::ChargingState state);
+    void currentFlowChanged(int flow);
+    void remainingCapacityChanged(int capacity);
+    void remainingChargingTimeChanged(int seconds);
+    void voltageChanged(int voltage);
+    void batteryStatusChanged(QBatteryInfo::BatteryStatus);
 
 protected:
     void connectNotify(const QMetaMethod &signal);
@@ -119,6 +131,7 @@ private:
     bool watchVoltage;
     bool watchBatteryStatus;
     int batteryCounts;
+    int index;
     QMap<int, int> currentFlows; // <battery ID, current value> pair
     QMap<int, int> voltages;
     QMap<int, int> remainingCapacities;
diff --git a/src/systeminfo/mac/qbatteryinfo_mac.mm b/src/systeminfo/mac/qbatteryinfo_mac.mm
index 8b050d9b..3a79d50e 100644
--- a/src/systeminfo/mac/qbatteryinfo_mac.mm
+++ b/src/systeminfo/mac/qbatteryinfo_mac.mm
@@ -81,6 +81,27 @@ QBatteryInfoPrivate::QBatteryInfoPrivate(QBatteryInfo *parent)
     , timeToFull(-1)
     , remainingEnergy(-1)
     , numberOfBatteries(0)
+    , index(0)
+{
+    initialize();
+}
+
+QBatteryInfoPrivate::QBatteryInfoPrivate(int batteryIndex, QBatteryInfo *parent)
+    : QObject(parent)
+    , q_ptr(parent)
+    , currentBatLevel(0)
+    , currentVoltage(-1)
+    , dischargeRate(0)
+    , capacity(-1)
+    , timeToFull(-1)
+    , remainingEnergy(-1)
+    , numberOfBatteries(0)
+    , index(batteryIndex)
+{
+    initialize();
+}
+
+void QBatteryInfoPrivate::initialize()
 {
     getBatteryInfo();
     NSAutoreleasePool *autoreleasepool = [[NSAutoreleasePool alloc] init];
@@ -104,6 +125,19 @@ int QBatteryInfoPrivate::batteryCount()
     return numberOfBatteries;
 }
 
+int QBatteryInfoPrivate::batteryIndex() const
+{
+    return index;
+}
+
+void QBatteryInfoPrivate::setBatteryIndex(int batteryIndex)
+{
+    if (index != batteryIndex) {
+        index = batteryIndex;
+        Q_EMIT batteryIndexChanged(index);
+    }
+}
+
 int QBatteryInfoPrivate::currentFlow(int battery)
 {
     if (battery < 0)
@@ -111,6 +145,11 @@ int QBatteryInfoPrivate::currentFlow(int battery)
     return currentFlows.value(battery);
 }
 
+int QBatteryInfoPrivate::currentFlow()
+{
+    return currentFlow(index);
+}
+
 int QBatteryInfoPrivate::maximumCapacity(int battery)
 {
     if (battery < 0)
@@ -118,6 +157,11 @@ int QBatteryInfoPrivate::maximumCapacity(int battery)
     return maximumCapacities.value(battery);
 }
 
+int QBatteryInfoPrivate::maximumCapacity()
+{
+    return maximumCapacity(index);
+}
+
 int QBatteryInfoPrivate::remainingCapacity(int battery)
 {
     if (battery < 0)
@@ -125,6 +169,11 @@ int QBatteryInfoPrivate::remainingCapacity(int battery)
     return remainingCapacities.value(battery);
 }
 
+int QBatteryInfoPrivate::remainingCapacity()
+{
+    return remainingCapacity(index);
+}
+
 int QBatteryInfoPrivate::remainingChargingTime(int battery)
 {
     if (battery < 0)
@@ -132,6 +181,11 @@ int QBatteryInfoPrivate::remainingChargingTime(int battery)
     return remainingChargingTimes.value(battery);
 }
 
+int QBatteryInfoPrivate::remainingChargingTime()
+{
+    return remainingChargingTime(index);
+}
+
 int QBatteryInfoPrivate::voltage(int battery)
 {
     if (battery < 0)
@@ -139,6 +193,11 @@ int QBatteryInfoPrivate::voltage(int battery)
     return voltages.value(battery);
 }
 
+int QBatteryInfoPrivate::voltage()
+{
+    return voltage(index);
+}
+
 QBatteryInfo::ChargerType QBatteryInfoPrivate::chargerType()
 {
     return curChargeType;
@@ -151,6 +210,11 @@ QBatteryInfo::ChargingState QBatteryInfoPrivate::chargingState(int battery)
     return chargingStates.value(battery);
 }
 
+QBatteryInfo::ChargingState QBatteryInfoPrivate::chargingState()
+{
+    return chargingState(index);
+}
+
 QBatteryInfo::EnergyUnit QBatteryInfoPrivate::energyUnit()
 {
     return QBatteryInfo::UnitmAh;
@@ -163,6 +227,11 @@ QBatteryInfo::BatteryStatus QBatteryInfoPrivate::batteryStatus(int battery)
     return batteryStatuses.value(battery);
 }
 
+QBatteryInfo::BatteryStatus QBatteryInfoPrivate::batteryStatus()
+{
+    return batteryStatus(index);
+}
+
 void QBatteryInfoPrivate::connectNotify(const QMetaMethod &signal)
 {
    // static const QMetaMethod batteryCountChangedSignal = QMetaMethod::fromSignal(&QBatteryInfoPrivate::batteryCountChanged);
@@ -248,7 +317,8 @@ QBatteryInfo::ChargingState QBatteryInfoPrivate::currentChargingState()
 
         if ( chargingStates.value(i) != state) {
             chargingStates[i] = state;
-            Q_EMIT chargingStateChanged(i,state);
+            if (i == index)
+                Q_EMIT chargingStateChanged(state);
         }
     }
     CFRelease(powerSourcesInfo);
@@ -316,35 +386,40 @@ void QBatteryInfoPrivate::getBatteryInfo()
         }
         if (batteryStatuses.value(i) != stat) {
             batteryStatuses[i] = stat;
-            Q_EMIT batteryStatusChanged(i,stat);
+            if (i == index)
+                Q_EMIT batteryStatusChanged(stat);
         }
 
         cVoltage = [[(NSDictionary*)batDoctionary objectForKey:@kIOPSVoltageKey] intValue];
 
         if (cVoltage != voltages.value(i) && cVoltage != 0) {
             voltages[i] = cVoltage;
-            Q_EMIT(voltageChanged(i, cVoltage));
+            if (i == index)
+                Q_EMIT(voltageChanged( cVoltage));
         }
 
         cEnergy = [[(NSDictionary*)batDoctionary objectForKey:@kIOPSCurrentKey] doubleValue];
 
         if (cEnergy != currentFlows.value(i) && cEnergy != 0) {
             currentFlows[i] = cEnergy;
-            Q_EMIT currentFlowChanged(i,cEnergy);
+            if (i == index)
+                Q_EMIT currentFlowChanged(cEnergy);
         }
 
         cTime = [[(NSDictionary*)batDoctionary objectForKey:@kIOPSTimeToFullChargeKey] intValue];
 
         if (cTime != remainingChargingTimes.value(i)) {
             remainingChargingTimes[i] = cTime * 60;
-            Q_EMIT remainingChargingTimeChanged(i,remainingChargingTimes[i]);
+            if (i == index)
+                Q_EMIT remainingChargingTimeChanged(remainingChargingTimes[i]);
         }
 
         rEnergy = [[(NSDictionary*)batDoctionary objectForKey:@"CurrentCapacity"] intValue];
 
         if (rEnergy != remainingCapacities.value(i) && rEnergy != 0) {
             remainingCapacities[i] = rEnergy;
-            Q_EMIT remainingCapacityChanged(i,remainingCapacities[i]);
+            if (i == index)
+                Q_EMIT remainingCapacityChanged(remainingCapacities[i]);
         }
         int max = rEnergy / ((qreal)(curCapacityPercent) / 100);
         maximumCapacities[i] = max;
diff --git a/src/systeminfo/mac/qbatteryinfo_mac_p.h b/src/systeminfo/mac/qbatteryinfo_mac_p.h
index cdc783ea..ccab2a19 100644
--- a/src/systeminfo/mac/qbatteryinfo_mac_p.h
+++ b/src/systeminfo/mac/qbatteryinfo_mac_p.h
@@ -65,31 +65,43 @@ class QBatteryInfoPrivate : public QObject
 
 public:
     QBatteryInfoPrivate(QBatteryInfo *parent);
+    QBatteryInfoPrivate(int batteryIndex, QBatteryInfo *parent);
     ~QBatteryInfoPrivate();
 
     int batteryCount();
+    int batteryIndex() const;
     int currentFlow(int battery);
+    int currentFlow();
     int maximumCapacity(int battery);
+    int maximumCapacity();
     int remainingCapacity(int battery);
+    int remainingCapacity();
     int remainingChargingTime(int battery);
+    int remainingChargingTime();
     int voltage(int battery);
+    int voltage();
 
     QBatteryInfo::ChargerType chargerType();
     QBatteryInfo::ChargingState chargingState(int battery);
+    QBatteryInfo::ChargingState chargingState();
     QBatteryInfo::EnergyUnit energyUnit();
     QBatteryInfo::BatteryStatus batteryStatus(int battery);
+    QBatteryInfo::BatteryStatus batteryStatus();
     void getBatteryInfo();
     QBatteryInfo::ChargingState currentChargingState();
 
+    void setBatteryIndex(int batteryIndex);
+
 Q_SIGNALS:
     void batteryCountChanged(int count);
+    void batteryIndexChanged(int batteryIndex);
     void chargerTypeChanged(QBatteryInfo::ChargerType type);
-    void chargingStateChanged(int battery, QBatteryInfo::ChargingState state);
-    void currentFlowChanged(int battery, int flow);
-    void remainingCapacityChanged(int battery, int capacity);
-    void remainingChargingTimeChanged(int battery, int seconds);
-    void voltageChanged(int battery, int voltage);
-    void batteryStatusChanged(int battery, QBatteryInfo::BatteryStatus);
+    void chargingStateChanged(QBatteryInfo::ChargingState state);
+    void currentFlowChanged(int flow);
+    void remainingCapacityChanged(int capacity);
+    void remainingChargingTimeChanged(int seconds);
+    void voltageChanged(int voltage);
+    void batteryStatusChanged(QBatteryInfo::BatteryStatus);
 
 protected:
     void connectNotify(const QMetaMethod &signal);
@@ -117,6 +129,7 @@ private:
     int timeToFull;
     int remainingEnergy;
     int numberOfBatteries;
+    int index;
 
 //    int batteryCounts;
     QMap<int, int> currentFlows; // <battery ID, current value> pair
@@ -128,6 +141,7 @@ private:
     QBatteryInfo::ChargerType currentChargerType;
     QMap<int, QBatteryInfo::BatteryStatus> batteryStatuses;
 
+    void initialize();
 };
 
 QT_END_NAMESPACE
diff --git a/src/systeminfo/qbatteryinfo.cpp b/src/systeminfo/qbatteryinfo.cpp
index bfa6ca28..deae3117 100644
--- a/src/systeminfo/qbatteryinfo.cpp
+++ b/src/systeminfo/qbatteryinfo.cpp
@@ -197,6 +197,20 @@ QBatteryInfo::QBatteryInfo(QObject *parent)
 }
 
 /*!
+    Constructs a QBatteryInfo object with the given \a index and \a parent.
+*/
+QBatteryInfo::QBatteryInfo(int batteryIndex, QObject *parent)
+    : QObject(parent)
+#if !defined(QT_SIMULATOR)
+    , d_ptr(new QBatteryInfoPrivate(batteryIndex, this))
+#else
+    , d_ptr(new QBatteryInfoSimulator(this))
+#endif // QT_SIMULATOR
+
+{
+}
+
+/*!
     Destroys the object
 */
 QBatteryInfo::~QBatteryInfo()
@@ -215,22 +229,42 @@ int QBatteryInfo::batteryCount() const
 }
 
 /*!
+ * \brief Get the current battery index
+ * \return The current battery index
+ */
+int QBatteryInfo::batteryIndex() const
+{
+    return d_ptr->batteryIndex();
+}
+
+/*!
+ * \brief Set the battery index of this instance
+ * \param batteryIndex The new battery index
+ *
+ * Set the battery index of this instance to batteryIndex
+ */
+void QBatteryInfo::setBatteryIndex(int batteryIndex)
+{
+    d_ptr->setBatteryIndex(batteryIndex);
+}
+
+/*!
     Returns the current flow of the given \a battery, measured in milliamperes (mA). A positive
     returned value means discharging, and a negative value means charging. In case of error, or
     the information if not available, 0 is returned.
 */
-int QBatteryInfo::currentFlow(int battery) const
+int QBatteryInfo::currentFlow() const
 {
-    return d_ptr->currentFlow(battery);
+    return d_ptr->currentFlow();
 }
 
 /*!
     Returns the maximum capacity of the given \a battery, measured in QBatteryInfo::EnergyUnit.
     If the battery is not found, or the information is not available, -1 is returned.
 */
-int QBatteryInfo::maximumCapacity(int battery) const
+int QBatteryInfo::maximumCapacity() const
 {
-    return d_ptr->maximumCapacity(battery);
+    return d_ptr->maximumCapacity();
 }
 
 /*!
@@ -240,9 +274,9 @@ int QBatteryInfo::maximumCapacity(int battery) const
     To calculate capacity in percentage,
     (remainingCapacity(0) / maximumCapacity(0)) * 100
 */
-int QBatteryInfo::remainingCapacity(int battery) const
+int QBatteryInfo::remainingCapacity() const
 {
-    return d_ptr->remainingCapacity(battery);
+    return d_ptr->remainingCapacity();
 }
 
 /*!
@@ -250,18 +284,18 @@ int QBatteryInfo::remainingCapacity(int battery) const
     is full or not charging, 0 is returned. If the battery is not found or the information is not
     available, -1 is returned.
 */
-int QBatteryInfo::remainingChargingTime(int battery) const
+int QBatteryInfo::remainingChargingTime() const
 {
-    return d_ptr->remainingChargingTime(battery);
+    return d_ptr->remainingChargingTime();
 }
 
 /*!
     Returns the voltage of the given \a battery, measured in millivolts (mV). If the battery is not
     found, or the information is not available, -1 is returned.
 */
-int QBatteryInfo::voltage(int battery) const
+int QBatteryInfo::voltage() const
 {
-    return d_ptr->voltage(battery);
+    return d_ptr->voltage();
 }
 
 /*!
@@ -278,9 +312,9 @@ QBatteryInfo::ChargerType QBatteryInfo::chargerType() const
 /*!
     Returns the charging state of the given \a battery.
 */
-QBatteryInfo::ChargingState QBatteryInfo::chargingState(int battery) const
+QBatteryInfo::ChargingState QBatteryInfo::chargingState() const
 {
-    return d_ptr->chargingState(battery);
+    return d_ptr->chargingState();
 }
 
 /*!
@@ -297,9 +331,9 @@ QBatteryInfo::EnergyUnit QBatteryInfo::energyUnit() const
 /*!
     Returns the battery status of the given \a battery.
 */
-QBatteryInfo::BatteryStatus QBatteryInfo::batteryStatus(int battery) const
+QBatteryInfo::BatteryStatus QBatteryInfo::batteryStatus() const
 {
-    return d_ptr->batteryStatus(battery);
+    return d_ptr->batteryStatus();
 }
 
 /*!
diff --git a/src/systeminfo/qbatteryinfo.h b/src/systeminfo/qbatteryinfo.h
index be32196c..604240b0 100644
--- a/src/systeminfo/qbatteryinfo.h
+++ b/src/systeminfo/qbatteryinfo.h
@@ -63,8 +63,16 @@ class Q_SYSTEMINFO_EXPORT QBatteryInfo : public QObject
     Q_ENUMS(BatteryStatus)
 
     Q_PROPERTY(int batteryCount READ batteryCount NOTIFY batteryCountChanged)
+    Q_PROPERTY(int batteryIndex READ batteryIndex WRITE setBatteryIndex NOTIFY batteryIndexChanged)
+    Q_PROPERTY(int currentFlow READ currentFlow NOTIFY currentFlowChanged)
+    Q_PROPERTY(int maximumCapacity READ maximumCapacity)
+    Q_PROPERTY(int remainingCapacity READ remainingCapacity NOTIFY remainingCapacityChanged)
+    Q_PROPERTY(int remainingChargingTime READ remainingChargingTime NOTIFY remainingChargingTimeChanged)
+    Q_PROPERTY(int voltage READ voltage NOTIFY voltageChanged)
+    Q_PROPERTY(int chargingState READ chargingState NOTIFY chargingStateChanged)
     Q_PROPERTY(ChargerType chargerType READ chargerType NOTIFY chargerTypeChanged)
     Q_PROPERTY(EnergyUnit energyUnit READ energyUnit)
+    Q_PROPERTY(int batteryStatus READ batteryStatus NOTIFY batteryStatusChanged)
 
 public:
     enum ChargerType {
@@ -97,28 +105,33 @@ public:
     };
 
     QBatteryInfo(QObject *parent = 0);
+    QBatteryInfo(int batteryIndex, QObject *parent = 0);
     virtual ~QBatteryInfo();
 
     int batteryCount() const;
-    int currentFlow(int battery) const;
-    int maximumCapacity(int battery) const;
-    int remainingCapacity(int battery) const;
-    int remainingChargingTime(int battery) const;
-    int voltage(int battery) const;
-    QBatteryInfo::ChargingState chargingState(int battery) const;
+    int batteryIndex() const;
+    int currentFlow() const;
+    int maximumCapacity() const;
+    int remainingCapacity() const;
+    int remainingChargingTime() const;
+    int voltage() const;
+    QBatteryInfo::ChargingState chargingState() const;
     QBatteryInfo::ChargerType chargerType() const;
     QBatteryInfo::EnergyUnit energyUnit() const;
-    QBatteryInfo::BatteryStatus batteryStatus(int battery) const;
+    QBatteryInfo::BatteryStatus batteryStatus() const;
+
+    void setBatteryIndex(int batteryIndex);
 
 Q_SIGNALS:
+    void batteryIndexChanged(int batteryIndex);
     void batteryCountChanged(int count);
     void chargerTypeChanged(QBatteryInfo::ChargerType type);
-    void chargingStateChanged(int battery, QBatteryInfo::ChargingState state);
-    void currentFlowChanged(int battery, int flow);
-    void remainingCapacityChanged(int battery, int capacity);
-    void remainingChargingTimeChanged(int battery, int seconds);
-    void voltageChanged(int battery, int voltage);
-    void batteryStatusChanged(int battery, QBatteryInfo::BatteryStatus);
+    void chargingStateChanged(QBatteryInfo::ChargingState state);
+    void currentFlowChanged(int flow);
+    void remainingCapacityChanged(int capacity);
+    void remainingChargingTimeChanged(int seconds);
+    void voltageChanged(int voltage);
+    void batteryStatusChanged(QBatteryInfo::BatteryStatus);
 
 protected:
     void connectNotify(const QMetaMethod &signal);
diff --git a/src/systeminfo/simulator/qsysteminfo_simulator.cpp b/src/systeminfo/simulator/qsysteminfo_simulator.cpp
index 05f1b0a8..7b700123 100644
--- a/src/systeminfo/simulator/qsysteminfo_simulator.cpp
+++ b/src/systeminfo/simulator/qsysteminfo_simulator.cpp
@@ -57,6 +57,16 @@ QBatteryInfoSimulator::QBatteryInfoSimulator(QBatteryInfo *parent)
     : QObject(parent)
     , q_ptr(parent)
     , batteryInfoSimulatorBackend(QBatteryInfoSimulatorBackend::getSimulatorBackend())
+    , index(0)
+{
+    SystemInfoConnection::ensureSimulatorConnection();
+}
+
+QBatteryInfoSimulator::QBatteryInfoSimulator(int batteryIndex, QBatteryInfo *parent)
+    : QObject(parent)
+    , q_ptr(parent)
+    , batteryInfoSimulatorBackend(QBatteryInfoSimulatorBackend::getSimulatorBackend())
+    , index(batteryIndex)
 {
     SystemInfoConnection::ensureSimulatorConnection();
 }
@@ -73,6 +83,20 @@ int QBatteryInfoSimulator::batteryCount()
     return -1;
 }
 
+int QBatteryInfoSimulator::batteryIndex() const
+{
+    if (batteryInfoSimulatorBackend)
+        return batteryInfoSimulatorBackend->getBatteryIndex();
+
+    return -1;
+}
+
+void QBatteryInfoSimulator::setBatteryIndex(int batteryIndex)
+{
+    if (batteryInfoSimulatorBackend)
+        batteryInfoSimulatorBackend->setBatteryIndex(batteryIndex);
+}
+
 int QBatteryInfoSimulator::currentFlow(int battery)
 {
     if (batteryInfoSimulatorBackend)
@@ -81,6 +105,11 @@ int QBatteryInfoSimulator::currentFlow(int battery)
     return 0;
 }
 
+int QBatteryInfoSimulator::currentFlow()
+{
+    return currentFlow(batteryInfoSimulatorBackend->getBatteryIndex());
+}
+
 int QBatteryInfoSimulator::maximumCapacity(int battery)
 {
     if (batteryInfoSimulatorBackend)
@@ -89,6 +118,11 @@ int QBatteryInfoSimulator::maximumCapacity(int battery)
     return -1;
 }
 
+int QBatteryInfoSimulator::maximumCapacity()
+{
+    return maximumCapacity(batteryInfoSimulatorBackend->getBatteryIndex());
+}
+
 int QBatteryInfoSimulator::remainingCapacity(int battery)
 {
     if (batteryInfoSimulatorBackend)
@@ -97,6 +131,11 @@ int QBatteryInfoSimulator::remainingCapacity(int battery)
     return -1;
 }
 
+int QBatteryInfoSimulator::remainingCapacity()
+{
+    return remainingCapacity(batteryInfoSimulatorBackend->getBatteryIndex());
+}
+
 int QBatteryInfoSimulator::remainingChargingTime(int battery)
 {
     if (batteryInfoSimulatorBackend)
@@ -105,6 +144,11 @@ int QBatteryInfoSimulator::remainingChargingTime(int battery)
     return -1;
 }
 
+int QBatteryInfoSimulator::remainingChargingTime(int battery)
+{
+    return remainingChargingTime(batteryInfoSimulatorBackend->getBatteryIndex());
+}
+
 int QBatteryInfoSimulator::voltage(int battery)
 {
     if (batteryInfoSimulatorBackend)
@@ -113,6 +157,11 @@ int QBatteryInfoSimulator::voltage(int battery)
     return -1;
 }
 
+int QBatteryInfoSimulator::voltage()
+{
+    return voltage(batteryInfoSimulatorBackend->getBatteryIndex());
+}
+
 QBatteryInfo::ChargerType QBatteryInfoSimulator::chargerType()
 {
     if (batteryInfoSimulatorBackend)
@@ -129,6 +178,11 @@ QBatteryInfo::ChargingState QBatteryInfoSimulator::chargingState(int battery)
     return QBatteryInfo::UnknownChargingState;
 }
 
+QBatteryInfo::ChargingState QBatteryInfoSimulator::chargingState()
+{
+    return chargingState(batteryInfoSimulatorBackend->getBatteryIndex());
+}
+
 QBatteryInfo::EnergyUnit QBatteryInfoSimulator::energyUnit()
 {
     if (batteryInfoSimulatorBackend)
@@ -145,6 +199,11 @@ QBatteryInfo::BatteryStatus QBatteryInfoSimulator::batteryStatus(int battery)
     return QBatteryInfo::BatteryStatusUnknown;
 }
 
+QBatteryInfo::BatteryStatus QBatteryInfoSimulator::batteryStatus()
+{
+    return batteryStatus(batteryInfoSimulatorBackend->getBatteryIndex());
+}
+
 extern QMetaMethod proxyToSourceSignal(const QMetaMethod &, QObject *);
 
 void QBatteryInfoSimulator::connectNotify(const QMetaMethod &signal)
diff --git a/src/systeminfo/simulator/qsysteminfo_simulator_p.h b/src/systeminfo/simulator/qsysteminfo_simulator_p.h
index febcded7..121daa7e 100644
--- a/src/systeminfo/simulator/qsysteminfo_simulator_p.h
+++ b/src/systeminfo/simulator/qsysteminfo_simulator_p.h
@@ -74,28 +74,40 @@ class QBatteryInfoSimulator : public QObject
 
 public:
     QBatteryInfoSimulator(QBatteryInfo *parent);
+    QBatteryInfoSimulator(int batteryIndex, QBatteryInfo *parent);
     ~QBatteryInfoSimulator();
 
     int batteryCount();
+    int batteryIndex() const;
     int currentFlow(int battery);
+    int currentFlow();
     int maximumCapacity(int battery);
+    int maximumCapacity();
     int remainingCapacity(int battery);
+    int remainingCapacity();
     int remainingChargingTime(int battery);
+    int remainingChargingTime();
     int voltage(int battery);
+    int voltage();
     QBatteryInfo::ChargerType chargerType();
     QBatteryInfo::ChargingState chargingState(int battery);
+    QBatteryInfo::ChargingState chargingState();
     QBatteryInfo::EnergyUnit energyUnit();
     QBatteryInfo::BatteryStatus batteryStatus(int battery);
+    QBatteryInfo::BatteryStatus batteryStatus();
+
+    void setBatteryIndex(int batteryIndex);
 
 Q_SIGNALS:
     void batteryCountChanged(int count);
+    void batteryIndexChanged(int batteryIndex);
     void chargerTypeChanged(QBatteryInfo::ChargerType type);
-    void chargingStateChanged(int battery, QBatteryInfo::ChargingState state);
-    void currentFlowChanged(int battery, int flow);
-    void remainingCapacityChanged(int battery, int capacity);
-    void remainingChargingTimeChanged(int battery, int seconds);
-    void voltageChanged(int battery, int voltage);
-    void batteryStatusChanged(int battery, QBatteryInfo::BatteryStatus);
+    void chargingStateChanged(QBatteryInfo::ChargingState state);
+    void currentFlowChanged(int flow);
+    void remainingCapacityChanged(int capacity);
+    void remainingChargingTimeChanged(int seconds);
+    void voltageChanged(int voltage);
+    void batteryStatusChanged(QBatteryInfo::BatteryStatus);
 
 protected:
     void connectNotify(const QMetaMethod &signal);
diff --git a/src/systeminfo/simulator/qsysteminfobackend_simulator.cpp b/src/systeminfo/simulator/qsysteminfobackend_simulator.cpp
index 2cf89a16..5fb43259 100644
--- a/src/systeminfo/simulator/qsysteminfobackend_simulator.cpp
+++ b/src/systeminfo/simulator/qsysteminfobackend_simulator.cpp
@@ -55,6 +55,7 @@ QNetworkInfoSimulatorBackend *QNetworkInfoSimulatorBackend::globalSimulatorBacke
 QBatteryInfoSimulatorBackend::QBatteryInfoSimulatorBackend(QObject *parent)
     : QObject(parent)
 {
+    data.index = 0;
     data.currentFlow = 0;
     data.maximumCapacity = -1;
     data.remainingCapacity = -1;
@@ -88,6 +89,11 @@ int QBatteryInfoSimulatorBackend::getBatteryCount()
     return 1;
 }
 
+int QBatteryInfoSimulatorBackend::getBatteryIndex() const
+{
+    return data.index;
+}
+
 int QBatteryInfoSimulatorBackend::getCurrentFlow(int battery)
 {
     if (battery == 0)
@@ -149,11 +155,19 @@ QBatteryInfo::BatteryStatus QBatteryInfoSimulatorBackend::getBatteryStatus(int b
     return QBatteryInfo::BatteryStatusUnknown;
 }
 
+void QBatteryInfoSimulatorBackend::setBatteryIndex(int batteryIndex)
+{
+    if (data.index != batteryIndex) {
+        data.index = batteryIndex;
+        emit batteryIndexChanged(data.index);
+    }
+}
+
 void QBatteryInfoSimulatorBackend::setCurrentFlow(int flow)
 {
     if (data.currentFlow != flow) {
         data.currentFlow = flow;
-        emit currentFlowChanged(0, flow);
+        emit currentFlowChanged(flow);
     }
 }
 
@@ -167,7 +181,7 @@ void QBatteryInfoSimulatorBackend::setRemainingCapacity(int capacity)
 {
     if (data.remainingCapacity != capacity) {
         data.remainingCapacity = capacity;
-        emit remainingCapacityChanged(0, capacity);
+        emit remainingCapacityChanged(capacity);
     }
 }
 
@@ -175,7 +189,7 @@ void QBatteryInfoSimulatorBackend::setVoltage(int vol)
 {
     if (data.voltage != vol) {
         data.voltage = vol;
-        emit voltageChanged(0, vol);
+        emit voltageChanged(vol);
     }
 }
 
@@ -183,7 +197,7 @@ void QBatteryInfoSimulatorBackend::setRemainingChargingTime(int time)
 {
     if (data.remainingChargingTime != time) {
         data.remainingChargingTime = time;
-        emit remainingChargingTimeChanged(0, time);
+        emit remainingChargingTimeChanged(time);
     }
 }
 
@@ -191,7 +205,7 @@ void QBatteryInfoSimulatorBackend::setChargingState(QBatteryInfo::ChargingState
 {
     if (data.chargingState != state) {
         data.chargingState = state;
-        emit chargingStateChanged(0, state);
+        emit chargingStateChanged(state);
     }
 }
 
@@ -213,7 +227,7 @@ void QBatteryInfoSimulatorBackend::setBatteryStatus(QBatteryInfo::BatteryStatus
 {
     if (data.batteryStatus != status) {
         data.batteryStatus = status;
-        emit batteryStatusChanged(0, status);
+        emit batteryStatusChanged(status);
     }
 }
 
diff --git a/src/systeminfo/simulator/qsysteminfobackend_simulator_p.h b/src/systeminfo/simulator/qsysteminfobackend_simulator_p.h
index 93463b9c..d1d838f1 100644
--- a/src/systeminfo/simulator/qsysteminfobackend_simulator_p.h
+++ b/src/systeminfo/simulator/qsysteminfobackend_simulator_p.h
@@ -73,6 +73,7 @@ public:
     static QBatteryInfoSimulatorBackend *getSimulatorBackend();
 
     int getBatteryCount();
+    int getBatteryIndex() const;
     int getCurrentFlow(int battery);
     int getMaximumCapacity(int battery);
     int getRemainingCapacity(int battery);
@@ -83,6 +84,7 @@ public:
     QBatteryInfo::EnergyUnit getEnergyUnit();
     QBatteryInfo::BatteryStatus getBatteryStatus(int battery);
 
+    void setBatteryIndex(int batteryIndex);
     void setCurrentFlow(int flow);
     void setMaximumCapacity(int capacity);
     void setRemainingCapacity(int capacity);
@@ -95,13 +97,14 @@ public:
 
 Q_SIGNALS:
     void batteryCountChanged(int count);
-    void currentFlowChanged(int battery, int flow);
-    void remainingCapacityChanged(int battery, int capacity);
-    void remainingChargingTimeChanged(int battery, int seconds);
-    void voltageChanged(int battery, int voltage);
-    void chargingStateChanged(int battery, QBatteryInfo::ChargingState state);
+    void batteryIndexChanged(int batteryIndex);
+    void currentFlowChanged(int flow);
+    void remainingCapacityChanged(int capacity);
+    void remainingChargingTimeChanged(int seconds);
+    void voltageChanged(int voltage);
+    void chargingStateChanged(QBatteryInfo::ChargingState state);
     void chargerTypeChanged(QBatteryInfo::ChargerType type);
-    void batteryStatusChanged(int battery, QBatteryInfo::BatteryStatus status);
+    void batteryStatusChanged(QBatteryInfo::BatteryStatus status);
 
 private:
     static QBatteryInfoSimulatorBackend *globalSimulatorBackend;
diff --git a/src/systeminfo/simulator/qsysteminfodata_simulator_p.h b/src/systeminfo/simulator/qsysteminfodata_simulator_p.h
index 15e26595..fa3aef69 100644
--- a/src/systeminfo/simulator/qsysteminfodata_simulator_p.h
+++ b/src/systeminfo/simulator/qsysteminfodata_simulator_p.h
@@ -115,6 +115,7 @@ struct QNetworkInfoData
 
 struct QBatteryInfoData
 {
+    int index;
     int currentFlow;
     int maximumCapacity;
     int remainingCapacity;
diff --git a/src/systeminfo/windows/qbatteryinfo_win.cpp b/src/systeminfo/windows/qbatteryinfo_win.cpp
index 1740518c..d7b73d2a 100644
--- a/src/systeminfo/windows/qbatteryinfo_win.cpp
+++ b/src/systeminfo/windows/qbatteryinfo_win.cpp
@@ -65,6 +65,22 @@ QBatteryInfoPrivate::QBatteryInfoPrivate(QBatteryInfo *parent)
     , q_ptr(parent)
     , timeToFull(0)
     , numberOfBatteries(0)
+    , index(0)
+{
+    initialize();
+}
+
+QBatteryInfoPrivate::QBatteryInfoPrivate(int batteryIndex, QBatteryInfo *parent)
+    : QObject(parent)
+    , q_ptr(parent)
+    , timeToFull(0)
+    , numberOfBatteries(0)
+    , index(batteryIndex)
+{
+    initialize();
+}
+
+void QBatteryInfoPrivate::initialize()
 {
     QTimer *timer = new QTimer(this);
     connect(timer,SIGNAL(timeout()),this,SLOT(getBatteryStatus()));
@@ -81,21 +97,49 @@ int QBatteryInfoPrivate::batteryCount()
     return numberOfBatteries;
 }
 
+int QBatteryInfoPrivate::batteryIndex() const
+{
+    return index;
+}
+
+void QBatteryInfoPrivate::setBatteryIndex(int batteryIndex)
+{
+    if (index != batteryIndex) {
+        index = batteryIndex;
+        Q_EMIT batteryIndexChanged(index);
+    }
+}
+
 int QBatteryInfoPrivate::currentFlow(int battery)
 {
     return currentFlows[battery];
 }
 
+int QBatteryInfoPrivate::currentFlow()
+{
+    return currentFlow(index);
+}
+
 int QBatteryInfoPrivate::maximumCapacity(int battery)
 {
     return maximumCapacities[battery];
 }
 
+int QBatteryInfoPrivate::maximumCapacity()
+{
+    return maximumCapacity(index);
+}
+
 int QBatteryInfoPrivate::remainingCapacity(int battery)
 {
     return remainingCapacities[battery];
 }
 
+int QBatteryInfoPrivate::remainingCapacity()
+{
+    return remainingCapacity(index);
+}
+
 int QBatteryInfoPrivate::remainingChargingTime(int battery)
 {
     Q_UNUSED(battery)
@@ -105,17 +149,27 @@ int QBatteryInfoPrivate::remainingChargingTime(int battery)
    int cTime = systemBatteryState.EstimatedTime;
     if (cTime != timeToFull) {
         timeToFull = cTime;
-        emit remainingChargingTimeChanged(1,timeToFull);
+        emit remainingChargingTimeChanged(timeToFull);
     }
 
     return timeToFull;
 }
 
+int QBatteryInfoPrivate::remainingChargingTime()
+{
+    return remainingChargingTime(index);
+}
+
 int QBatteryInfoPrivate::voltage(int battery)
 {
     return voltages[battery];
 }
 
+int QBatteryInfoPrivate::voltage()
+{
+    return voltage(index);
+}
+
 QBatteryInfo::ChargerType QBatteryInfoPrivate::chargerType()
 {
     return currentChargerType;
@@ -126,6 +180,11 @@ QBatteryInfo::ChargingState QBatteryInfoPrivate::chargingState(int battery)
     return chargingStates[battery];
 }
 
+QBatteryInfo::ChargingState QBatteryInfoPrivate::chargingState()
+{
+    return chargingState(index);
+}
+
 QBatteryInfo::EnergyUnit QBatteryInfoPrivate::energyUnit()
 {
     return QBatteryInfo::UnitmWh;
@@ -136,6 +195,11 @@ QBatteryInfo::BatteryStatus QBatteryInfoPrivate::batteryStatus(int battery)
     return batteryStatuses[battery];
 }
 
+QBatteryInfo::BatteryStatus QBatteryInfoPrivate::batteryStatus()
+{
+    return batteryStatus(index);
+}
+
 void QBatteryInfoPrivate::getBatteryStatus()
 {
 #if !defined (Q_CC_MINGW) || defined(__MINGW64_VERSION_MAJOR)
@@ -145,7 +209,7 @@ void QBatteryInfoPrivate::getBatteryStatus()
     int cTime = systemBatteryState.EstimatedTime;
     if (cTime != timeToFull) {
         timeToFull = cTime;
-        emit remainingChargingTimeChanged(1,timeToFull);
+        emit remainingChargingTimeChanged(timeToFull);
     }
 
     int batteryNumber = 0;
@@ -222,20 +286,24 @@ void QBatteryInfoPrivate::getBatteryStatus()
 
                                                     if (chargingStates[batteryNumber] != chargingState) {
                                                         chargingStates.insert(batteryNumber, chargingState);
-                                                        emit chargingStateChanged(batteryNumber,chargingState);
+                                                        if (batteryNumber == index)
+                                                            emit chargingStateChanged(chargingState);
                                                     }
 
                                                     if (voltages[batteryNumber] !=  batteryStatus.Voltage) {
                                                         voltages.insert(batteryNumber, batteryStatus.Voltage);
-                                                        Q_EMIT voltageChanged(batteryNumber, batteryStatus.Voltage);
+                                                        if (batteryNumber == index)
+                                                            Q_EMIT voltageChanged(batteryStatus.Voltage);
                                                     }
                                                     if (currentFlows[batteryNumber] != batteryStatus.Rate) {
                                                         currentFlows.insert(batteryNumber,batteryStatus.Rate);
-                                                        Q_EMIT currentFlowChanged(batteryNumber, batteryStatus.Rate);
+                                                        if (batteryNumber == index)
+                                                            Q_EMIT currentFlowChanged(batteryStatus.Rate);
                                                     }
                                                     if (remainingCapacities[batteryNumber] != batteryStatus.Capacity) {
                                                         remainingCapacities.insert(batteryNumber, batteryStatus.Capacity);
-                                                        Q_EMIT remainingCapacityChanged(batteryNumber, batteryStatus.Capacity);
+                                                        if (batteryNumber == index)
+                                                            Q_EMIT remainingCapacityChanged(batteryStatus.Capacity);
                                                     }
                                                     ///
                                                     int level = batteryInfo.FullChargedCapacity / batteryStatus.Capacity;
@@ -253,7 +321,8 @@ void QBatteryInfoPrivate::getBatteryStatus()
 
                                                     if (batteryStatuses[batteryNumber] != batStatus) {
                                                         batteryStatuses.insert(batteryNumber,batStatus);
-                                                        Q_EMIT batteryStatusChanged(batteryNumber, batStatus);
+                                                        if (batteryNumber == index)
+                                                            Q_EMIT batteryStatusChanged(batStatus);
                                                     }
                                                 }
                                             }
diff --git a/src/systeminfo/windows/qbatteryinfo_win_p.h b/src/systeminfo/windows/qbatteryinfo_win_p.h
index 26a76d79..bb2a4d87 100644
--- a/src/systeminfo/windows/qbatteryinfo_win_p.h
+++ b/src/systeminfo/windows/qbatteryinfo_win_p.h
@@ -68,28 +68,40 @@ class QBatteryInfoPrivate : public QObject
 
 public:
     QBatteryInfoPrivate(QBatteryInfo *parent);
+    QBatteryInfoPrivate(int batteryIndex, QBatteryInfo *parent);
     ~QBatteryInfoPrivate();
 
     int batteryCount();
+    int batteryIndex() const;
     int currentFlow(int battery);
+    int currentFlow();
     int maximumCapacity(int battery);
+    int maximumCapacity();
     int remainingCapacity(int battery);
+    int remainingCapacity();
     int remainingChargingTime(int battery);
+    int remainingChargingTime();
     int voltage(int battery);
+    int voltage();
     QBatteryInfo::ChargerType chargerType();
     QBatteryInfo::ChargingState chargingState(int battery);
+    QBatteryInfo::ChargingState chargingState();
     QBatteryInfo::EnergyUnit energyUnit();
     QBatteryInfo::BatteryStatus batteryStatus(int battery);
+    QBatteryInfo::BatteryStatus batteryStatus();
+
+    void setBatteryIndex(int batteryIndex);
 
 Q_SIGNALS:
     void batteryCountChanged(int count);
+    void batteryIndexChanged(int batteryIndex);
     void chargerTypeChanged(QBatteryInfo::ChargerType type);
-    void chargingStateChanged(int battery, QBatteryInfo::ChargingState state);
-    void currentFlowChanged(int battery, int flow);
-    void remainingCapacityChanged(int battery, int capacity);
-    void remainingChargingTimeChanged(int battery, int seconds);
-    void voltageChanged(int battery, int voltage);
-    void batteryStatusChanged(int battery, QBatteryInfo::BatteryStatus status);
+    void chargingStateChanged(QBatteryInfo::ChargingState state);
+    void currentFlowChanged(int flow);
+    void remainingCapacityChanged(int capacity);
+    void remainingChargingTimeChanged(int seconds);
+    void voltageChanged(int voltage);
+    void batteryStatusChanged(QBatteryInfo::BatteryStatus status);
 
 private:
     QBatteryInfo * const q_ptr;
@@ -97,6 +109,7 @@ private:
 
     int timeToFull;
     int numberOfBatteries;
+    int index;
 
     QMap<int, int> currentFlows; // <battery ID, current value> pair
     QMap<int, int> voltages;
@@ -107,6 +120,8 @@ private:
     QBatteryInfo::ChargerType currentChargerType;
     QMap<int, QBatteryInfo::BatteryStatus> batteryStatuses;
 
+    void initialize();
+
 private Q_SLOTS:
     void getBatteryStatus();
 
diff --git a/tests/auto/systeminfo/qbatteryinfo/tst_qbatteryinfo.cpp b/tests/auto/systeminfo/qbatteryinfo/tst_qbatteryinfo.cpp
index 478e0dcb..9ce88a30 100644
--- a/tests/auto/systeminfo/qbatteryinfo/tst_qbatteryinfo.cpp
+++ b/tests/auto/systeminfo/qbatteryinfo/tst_qbatteryinfo.cpp
@@ -52,6 +52,7 @@ private slots:
     void tst_capacity();
     void tst_flow();
     void tst_invalid();
+    void tst_setBatteryIndex();
 };
 
 void tst_QBatteryInfo::tst_capacity()
@@ -60,8 +61,9 @@ void tst_QBatteryInfo::tst_capacity()
 
     int count = batteryInfo.batteryCount();
     for (int i = 0; i < count; ++i) {
-        int max = batteryInfo.maximumCapacity(i);
-        int remaining = batteryInfo.remainingCapacity(i);
+        batteryInfo.setBatteryIndex(i);
+        int max = batteryInfo.maximumCapacity();
+        int remaining = batteryInfo.remainingCapacity();
 
         QVERIFY(max == -1 || remaining == -1 || remaining <= max);
     }
@@ -73,26 +75,27 @@ void tst_QBatteryInfo::tst_flow()
 
     int count = batteryInfo.batteryCount();
     for (int i = 0; i < count; ++i) {
-        QBatteryInfo::ChargingState chargingState = batteryInfo.chargingState(i);
+        batteryInfo.setBatteryIndex(i);
+        QBatteryInfo::ChargingState chargingState = batteryInfo.chargingState();
         switch (chargingState) {
         case QBatteryInfo::Charging:
-            QVERIFY(batteryInfo.currentFlow(i) < 0);
-            QVERIFY(batteryInfo.remainingChargingTime(i) >= 0);
+            QVERIFY(batteryInfo.currentFlow() < 0);
+            QVERIFY(batteryInfo.remainingChargingTime() >= 0);
             break;
         case QBatteryInfo::Full:
-            QVERIFY(batteryInfo.remainingChargingTime(i) == 0);
+            QVERIFY(batteryInfo.remainingChargingTime() == 0);
             break;
         case QBatteryInfo::NotCharging:
-            QVERIFY(batteryInfo.currentFlow(i) >= 0);
-            QVERIFY(batteryInfo.remainingChargingTime(i) == 0);
+            QVERIFY(batteryInfo.currentFlow() >= 0);
+            QVERIFY(batteryInfo.remainingChargingTime() == 0);
             break;
         case QBatteryInfo::Discharging:
-            QVERIFY(batteryInfo.currentFlow(i) > 0);
-            QVERIFY(batteryInfo.remainingChargingTime(i) == 0);
+            QVERIFY(batteryInfo.currentFlow() > 0);
+            QVERIFY(batteryInfo.remainingChargingTime() == 0);
             break;
         case QBatteryInfo::UnknownChargingState:
-            QVERIFY(batteryInfo.currentFlow(i) == 0);
-            QVERIFY(batteryInfo.remainingChargingTime(i) == -1);
+            QVERIFY(batteryInfo.currentFlow() == 0);
+            QVERIFY(batteryInfo.remainingChargingTime() == -1);
             break;
         }
     }
@@ -102,22 +105,40 @@ void tst_QBatteryInfo::tst_invalid()
 {
     QBatteryInfo batteryInfo;
 
-    QVERIFY(batteryInfo.currentFlow(-1) == 0);
-    QVERIFY(batteryInfo.maximumCapacity(-1) == -1);
-    QVERIFY(batteryInfo.remainingCapacity(-1) == -1);
-    QVERIFY(batteryInfo.remainingChargingTime(-1) == -1);
-    QVERIFY(batteryInfo.voltage(-1) == -1);
-    QVERIFY(batteryInfo.chargingState(-1) == QBatteryInfo::UnknownChargingState);
-    QVERIFY(batteryInfo.batteryStatus(-1) == QBatteryInfo::BatteryStatusUnknown);
+    batteryInfo.setBatteryIndex(-1);
+    QVERIFY(batteryInfo.currentFlow() == 0);
+    QVERIFY(batteryInfo.maximumCapacity() == -1);
+    QVERIFY(batteryInfo.remainingCapacity() == -1);
+    QVERIFY(batteryInfo.remainingChargingTime() == -1);
+    QVERIFY(batteryInfo.voltage() == -1);
+    QVERIFY(batteryInfo.chargingState() == QBatteryInfo::UnknownChargingState);
+    QVERIFY(batteryInfo.batteryStatus() == QBatteryInfo::BatteryStatusUnknown);
 
     int count = batteryInfo.batteryCount();
-    QVERIFY(batteryInfo.currentFlow(count) == 0);
-    QVERIFY(batteryInfo.maximumCapacity(count) == -1);
-    QVERIFY(batteryInfo.remainingCapacity(count) == -1);
-    QVERIFY(batteryInfo.remainingChargingTime(count) == -1);
-    QVERIFY(batteryInfo.voltage(count) == -1);
-    QVERIFY(batteryInfo.chargingState(count) == QBatteryInfo::UnknownChargingState);
-    QVERIFY(batteryInfo.batteryStatus(count) == QBatteryInfo::BatteryStatusUnknown);
+    batteryInfo.setBatteryIndex(count);
+    QVERIFY(batteryInfo.currentFlow() == 0);
+    QVERIFY(batteryInfo.maximumCapacity() == -1);
+    QVERIFY(batteryInfo.remainingCapacity() == -1);
+    QVERIFY(batteryInfo.remainingChargingTime() == -1);
+    QVERIFY(batteryInfo.voltage() == -1);
+    QVERIFY(batteryInfo.chargingState() == QBatteryInfo::UnknownChargingState);
+    QVERIFY(batteryInfo.batteryStatus() == QBatteryInfo::BatteryStatusUnknown);
+}
+
+void tst_QBatteryInfo::tst_setBatteryIndex()
+{
+    QBatteryInfo batteryInfo;
+
+    QCOMPARE(batteryInfo.batteryIndex(), 0);
+
+    batteryInfo.setBatteryIndex(1);
+    QCOMPARE(batteryInfo.batteryIndex(), 1);
+
+    batteryInfo.setBatteryIndex(1000);
+    QCOMPARE(batteryInfo.batteryIndex(), 1000);
+
+    batteryInfo.setBatteryIndex(-1);
+    QCOMPARE(batteryInfo.batteryIndex(), -1);
 }
 
 QTEST_MAIN(tst_QBatteryInfo)
diff --git a/tests/manual/sysinfo-tester/main.cpp b/tests/manual/sysinfo-tester/main.cpp
index a23cf751..49be6da9 100644
--- a/tests/manual/sysinfo-tester/main.cpp
+++ b/tests/manual/sysinfo-tester/main.cpp
@@ -339,14 +339,15 @@ static void test_networkinfo(void)
 static void test_batteryinfo(void)
 {
     QBatteryInfo batInfo;
+    X(batInfo.batteryIndex())
     X(batInfo.chargerType());
-    X(batInfo.chargingState(0) );
-    X(batInfo.maximumCapacity(0));
-    X(batInfo.remainingCapacity(0));
-    X(batInfo.voltage(0));
-    X(batInfo.remainingChargingTime(0));
-    X(batInfo.currentFlow(0));
-    X(batInfo.batteryStatus(0));
+    X(batInfo.chargingState() );
+    X(batInfo.maximumCapacity());
+    X(batInfo.remainingCapacity());
+    X(batInfo.voltage());
+    X(batInfo.remainingChargingTime());
+    X(batInfo.currentFlow());
+    X(batInfo.batteryStatus());
     X(batInfo.energyUnit());
     X(batInfo.batteryCount());
 }