workspace/libs/solid/control/ifaces/powermanager.h

   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 #ifndef SOLID_IFACES_POWERMANAGER_H
  22 #define SOLID_IFACES_POWERMANAGER_H
  23
  24 #include <QtCore/QObject>
  25 #include <QtCore/QStringList>
  26
  27 #include "../solid_control_export.h"
  28
  29 #include "../powermanager.h"
  30
  31 class KJob;
  32
  33 namespace Solid
  34 {
  35 namespace Control
  36 {
  37 namespace Ifaces
  38 {
  39     /**
  40      * This class specifies the interface a backend will have to implement in
  41      * order to be used in the system.
  42      *
  43      * A power manager allows to control or query the power management features
  44      * or the underlying platform.
  45      */
  46     class SOLIDCONTROLIFACES_EXPORT PowerManager : public QObject
  47     {
  48         Q_OBJECT
  49
  50     public:
  51         /**
  52          * Constructs a PowerManager
  53          */
  54         PowerManager(QObject *parent = 0);
  55
  56         /**
  57          * Destructs a PowerManager object
  58          */
  59         virtual ~PowerManager();
  60
  61
  62         /**
  63          * Retrieves the list of power management schemes available on this system.
  64          *
  65          * @return the available power management schemes
  66          */
  67         virtual QStringList supportedSchemes() const = 0;
  68
  69         /**
  70          * Retrieves a localized description corresponding to the given scheme.
  71          *
  72          * @param schemeName the name of the scheme we request the description for
  73          * @return the associated description
  74          */
  75         virtual QString schemeDescription(const QString &schemeName) const = 0;
  76
  77         /**
  78          * Retrieves the name of the current power management scheme used
  79          * by the system.
  80          *
  81          * @return the current scheme
  82          */
  83         virtual QString scheme() const = 0;
  84
  85         /**
  86          * Changes the current power management scheme.
  87          *
  88          * @param name the name of the new scheme
  89          * @return true if the scheme change succeeded, false otherwise
  90          */
  91         virtual bool setScheme(const QString &name) = 0;
  92
  93
  94         /**
  95          * Retrieves the current state of the system battery.
  96          *
  97          * @return the current battery state
  98          * @see Solid::Control::PowerManager::BatteryState
  99          */
 100         virtual Solid::Control::PowerManager::BatteryState batteryState() const = 0;
 101
 102         /**
 103          * Retrieves the current charge percentage of the system batteries.
 104          *
 105          * @return the current global battery charge percentage
 106          */
 107         virtual int batteryChargePercent() const = 0;
 108
 109         /**
 110          * Retrieves the current estimated remaining time of the system batteries
 111          *
 112          * @return the current global estimated remaining time in milliseconds
 113          */
 114         virtual int batteryRemainingTime() const = 0;
 115
 116         /**
 117          * Retrieves the current state of the system AC adapter.
 118          *
 119          * @return the current AC adapter state
 120          * @see Solid::Control::PowerManager::AcAdapterState
 121          */
 122         virtual Solid::Control::PowerManager::AcAdapterState acAdapterState() const = 0;
 123
 124
 125         /**
 126          * Retrieves the set of suspend methods supported by the system.
 127          *
 128          * @return the suspend methods supported by this system
 129          * @see Solid::Control::PowerManager::SuspendMethod
 130          * @see Solid::Control::PowerManager::SuspendMethods
 131          */
 132         virtual Solid::Control::PowerManager::SuspendMethods supportedSuspendMethods() const = 0;
 133
 134         /**
 135          * Requests a suspend of the system.
 136          *
 137          * @param method the suspend method to use
 138          * @return the job handling the operation
 139          */
 140         virtual KJob *suspend(Solid::Control::PowerManager::SuspendMethod method) const = 0;
 141
 142
 143         /**
 144          * Retrieves the set of CPU frequency policies supported by the system.
 145          *
 146          * @return the CPU frequency policies supported by this system
 147          * @see Solid::Control::PowerManager::CpuFreqPolicy
 148          * @see Solid::Control::PowerManager::CpuFreqPolicies
 149          */
 150         virtual Solid::Control::PowerManager::CpuFreqPolicies supportedCpuFreqPolicies() const = 0;
 151
 152         /**
 153          * Retrieves the current CPU frequency policy of the system.
 154          *
 155          * @return the current CPU frequency policy used by the system
 156          * @see Solid::Control::PowerManager::CpuFreqPolicy
 157          */
 158         virtual Solid::Control::PowerManager::CpuFreqPolicy cpuFreqPolicy() const = 0;
 159
 160         /**
 161          * Changes the current CPU frequency policy of the system.
 162          *
 163          * @param newPolicy the new policy
 164          * @return true if the policy change succeeded, false otherwise
 165          * @see Solid::Control::PowerManager::CpuFreqPolicy
 166          */
 167         virtual bool setCpuFreqPolicy(Solid::Control::PowerManager::CpuFreqPolicy newPolicy) = 0;
 168
 169         /**
 170          * Checks if a CPU can be disabled.
 171          *
 172          * @param cpuNum the number of the CPU we want to check
 173          * @return true if the given CPU can be disabled, false otherwise
 174          */
 175         virtual bool canDisableCpu(int cpuNum) const = 0;
 176
 177         /**
 178          * Enables or disables a CPU.
 179          *
 180          * @param cpuNum the number of the CPU we want to enable or disable
 181          * @param enabled the new state of the CPU
 182          * @return true if the state change succeeded, false otherwise
 183          */
 184         virtual bool setCpuEnabled(int cpuNum, bool enabled) = 0;
 185
 186         /**
 187          * Checks if brightness controls are enabled on this system.
 188          *
 189          * @return a list of the devices available to control
 190          */
 191         virtual Solid::Control::PowerManager::BrightnessControlsList brightnessControlsAvailable() = 0;
 192
 193         /**
 194          * Gets the screen brightness.
 195          *
 196          * @param device the name of the device that you would like to control
 197          * @return the brightness of the device, as a percentage
 198          */
 199         virtual float brightness(const QString &device = QString()) = 0;
 200
 201         /**
 202          * Sets the screen brightness.
 203          *
 204          * @param brightness the desired screen brightness, as a percentage
 205          * @param device the name of the device that you would like to control, as given by brightnessControlsAvailable
 206          * @return true if the brightness change succeeded, false otherwise
 207          */
 208         virtual bool setBrightness(float brightness, const QString &panel = QString()) = 0;
 209
 210     Q_SIGNALS:
 211         /**
 212          * This signal is emitted when the power management scheme has changed.
 213          *
 214          * @param newScheme the new scheme name
 215          */
 216         void schemeChanged(QString newScheme);
 217
 218         /**
 219          * This signal is emitted when the AC adapter is plugged or unplugged.
 220          *
 221          * @param newState the new state of the AC adapter, it's one of the
 222          * type @see Solid::Control::PowerManager::AcAdapterState
 223          */
 224         void acAdapterStateChanged(int newState);
 225
 226         /**
 227          * This signal is emitted when the system battery state changed.
 228          *
 229          * @param newState the new state of the system battery, it's one of the
 230          * type @see Solid::Control::PowerManager::BatteryState
 231          */
 232         void batteryStateChanged(int newState);
 233
 234         /**
 235          * This signal is emitted when a button has been pressed.
 236          *
 237          * @param buttonType the pressed button type, it's one of the
 238          * type @see Solid::Control::PowerManager::ButtonType
 239          */
 240         void buttonPressed(int buttonType);
 241
 242         /**
 243          * This signal is emitted when the brightness changes.
 244          *
 245          * @param brightness the new brightness level
 246          */
 247         void brightnessChanged(float brightness);
 248
 249         /**
 250          * This signal is emitted when the estimated battery remaining time changes.
 251          *
 252          * @param brightness the new remaining time
 253          */
 254         void batteryRemainingTimeChanged(int time);
 255     };
 256 }
 257 }
 258 }
 259
 260 #endif