workspace/solid/hal/halpower.cpp

   1  /*  This file is part of the KDE project
   2     Copyright (C) 2006 Kevin Ottens <ervin@kde.org>
   3     Copyright (C) 2008 Dario Freddi <drf54321@gmail.com>
   4
   5     This library is free software; you can redistribute it and/or
   6     modify it under the terms of the GNU Library General Public
   7     License version 2 as published by the Free Software Foundation.
   8
   9     This library is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12     Library General Public License for more details.
  13
  14     You should have received a copy of the GNU Library General Public License
  15     along with this library; see the file COPYING.LIB.  If not, write to
  16     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  17     Boston, MA 02110-1301, USA.
  18
  19 */
  20
  21 #include "halpower.h"
  22
  23 #include <QtDBus/QDBusReply>
  24
  25 #include <kdebug.h>
  26
  27 #include "halsuspendjob.h"
  28
  29 #include <solid/deviceinterface.h>
  30 #include <solid/acadapter.h>
  31 #include <solid/battery.h>
  32 #include <solid/button.h>
  33 #include <solid/genericinterface.h>
  34
  35 HalPower::HalPower(QObject *parent, const QStringList  & /*args */)
  36     : PowerManager(parent),
  37       m_halComputer("org.freedesktop.Hal",
  38                      "/org/freedesktop/Hal/devices/computer",
  39                      "org.freedesktop.Hal.Device",
  40                      QDBusConnection::systemBus()),
  41       m_halPowerManagement("org.freedesktop.Hal",
  42                             "/org/freedesktop/Hal/devices/computer",
  43                             "org.freedesktop.Hal.Device.SystemPowerManagement",
  44                             QDBusConnection::systemBus()),
  45       m_halCpuFreq("org.freedesktop.Hal",
  46                     "/org/freedesktop/Hal/devices/computer",
  47                     "org.freedesktop.Hal.Device.CPUFreq",
  48                     QDBusConnection::systemBus()),
  49       m_halManager("org.freedesktop.Hal",
  50                     "/org/freedesktop/Hal/Manager",
  51                     "org.freedesktop.Hal.Manager",
  52                     QDBusConnection::systemBus())
  53 {
  54     connect(Solid::DeviceNotifier::instance(), SIGNAL(deviceRemoved(const QString &)),
  55             this, SLOT(slotDeviceRemoved(const QString &)));
  56     connect(Solid::DeviceNotifier::instance(), SIGNAL(deviceAdded(const QString &)),
  57             this, SLOT(slotDeviceAdded(const QString &)));
  58
  59     m_pluggedAdapterCount = 0;
  60     computeAcAdapters();
  61
  62     computeBatteries();
  63     updateBatteryStats();
  64
  65     computeButtons();
  66 }
  67
  68 HalPower::~HalPower()
  69 {
  70     qDeleteAll(m_acAdapters);
  71     qDeleteAll(m_batteries);
  72     qDeleteAll(m_buttons);
  73 }
  74
  75 QStringList HalPower::supportedSchemes() const
  76 {
  77     return QStringList() << "performance" << "powersaving";
  78 }
  79
  80 QString HalPower::schemeDescription(const QString &schemeName) const
  81 {
  82     if (schemeName=="performance")
  83     {
  84         return "Use all the performances of the system";
  85     }
  86     else if (schemeName=="powersaving")
  87     {
  88         return "Try to keep as much power as possible to improve battery life";
  89     }
  90     else
  91     {
  92         return QString();
  93     }
  94
  95     return QString();
  96 }
  97
  98 QString HalPower::scheme() const
  99 {
 100     // FIXME: We miss an accessor in HAL to make scheme management useful
 101     return QString();
 102 }
 103
 104 bool HalPower::setScheme(const QString &name)
 105 {
 106     bool powersave;
 107
 108     if (name=="powersaving")
 109     {
 110         powersave = true;
 111     }
 112     else if (name=="performance")
 113     {
 114         powersave = false;
 115     }
 116     else
 117     {
 118         return false;
 119     }
 120
 121     QDBusReply<int> reply = m_halPowerManagement.call("SetPowerSave", powersave);
 122
 123     if (reply.isValid())
 124     {
 125         int code = reply;
 126         return code==0;
 127     }
 128     else
 129     {
 130         return false;
 131     }
 132 }
 133
 134 Solid::Control::PowerManager::BatteryState HalPower::batteryState() const
 135 {
 136     if (m_batteries.size()==0)
 137     {
 138         return Solid::Control::PowerManager::NoBatteryState;
 139     }
 140     else if (m_currentBatteryCharge <= m_criticalBatteryCharge)
 141     {
 142         return Solid::Control::PowerManager::Critical;
 143     }
 144     else if (m_currentBatteryCharge <= m_lowBatteryCharge)
 145     {
 146         return Solid::Control::PowerManager::Low;
 147     }
 148     else if (m_currentBatteryCharge <= m_warningBatteryCharge)
 149     {
 150         return Solid::Control::PowerManager::Warning;
 151     }
 152     else
 153     {
 154         return Solid::Control::PowerManager::Normal;
 155     }
 156 }
 157
 158 int HalPower::batteryChargePercent() const
 159 {
 160     if (!m_maxBatteryCharge) return 0;
 161
 162     return (m_currentBatteryCharge *100)/m_maxBatteryCharge;
 163 }
 164
 165 int HalPower::batteryRemainingTime() const
 166 {
 167     return m_estimatedBatteryTime;
 168 }
 169
 170 Solid::Control::PowerManager::AcAdapterState HalPower::acAdapterState() const
 171 {
 172     if (m_acAdapters.size()==0)
 173     {
 174         return Solid::Control::PowerManager::UnknownAcAdapterState;
 175     }
 176     else if (m_pluggedAdapterCount==0)
 177     {
 178         return Solid::Control::PowerManager::Unplugged;
 179     }
 180     else
 181     {
 182         return Solid::Control::PowerManager::Plugged;
 183     }
 184 }
 185
 186 Solid::Control::PowerManager::SuspendMethods HalPower::supportedSuspendMethods() const
 187 {
 188     Solid::Control::PowerManager::SuspendMethods supported = Solid::Control::PowerManager::UnknownSuspendMethod;
 189
 190     QDBusReply<bool> reply = m_halComputer.call("GetPropertyBoolean", "power_management.can_suspend");
 191
 192     if (reply.isValid())
 193     {
 194         bool can_suspend = reply;
 195         if (can_suspend)
 196         {
 197             supported |= Solid::Control::PowerManager::ToRam;
 198         }
 199     }
 200     else
 201     {
 202         kDebug() << reply.error().name() << ": " << reply.error().message();
 203     }
 204
 205     reply = m_halComputer.call("GetPropertyBoolean", "power_management.can_hibernate");
 206
 207     if (reply.isValid())
 208     {
 209         bool can_hibernate = reply;
 210         if (can_hibernate)
 211         {
 212             supported |= Solid::Control::PowerManager::ToDisk;
 213         }
 214     }
 215     else
 216     {
 217         kDebug() << reply.error().name() << ": " << reply.error().message();
 218     }
 219
 220     return supported;
 221 }
 222
 223 KJob *HalPower::suspend(Solid::Control::PowerManager::SuspendMethod method) const
 224 {
 225     return new HalSuspendJob(m_halPowerManagement,
 226                              method, supportedSuspendMethods());
 227 }
 228
 229 Solid::Control::PowerManager::CpuFreqPolicies HalPower::supportedCpuFreqPolicies() const
 230 {
 231     QDBusReply<QStringList> reply = m_halCpuFreq.call("GetCPUFreqAvailableGovernors");
 232
 233     if (!reply.isValid())
 234     {
 235         return Solid::Control::PowerManager::UnknownCpuFreqPolicy;
 236     }
 237     else
 238     {
 239         QStringList governors = reply;
 240         Solid::Control::PowerManager::CpuFreqPolicies policies = Solid::Control::PowerManager::UnknownCpuFreqPolicy;
 241
 242         foreach (const QString& governor, governors)
 243         {
 244             if (governor == "ondemand")
 245             {
 246                 policies|= Solid::Control::PowerManager::OnDemand;
 247             }
 248             else if (governor == "userspace")
 249             {
 250                 policies|= Solid::Control::PowerManager::Userspace;
 251             }
 252             else if (governor == "powersave")
 253             {
 254                 policies|= Solid::Control::PowerManager::Powersave;
 255             }
 256             else if (governor == "performance")
 257             {
 258                 policies|= Solid::Control::PowerManager::Performance;
 259             }
 260             else if (governor == "conservative")
 261             {
 262                 policies|= Solid::Control::PowerManager::Conservative;
 263             }
 264             else
 265             {
 266                 kWarning() << "Unknown governor: " << governor ;
 267             }
 268         }
 269
 270         return policies;
 271     }
 272 }
 273
 274 Solid::Control::PowerManager::CpuFreqPolicy HalPower::cpuFreqPolicy() const
 275 {
 276     QDBusReply<QString> reply = m_halCpuFreq.call("GetCPUFreqGovernor");
 277
 278     if (!reply.isValid())
 279     {
 280         return Solid::Control::PowerManager::UnknownCpuFreqPolicy;
 281     }
 282     else
 283     {
 284         QString governor = reply;
 285
 286         if (governor == "ondemand")
 287         {
 288             return Solid::Control::PowerManager::OnDemand;
 289         }
 290         else if (governor == "userspace")
 291         {
 292             return Solid::Control::PowerManager::Userspace;
 293         }
 294         else if (governor == "powersave")
 295         {
 296             return Solid::Control::PowerManager::Powersave;
 297         }
 298         else if (governor == "performance")
 299         {
 300             return Solid::Control::PowerManager::Performance;
 301         }
 302         else if (governor == "conservative")
 303         {
 304             return Solid::Control::PowerManager::Conservative;
 305         }
 306         else
 307         {
 308             return Solid::Control::PowerManager::UnknownCpuFreqPolicy;
 309         }
 310     }
 311 }
 312
 313 bool HalPower::setCpuFreqPolicy(Solid::Control::PowerManager::CpuFreqPolicy newPolicy)
 314 {
 315     QString governor;
 316
 317     switch(newPolicy)
 318     {
 319     case Solid::Control::PowerManager::OnDemand:
 320         governor = "ondemand";
 321         break;
 322     case Solid::Control::PowerManager::Userspace:
 323         governor = "userspace";
 324         break;
 325     case Solid::Control::PowerManager::Powersave:
 326         governor = "powersave";
 327         break;
 328     case Solid::Control::PowerManager::Performance:
 329         governor = "performance";
 330         break;
 331     case Solid::Control::PowerManager::Conservative:
 332         governor = "conservative";
 333         break;
 334     default:
 335         return false;
 336     }
 337
 338     QDBusReply<int> reply = m_halCpuFreq.call("SetCPUFreqGovernor", governor);
 339
 340     if (reply.isValid())
 341     {
 342         int code = reply;
 343         return code==0;
 344     }
 345     else
 346     {
 347         return false;
 348     }
 349 }
 350
 351 bool HalPower::canDisableCpu(int /*cpuNum */) const
 352 {
 353     return false;
 354 }
 355
 356 bool HalPower::setCpuEnabled(int /*cpuNum */, bool /*enabled */)
 357 {
 358     return false;
 359 }
 360
 361 Solid::Control::PowerManager::BrightnessControlsList HalPower::brightnessControlsAvailable()
 362 {
 363     Solid::Control::PowerManager::BrightnessControlsList deviceList;
 364     foreach(const QString &name, m_halManager.call("FindDeviceByCapability", "laptop_panel").arguments().at(0).toStringList())
 365     {
 366         deviceList.insert(name, Solid::Control::PowerManager::Screen);
 367     }
 368     foreach(const QString &name, m_halManager.call("FindDeviceByCapability", "keyboard_backlight").arguments().at(0).toStringList())
 369     {
 370         deviceList.insert(name, Solid::Control::PowerManager::Keyboard);
 371     }
 372     return deviceList;
 373 }
 374
 375 float HalPower::brightness(const QString &device)
 376 {
 377     float brightness;
 378     if(m_halManager.call("FindDeviceByCapability", "laptop_panel").arguments().at(0).toStringList().contains(device))
 379     {
 380         QDBusInterface deviceInterface("org.freedesktop.Hal", device, "org.freedesktop.Hal.Device.LaptopPanel", QDBusConnection::systemBus());
 381         brightness = deviceInterface.call("GetBrightness").arguments().at(0).toDouble();
 382         if(deviceInterface.lastError().isValid())
 383         {
 384             return 0;
 385         }
 386         else
 387         {
 388             QDBusInterface propertyInterface("org.freedesktop.Hal", device, "org.freedesktop.Hal.Device", QDBusConnection::systemBus());
 389             int levels = propertyInterface.call("GetProperty", "laptop_panel.num_levels").arguments().at(0).toInt();
 390             return (float)(100*(brightness/(levels-1)));
 391         }
 392     }
 393     if(m_halManager.call("FindDeviceByCapability", "keyboard_backlight").arguments().at(0).toStringList().contains(device))
 394     {
 395         QDBusInterface deviceInterface("org.freedesktop.Hal", device, "org.freedesktop.Hal.Device.KeyboardBacklight", QDBusConnection::systemBus()); //TODO - I do not have a backlight enabled keyboard, so I'm guessing a bit here. Could someone please check this.
 396         brightness = deviceInterface.call("GetBrightness").arguments().at(0).toDouble();
 397         if(deviceInterface.lastError().isValid())
 398         {
 399             return 0;
 400         }
 401         else
 402         {
 403             QDBusInterface propertyInterface("org.freedesktop.Hal", device, "org.freedesktop.Hal.Device", QDBusConnection::systemBus());
 404             int levels = propertyInterface.call("GetProperty", "keyboard_backlight.num_levels").arguments().at(0).toInt();
 405             return (float)(100*(brightness/(levels-1)));
 406         }
 407     }
 408     return 0;
 409 }
 410
 411 bool HalPower::setBrightness(float brightness, const QString &device)
 412 {
 413     if(m_halManager.call("FindDeviceByCapability", "laptop_panel").arguments().at(0).toStringList().contains(device))
 414     {
 415         QDBusInterface propertyInterface("org.freedesktop.Hal", device, "org.freedesktop.Hal.Device", QDBusConnection::systemBus());
 416         int levels = propertyInterface.call("GetProperty", "laptop_panel.num_levels").arguments().at(0).toInt();
 417         QDBusInterface deviceInterface("org.freedesktop.Hal", device, "org.freedesktop.Hal.Device.LaptopPanel", QDBusConnection::systemBus());
 418         deviceInterface.call("SetBrightness", qRound((levels-1)*(brightness/100.0))); // .0? The right way? Feels hackish.
 419         if(!deviceInterface.lastError().isValid())
 420         {
 421             emit(brightnessChanged(brightness));
 422             return true;
 423         }
 424     }
 425     if(m_halManager.call("FindDeviceByCapability", "keyboard_backlight").arguments().at(0).toStringList().contains(device))
 426     {
 427         QDBusInterface propertyInterface("org.freedesktop.Hal", device, "org.freedesktop.Hal.Device", QDBusConnection::systemBus());
 428         int levels = propertyInterface.call("GetProperty", "keyboard_backlight.num_levels").arguments().at(0).toInt();
 429         QDBusInterface deviceInterface("org.freedesktop.Hal", device, "org.freedesktop.Hal.Device.KeyboardBacklight", QDBusConnection::systemBus()); //TODO - I do not have a backlight enabled keyboard, so I'm guessing a bit here. Could someone please check this.
 430         deviceInterface.call("SetBrightness", qRound((levels-1)*(brightness/100.0)));
 431         if(!deviceInterface.lastError().isValid())
 432         {
 433             emit(brightnessChanged(brightness));
 434             return true;
 435         }
 436     }
 437     return false;
 438 }
 439
 440 void HalPower::computeAcAdapters()
 441 {
 442     QList<Solid::Device> adapters
 443         = Solid::Device::listFromType(Solid::DeviceInterface::AcAdapter);
 444
 445     foreach (Solid::Device adapter, adapters)
 446     {
 447         m_acAdapters[adapter.udi()] = new Solid::Device(adapter);
 448         connect(m_acAdapters[adapter.udi()]->as<Solid::AcAdapter>(), SIGNAL(plugStateChanged(bool, const QString &)),
 449                  this, SLOT(slotPlugStateChanged(bool)));
 450
 451         if (m_acAdapters[adapter.udi()]->as<Solid::AcAdapter>()!=0
 452           && m_acAdapters[adapter.udi()]->as<Solid::AcAdapter>()->isPlugged())
 453         {
 454             m_pluggedAdapterCount++;
 455         }
 456     }
 457 }
 458
 459 void HalPower::computeBatteries()
 460 {
 461     QList<Solid::Device> batteries
 462         = Solid::Device::listFromQuery("Battery.type == 'PrimaryBattery'");
 463
 464     foreach (Solid::Device battery, batteries)
 465     {
 466         m_batteries[battery.udi()] = new Solid::Device(battery);
 467         connect(m_batteries[battery.udi()]->as<Solid::Battery>(), SIGNAL(chargePercentChanged(int, const QString &)),
 468                  this, SLOT(updateBatteryStats()));
 469         connect(m_batteries[battery.udi()]->as<Solid::GenericInterface>(), SIGNAL(propertyChanged(const QMap<QString,int> &)),
 470                  this, SLOT(slotBatteryPropertyChanged(const QMap<QString,int> &)));
 471     }
 472
 473     updateBatteryStats();
 474 }
 475
 476 void HalPower::computeButtons()
 477 {
 478     QList<Solid::Device> buttons
 479         = Solid::Device::listFromType(Solid::DeviceInterface::Button);
 480
 481     foreach (Solid::Device button, buttons)
 482     {
 483         m_buttons[button.udi()] = new Solid::Device(button);
 484         connect(m_buttons[button.udi()]->as<Solid::Button>(), SIGNAL(pressed(Solid::Button::ButtonType, const QString &)),
 485                  this, SLOT(slotButtonPressed(Solid::Button::ButtonType)));
 486     }
 487 }
 488
 489 void HalPower::updateBatteryStats()
 490 {
 491     m_currentBatteryCharge = 0;
 492     m_maxBatteryCharge = 0;
 493     m_warningBatteryCharge = 0;
 494     m_lowBatteryCharge = 0;
 495     m_criticalBatteryCharge = 0;
 496     m_estimatedBatteryTime = 0;
 497
 498     foreach (Solid::Device *d, m_batteries)
 499     {
 500         Solid::GenericInterface *interface = d->as<Solid::GenericInterface>();
 501
 502         if (interface == 0) continue;
 503
 504         m_currentBatteryCharge+= interface->property("battery.charge_level.current").toInt();
 505         m_maxBatteryCharge+= interface->property("battery.charge_level.last_full").toInt();
 506         m_warningBatteryCharge+= interface->property("battery.charge_level.warning").toInt();
 507         m_lowBatteryCharge+= interface->property("battery.charge_level.low").toInt();
 508         m_estimatedBatteryTime+= interface->property("battery.remaining_time").toInt() * 1000;
 509     }
 510
 511     m_criticalBatteryCharge = m_lowBatteryCharge/2;
 512 }
 513
 514 void HalPower::slotPlugStateChanged(bool newState)
 515 {
 516     if (newState)
 517     {
 518         if(m_pluggedAdapterCount == 0)
 519         {
 520             emit acAdapterStateChanged(Solid::Control::PowerManager::Plugged);
 521         }
 522         m_pluggedAdapterCount++;
 523     }
 524     else
 525     {
 526         if(m_pluggedAdapterCount == 1)
 527         {
 528             emit acAdapterStateChanged(Solid::Control::PowerManager::Unplugged);
 529         }
 530         m_pluggedAdapterCount--;
 531     }
 532 }
 533
 534 void HalPower::slotButtonPressed(Solid::Button::ButtonType type)
 535 {
 536     Solid::Button *button = qobject_cast<Solid::Button *>(sender());
 537
 538     if (button == 0) return;
 539
 540     switch(type)
 541     {
 542     case Solid::Button::PowerButton:
 543         emit buttonPressed(Solid::Control::PowerManager::PowerButton);
 544         break;
 545     case Solid::Button::SleepButton:
 546         emit buttonPressed(Solid::Control::PowerManager::SleepButton);
 547         break;
 548     case Solid::Button::LidButton:
 549         if (button->stateValue())
 550         {
 551             emit buttonPressed(Solid::Control::PowerManager::LidClose);
 552         }
 553         else
 554         {
 555             emit buttonPressed(Solid::Control::PowerManager::LidOpen);
 556         }
 557         break;
 558     default:
 559         kWarning() << "Unknown button type" ;
 560         break;
 561     }
 562 }
 563
 564 void HalPower::slotDeviceAdded(const QString &udi)
 565 {
 566     Solid::Device *device = new Solid::Device(udi);
 567     if (device->is<Solid::AcAdapter>())
 568     {
 569         m_acAdapters[udi] = device;
 570         connect(m_acAdapters[udi]->as<Solid::AcAdapter>(), SIGNAL(plugStateChanged(bool, const QString &)),
 571                  this, SLOT(slotPlugStateChanged(bool)));
 572
 573         if (m_acAdapters[udi]->as<Solid::AcAdapter>()!=0
 574           && m_acAdapters[udi]->as<Solid::AcAdapter>()->isPlugged())
 575         {
 576             m_pluggedAdapterCount++;
 577         }
 578     }
 579     else if (device->is<Solid::Battery>())
 580     {
 581         m_batteries[udi] = device;
 582         connect(m_batteries[udi]->as<Solid::Battery>(), SIGNAL(chargePercentChanged(int, const QString &)),
 583                  this, SLOT(updateBatteryStats()));
 584         connect(m_batteries[udi]->as<Solid::GenericInterface>(), SIGNAL(propertyChanged(const QMap<QString,int> &)),
 585                  this, SLOT(slotBatteryPropertyChanged(const QMap<QString,int> &)));
 586     }
 587     else if (device->is<Solid::Button>())
 588     {
 589         m_buttons[udi] = device;
 590         connect(m_buttons[udi]->as<Solid::Button>(), SIGNAL(pressed(int, const QString &)),
 591                  this, SLOT(slotButtonPressed(int)));
 592     }
 593     else
 594     {
 595         delete device;
 596     }
 597 }
 598
 599 void HalPower::slotDeviceRemoved(const QString &udi)
 600 {
 601     Solid::Device *device = 0;
 602
 603     device = m_acAdapters.take(udi);
 604
 605     if (device!=0)
 606     {
 607         delete device;
 608
 609         m_pluggedAdapterCount = 0;
 610
 611         foreach (Solid::Device *d, m_acAdapters)
 612         {
 613             if (d->as<Solid::AcAdapter>()!=0
 614               && d->as<Solid::AcAdapter>()->isPlugged())
 615             {
 616                 m_pluggedAdapterCount++;
 617             }
 618         }
 619
 620         return;
 621     }
 622
 623     device = m_batteries.take(udi);
 624
 625     if (device!=0)
 626     {
 627         delete device;
 628         updateBatteryStats();
 629         return;
 630     }
 631
 632     device = m_buttons.take(udi);
 633
 634     if (device!=0)
 635     {
 636         delete device;
 637         return;
 638     }
 639 }
 640
 641 void HalPower::slotBatteryPropertyChanged(const QMap<QString,int> &changes)
 642 {
 643     /* This slot catches property changes on battery devices. At
 644      * the moment it is used to find out remaining time on batteries.
 645      */
 646
 647     if (changes.contains("battery.remaining_time")) {
 648         updateBatteryStats();
 649         emit batteryRemainingTimeChanged(batteryRemainingTime());
 650     }
 651 }
 652
 653 #include "halpower.moc"