workspace/plasma/dataengines/powermanagement/powermanagementengine.cpp

   1 /*
   2  *   Copyright 2007 Aaron Seigo <aseigo@kde.org>
   3  *   Copyright 2007-2008 Sebastian Kuegler <sebas@kde.org>
   4  *   CopyRight 2007 Maor Vanmak <mvanmak1@gmail.com>
   5  *   Copyright 2008 Dario Freddi <drf54321@gmail.com>
   6  *
   7  *   This program is free software; you can redistribute it and/or modify
   8  *   it under the terms of the GNU Library General Public License version 2 as
   9  *   published by the Free Software Foundation
  10  *
  11  *   This program is distributed in the hope that it will be useful,
  12  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *   GNU General Public License for more details
  15  *
  16  *   You should have received a copy of the GNU Library General Public
  17  *   License along with this program; if not, write to the
  18  *   Free Software Foundation, Inc.,
  19  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  20  */
  21
  22 #include "powermanagementengine.h"
  23
  24 //solid specific includes
  25 #include <solid/devicenotifier.h>
  26 #include <solid/device.h>
  27 #include <solid/deviceinterface.h>
  28 #include <solid/battery.h>
  29 #include <solid/powermanagement.h>
  30 #include <solid/control/powermanager.h>
  31
  32 #include <KDebug>
  33 #include <KLocale>
  34
  35 #include <QtDBus/QDBusInterface>
  36 #include <QtDBus/QDBusReply>
  37
  38 #include <Plasma/DataContainer>
  39
  40 PowermanagementEngine::PowermanagementEngine(QObject* parent, const QVariantList& args)
  41         : Plasma::DataEngine(parent, args)
  42         , m_acadapter(0)
  43         , m_sources(0)
  44         , m_dbus(QDBusConnection::sessionBus())
  45 {
  46     Q_UNUSED(args)
  47
  48     m_sources << "Battery" << "AC Adapter" << "Sleepstates" << "PowerDevil";
  49
  50     // This following call can be removed, but if we do, the
  51     // data is not shown in the plasmaengineexplorer.
  52     // sourceRequestEvent("Battery");
  53 }
  54
  55 PowermanagementEngine::~PowermanagementEngine()
  56 {}
  57
  58 void PowermanagementEngine::init()
  59 {
  60     connect(Solid::DeviceNotifier::instance(), SIGNAL(deviceRemoved(QString)),
  61             this,                              SLOT(deviceRemoved(QString)));
  62     connect(Solid::DeviceNotifier::instance(), SIGNAL(deviceAdded(QString)),
  63             this,                              SLOT(deviceAdded(QString)));
  64     connect(Solid::Control::PowerManager::notifier(), SIGNAL(batteryRemainingTimeChanged(int)),
  65             this,                                     SLOT(batteryRemainingTimeChanged(int)));
  66
  67     QStringList modules;
  68     QDBusInterface kdedInterface("org.kde.kded", "/kded", "org.kde.kded");
  69     QDBusReply<QStringList> reply = kdedInterface.call("loadedModules");
  70
  71     if (!reply.isValid()) {
  72         return;
  73     }
  74
  75     modules = reply.value();
  76
  77     if (modules.contains("powerdevil")) {
  78
  79         if (!m_dbus.connect("org.kde.kded", "/modules/powerdevil", "org.kde.PowerDevil",
  80                           "profileChanged", this,
  81                            SLOT(profilesChanged(const QString&, const QStringList&)))) {
  82             kDebug() << "error!";
  83         }
  84
  85         QDBusMessage msg = QDBusMessage::createMethodCall("org.kde.kded", "/modules/powerdevil",
  86                            "org.kde.PowerDevil", "streamData");
  87         m_dbus.call(msg);
  88
  89     }
  90 }
  91
  92 QStringList PowermanagementEngine::sources() const
  93 {
  94     return m_sources + m_batterySources.values();
  95 }
  96
  97 bool PowermanagementEngine::sourceRequestEvent(const QString &name)
  98 {
  99     if (name == "Battery") {
 100         QList<Solid::Device> list_battery =
 101                         Solid::Device::listFromType(Solid::DeviceInterface::Battery, QString());
 102         if (list_battery.count() == 0) {
 103             setData("Battery", "has Battery", false);
 104             return true;
 105         }
 106
 107         uint index = 0;
 108         QStringList battery_sources;
 109
 110         foreach (const Solid::Device &device_battery, list_battery) {
 111             const Solid::Battery* battery = device_battery.as<Solid::Battery>();
 112
 113             if(battery != 0) {
 114                 if(battery->type() == Solid::Battery::PrimaryBattery) {
 115                     QString source = QString("Battery%1").arg(index++);
 116
 117                     battery_sources<<source;
 118
 119                     m_batterySources[device_battery.udi()] = source;
 120
 121                     connect(battery, SIGNAL(chargeStateChanged(int, const QString &)), this,
 122                             SLOT(updateBatteryChargeState(int, const QString &)));
 123                     connect(battery, SIGNAL(chargePercentChanged(int, const QString &)), this,
 124                             SLOT(updateBatteryChargePercent(int, const QString &)));
 125                     connect(battery, SIGNAL(plugStateChanged(bool, const QString &)), this,
 126                             SLOT(updateBatteryPlugState(bool, const QString &)));
 127
 128                     // Set initial values
 129                     updateBatteryChargeState(battery->chargeState(), device_battery.udi());
 130                     updateBatteryChargePercent(battery->chargePercent(), device_battery.udi());
 131                     updateBatteryPlugState(battery->isPlugged(), device_battery.udi());
 132                 }
 133             }
 134         }
 135
 136         if (battery_sources.count() > 0) {
 137             setData("Battery", "has Battery", true);
 138             setData("Battery", "sources", battery_sources);
 139             setData("Battery", "Remaining msec", Solid::Control::PowerManager::batteryRemainingTime());
 140         }
 141     } else if (name == "AC Adapter") {
 142         // AC Adapter handling
 143         QList<Solid::Device> list_ac =
 144                         Solid::Device::listFromType(Solid::DeviceInterface::AcAdapter, QString());
 145         foreach (Solid::Device device_ac, list_ac) {
 146             m_acadapter = device_ac.as<Solid::AcAdapter>();
 147             updateAcPlugState(m_acadapter->isPlugged());
 148             connect(m_acadapter, SIGNAL(plugStateChanged(bool, const QString &)), this,
 149                     SLOT(updateAcPlugState(bool)));
 150         }
 151     } else if (name == "Sleepstates") {
 152         QSet<Solid::PowerManagement::SleepState> sleepstates =
 153                                 Solid::PowerManagement::supportedSleepStates();
 154         // We first set all possible sleepstates to false, then enable the ones that are available
 155         setData("Sleepstates", "Standby", false);
 156         setData("Sleepstates", "Suspend", false);
 157         setData("Sleepstates", "Hibernate", false);
 158
 159         foreach (const Solid::PowerManagement::SleepState &sleepstate, sleepstates) {
 160             if (sleepstate == Solid::PowerManagement::StandbyState) {
 161                 setData("Sleepstates", "Supports standby", true);
 162             } else if (sleepstate == Solid::PowerManagement::SuspendState) {
 163                 setData("Sleepstates", "Supports suspend", true);
 164             } else if (sleepstate == Solid::PowerManagement::HibernateState) {
 165                 setData("Sleepstates", "Supports hibernate", true);
 166             }
 167             kDebug() << "Sleepstate \"" << sleepstate << "\" supported.";
 168         }
 169     } else if (name == "PowerDevil") {
 170         QDBusMessage msg = QDBusMessage::createMethodCall("org.kde.kded", "/modules/powerdevil",
 171                            "org.kde.PowerDevil", "streamData");
 172         m_dbus.call(msg);
 173     } else {
 174         kDebug() << "Data for '" << name << "' not found";
 175     }
 176     return true;
 177 }
 178
 179 void PowermanagementEngine::updateBatteryChargeState(int newState, const QString& udi)
 180 {
 181     QString state;
 182     if (newState == Solid::Battery::NoCharge) {
 183         state = "NoCharge";
 184     } else if (newState == Solid::Battery::Charging) {
 185         state = "Charging";
 186     } else if (newState == Solid::Battery::Discharging) {
 187         state = "Discharging";
 188     } else {
 189         state = "Could not determine battery status. Something is fishy here. :o";
 190     }
 191     const QString& source = m_batterySources[udi];
 192     setData(source, "State", state);
 193     scheduleSourcesUpdated();
 194 }
 195
 196 void PowermanagementEngine::updateBatteryPlugState(bool newState, const QString& udi)
 197 {
 198     const QString& source = m_batterySources[udi];
 199     setData(source, "Plugged in", newState);
 200     scheduleSourcesUpdated();
 201 }
 202
 203 void PowermanagementEngine::updateBatteryChargePercent(int newValue, const QString& udi)
 204 {
 205     const QString& source = m_batterySources[udi];
 206     setData(source, "Percent", newValue);
 207     scheduleSourcesUpdated();
 208 }
 209
 210 void PowermanagementEngine::updateAcPlugState(bool newState)
 211 {
 212     setData("AC Adapter", "Plugged in", newState);
 213     scheduleSourcesUpdated();
 214 }
 215
 216 void PowermanagementEngine::deviceRemoved(const QString& udi)
 217 {
 218     if (m_batterySources.contains(udi)) {
 219         QString source = m_batterySources[udi];
 220         m_batterySources.remove(udi);
 221         removeSource(source);
 222
 223         QStringList sourceNames(m_batterySources.values());
 224         sourceNames.removeAll(source);
 225         setData("Battery", "sources", sourceNames);
 226     }
 227 }
 228
 229 void PowermanagementEngine::deviceAdded(const QString& udi)
 230 {
 231     Solid::Device device(udi);
 232     if (device.isValid()) {
 233         const Solid::Battery* battery = device.as<Solid::Battery>();
 234
 235         if (battery != 0) {
 236             int index = 0;
 237             QStringList sourceNames(m_batterySources.values());
 238             while (sourceNames.contains(QString("Battery%1").arg(index))) {
 239                 index++;
 240             }
 241
 242             QString source = QString("Battery%1").arg(index);
 243             sourceNames << source;
 244             m_batterySources[device.udi()] = source;
 245
 246             connect(battery, SIGNAL(chargeStateChanged(int, const QString &)), this,
 247                     SLOT(updateBatteryChargeState(int, const QString &)));
 248             connect(battery, SIGNAL(chargePercentChanged(int, const QString &)), this,
 249                     SLOT(updateBatteryChargePercent(int, const QString &)));
 250             connect(battery, SIGNAL(plugStateChanged(bool, const QString &)), this,
 251                     SLOT(updateBatteryPlugState(bool, const QString &)));
 252
 253             // Set initial values
 254             updateBatteryChargeState(battery->chargeState(), device.udi());
 255             updateBatteryChargePercent(battery->chargePercent(), device.udi());
 256             updateBatteryPlugState(battery->isPlugged(), device.udi());
 257
 258             setData("Battery", "sources", sourceNames);
 259         }
 260     }
 261 }
 262
 263 void PowermanagementEngine::profilesChanged( const QString &current, const QStringList &profiles )
 264 {
 265     setData("PowerDevil", "currentProfile", current);
 266     setData("PowerDevil", "availableProfiles", profiles);
 267     scheduleSourcesUpdated();
 268 }
 269
 270 void PowermanagementEngine::batteryRemainingTimeChanged(int time)
 271 {
 272     //kDebug() << "Remaining Time changed:" << time;
 273     setData("Battery0", "Remaining msec", time);
 274     scheduleSourcesUpdated();
 275 }
 276
 277 #include "powermanagementengine.moc"