src/chromeos/dbus/power_manager_client.h

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef CHROMEOS_DBUS_POWER_MANAGER_CLIENT_H_
   6 #define CHROMEOS_DBUS_POWER_MANAGER_CLIENT_H_
   7
   8 #include <string>
   9
  10 #include "base/basictypes.h"
  11 #include "base/callback.h"
  12 #include "base/time/time.h"
  13 #include "chromeos/chromeos_export.h"
  14 #include "chromeos/dbus/dbus_client.h"
  15 #include "chromeos/dbus/dbus_client_implementation_type.h"
  16 #include "third_party/cros_system_api/dbus/service_constants.h"
  17
  18 namespace power_manager {
  19 class PowerManagementPolicy;
  20 class PowerSupplyProperties;
  21 }
  22
  23 namespace chromeos {
  24
  25 // Callback used for getting the current screen brightness.  The param is in the
  26 // range [0.0, 100.0].
  27 typedef base::Callback<void(double)> GetScreenBrightnessPercentCallback;
  28
  29 // PowerManagerClient is used to communicate with the power manager.
  30 class CHROMEOS_EXPORT PowerManagerClient : public DBusClient {
  31  public:
  32   // Interface for observing changes from the power manager.
  33   class Observer {
  34    public:
  35     virtual ~Observer() {}
  36
  37     // Called if the power manager process restarts.
  38     virtual void PowerManagerRestarted() {}
  39
  40     // Called when the brightness is changed.
  41     // |level| is of the range [0, 100].
  42     // |user_initiated| is true if the action is initiated by the user.
  43     virtual void BrightnessChanged(int level, bool user_initiated) {}
  44
  45     // Called when peripheral device battery status is received.
  46     // |path| is the sysfs path for the battery of the peripheral device.
  47     // |name| is the human readble name of the device.
  48     // |level| within [0, 100] represents the device battery level and -1
  49     // means an unknown level or device is disconnected.
  50     virtual void PeripheralBatteryStatusReceived(const std::string& path,
  51                                                  const std::string& name,
  52                                                  int level) {}
  53
  54     // Called when updated information about the power supply is available.
  55     // The status is automatically updated periodically, but
  56     // RequestStatusUpdate() can be used to trigger an immediate update.
  57     virtual void PowerChanged(
  58         const power_manager::PowerSupplyProperties& proto) {}
  59
  60     // Called when the system is about to suspend. Suspend is deferred until
  61     // all observers' implementations of this method have finished running.
  62     //
  63     // If an observer wishes to asynchronously delay suspend,
  64     // PowerManagerClient::GetSuspendReadinessCallback() may be called from
  65     // within SuspendImminent().  The returned callback must be called once
  66     // the observer is ready for suspend.
  67     virtual void SuspendImminent() {}
  68
  69     // Called when a suspend attempt (previously announced via
  70     // SuspendImminent()) has completed. The system may not have actually
  71     // suspended (if e.g. the user canceled the suspend attempt).
  72     virtual void SuspendDone(const base::TimeDelta& sleep_duration) {}
  73
  74     // Called when the system is about to resuspend from a dark resume.  Like
  75     // SuspendImminent(), the suspend will be deferred until all observers have
  76     // finished running and those observers that wish to asynchronously delay
  77     // the suspend should call PowerManagerClient::GetSuspendReadinessCallback()
  78     // from within this method.  The returned callback should be run once the
  79     // observer is ready for suspend.
  80     virtual void DarkSuspendImminent() {}
  81
  82     // Called when the power button is pressed or released.
  83     virtual void PowerButtonEventReceived(bool down,
  84                                           const base::TimeTicks& timestamp) {}
  85
  86     // Called when the device's lid is opened or closed.
  87     virtual void LidEventReceived(bool open,
  88                                   const base::TimeTicks& timestamp) {}
  89
  90     // Called when the idle action will be performed after
  91     // |time_until_idle_action|.
  92     virtual void IdleActionImminent(
  93         const base::TimeDelta& time_until_idle_action) {}
  94
  95     // Called after IdleActionImminent() when the inactivity timer is reset
  96     // before the idle action has been performed.
  97     virtual void IdleActionDeferred() {}
  98   };
  99
 100   // Adds and removes the observer.
 101   virtual void AddObserver(Observer* observer) = 0;
 102   virtual void RemoveObserver(Observer* observer) = 0;
 103   virtual bool HasObserver(Observer* observer) = 0;
 104
 105   // Decreases the screen brightness. |allow_off| controls whether or not
 106   // it's allowed to turn off the back light.
 107   virtual void DecreaseScreenBrightness(bool allow_off) = 0;
 108
 109   // Increases the screen brightness.
 110   virtual void IncreaseScreenBrightness() = 0;
 111
 112   // Set the screen brightness to |percent|, in the range [0.0, 100.0].
 113   // If |gradual| is true, the transition will be animated.
 114   virtual void SetScreenBrightnessPercent(double percent, bool gradual) = 0;
 115
 116   // Asynchronously gets the current screen brightness, in the range
 117   // [0.0, 100.0].
 118   virtual void GetScreenBrightnessPercent(
 119       const GetScreenBrightnessPercentCallback& callback) = 0;
 120
 121   // Decreases the keyboard brightness.
 122   virtual void DecreaseKeyboardBrightness() = 0;
 123
 124   // Increases the keyboard brightness.
 125   virtual void IncreaseKeyboardBrightness() = 0;
 126
 127   // Requests an updated copy of the power status. Observer::PowerChanged()
 128   // will be called asynchronously.
 129   virtual void RequestStatusUpdate() = 0;
 130
 131   // Requests suspend of the system.
 132   virtual void RequestSuspend() = 0;
 133
 134   // Requests restart of the system.
 135   virtual void RequestRestart() = 0;
 136
 137   // Requests shutdown of the system.
 138   virtual void RequestShutdown() = 0;
 139
 140   // Notifies the power manager that the user is active (i.e. generating input
 141   // events).
 142   virtual void NotifyUserActivity(power_manager::UserActivityType type) = 0;
 143
 144   // Notifies the power manager that a video is currently playing. It also
 145   // includes whether or not the containing window for the video is fullscreen.
 146   virtual void NotifyVideoActivity(bool is_fullscreen) = 0;
 147
 148   // Tells the power manager to begin using |policy|.
 149   virtual void SetPolicy(
 150       const power_manager::PowerManagementPolicy& policy) = 0;
 151
 152   // Tells powerd whether or not we are in a projecting mode.  This is used to
 153   // adjust idleness thresholds and derived, on this side, from the number of
 154   // video outputs attached.
 155   virtual void SetIsProjecting(bool is_projecting) = 0;
 156
 157   // Returns a callback that can be called by an observer to report
 158   // readiness for suspend.  See Observer::SuspendImminent().
 159   virtual base::Closure GetSuspendReadinessCallback() = 0;
 160
 161   // Returns the number of callbacks returned by GetSuspendReadinessCallback()
 162   // for the current suspend attempt but not yet called. Used by tests.
 163   virtual int GetNumPendingSuspendReadinessCallbacks() = 0;
 164
 165   // Creates the instance.
 166   static PowerManagerClient* Create(DBusClientImplementationType type);
 167
 168   virtual ~PowerManagerClient();
 169
 170  protected:
 171   // Create() should be used instead.
 172   PowerManagerClient();
 173
 174  private:
 175   DISALLOW_COPY_AND_ASSIGN(PowerManagerClient);
 176 };
 177
 178 }  // namespace chromeos
 179
 180 #endif  // CHROMEOS_DBUS_POWER_MANAGER_CLIENT_H_