chromeos: Add PowerManagerClient::GetSwitchStates().

chromeos/dbus/power_manager_client.h

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef CHROMEOS_DBUS_POWER_MANAGER_CLIENT_H_
 #define CHROMEOS_DBUS_POWER_MANAGER_CLIENT_H_
 
 #include <string>
 
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/time/time.h"
 #include "chromeos/chromeos_export.h"
 #include "chromeos/dbus/dbus_client.h"
 #include "chromeos/dbus/dbus_client_implementation_type.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace power_manager {
 class PowerManagementPolicy;
 class PowerSupplyProperties;
 }
 
 namespace chromeos {
 
-// Callback used for getting the current screen brightness.  The param is in the
-// range [0.0, 100.0].
-typedef base::Callback<void(double)> GetScreenBrightnessPercentCallback;
-
-// Callback used for getting the current backlights forced off state.
-typedef base::Callback<void(bool)> GetBacklightsForcedOffCallback;
-
 // PowerManagerClient is used to communicate with the power manager.
 class CHROMEOS_EXPORT PowerManagerClient : public DBusClient {
  public:
+  enum class LidState {
+    OPEN,
+    CLOSED,
+    NOT_PRESENT,
+  };
+
+  enum class TabletMode {
+    ON,
+    OFF,
+    UNSUPPORTED,
+  };
+
+  // Callback used for getting the current screen brightness. The param is in
+  // the range [0.0, 100.0].
+  typedef base::Callback<void(double)> GetScreenBrightnessPercentCallback;
+
+  // Callback passed to GetBacklightsForcedOff().
+  typedef base::Callback<void(bool forced_off)> GetBacklightsForcedOffCallback;
+
+  // Callback passed to GetSwitchStates().
+  typedef base::Callback<void(LidState, TabletMode)> GetSwitchStatesCallback;
+
   // Interface for observing changes from the power manager.
   class Observer {
    public:
     virtual ~Observer() {}
 
     // Called if the power manager process restarts.
     virtual void PowerManagerRestarted() {}
 
     // Called when the brightness is changed.
     // |level| is of the range [0, 100].
@@ skipping 34 matching lines @@
     // finished running and those observers that wish to asynchronously delay
     // the suspend should call PowerManagerClient::GetSuspendReadinessCallback()
     // from within this method.  The returned callback should be run once the
     // observer is ready for suspend.
     virtual void DarkSuspendImminent() {}
 
     // Called when the power button is pressed or released.
     virtual void PowerButtonEventReceived(bool down,
                                           const base::TimeTicks& timestamp) {}
 
-    // Called when the device's lid is opened or closed.
-    virtual void LidEventReceived(bool open,
+    // Called when the device's lid is opened or closed. LidState::NOT_PRESENT
+    // is never passed.
+    virtual void LidEventReceived(LidState state,
                                   const base::TimeTicks& timestamp) {}
 
     // Called when the device's tablet mode switch is on or off.
-    virtual void TabletModeEventReceived(bool on,
+    // TabletMode::UNSUPPORTED is never passed.
+    virtual void TabletModeEventReceived(TabletMode mode,
                                          const base::TimeTicks& timestamp) {}
 
     // Called when the idle action will be performed after
     // |time_until_idle_action|.
     virtual void IdleActionImminent(
         const base::TimeDelta& time_until_idle_action) {}
 
     // Called after IdleActionImminent() when the inactivity timer is reset
     // before the idle action has been performed.
     virtual void IdleActionDeferred() {}
@@ skipping 30 matching lines @@
   virtual void DecreaseScreenBrightness(bool allow_off) = 0;
 
   // Increases the screen brightness.
   virtual void IncreaseScreenBrightness() = 0;
 
   // Set the screen brightness to |percent|, in the range [0.0, 100.0].
   // If |gradual| is true, the transition will be animated.
   virtual void SetScreenBrightnessPercent(double percent, bool gradual) = 0;
 
   // Asynchronously gets the current screen brightness, in the range
-  // [0.0, 100.0].
+  // [0.0, 100.0]. On error (e.g. powerd not running), |callback| will not be
+  // run.
   virtual void GetScreenBrightnessPercent(
       const GetScreenBrightnessPercentCallback& callback) = 0;
 
   // Decreases the keyboard brightness.
   virtual void DecreaseKeyboardBrightness() = 0;
 
   // Increases the keyboard brightness.
   virtual void IncreaseKeyboardBrightness() = 0;
 
   // Requests an updated copy of the power status. Observer::PowerChanged()
@@ skipping 23 matching lines @@
 
   // Tells powerd whether or not we are in a projecting mode.  This is used to
   // adjust idleness thresholds and derived, on this side, from the number of
   // video outputs attached.
   virtual void SetIsProjecting(bool is_projecting) = 0;
 
   // Tells powerd to change the power source to the given ID. An empty string
   // causes powerd to switch to using the battery on devices with type-C ports.
   virtual void SetPowerSource(const std::string& id) = 0;
 
-  // Forces the display and keyboard backlights (if present) to |forced_off|.
+  // Forces the display and (if present) keyboard backlights to |forced_off|.
   virtual void SetBacklightsForcedOff(bool forced_off) = 0;
 
-  // Gets the display and keyboard backlights (if present) forced off state.
+  // Gets the display and (if present) keyboard backlights' forced-off state. On
+  // error (e.g. powerd not running), |callback| will not be run.
   virtual void GetBacklightsForcedOff(
       const GetBacklightsForcedOffCallback& callback) = 0;
 
+  // Asynchronously fetches the current state of various hardware switches (e.g.
+  // the lid switch and the tablet-mode switch). On error (e.g. powerd not
+  // running), |callback| will not be run.
+  virtual void GetSwitchStates(const GetSwitchStatesCallback& callback) = 0;
+
   // Returns a callback that can be called by an observer to report
   // readiness for suspend.  See Observer::SuspendImminent().
   virtual base::Closure GetSuspendReadinessCallback() = 0;
 
   // Returns the number of callbacks returned by GetSuspendReadinessCallback()
   // for the current suspend attempt but not yet called. Used by tests.
   virtual int GetNumPendingSuspendReadinessCallbacks() = 0;
 
   // Creates the instance.
   static PowerManagerClient* Create(DBusClientImplementationType type);
 
   ~PowerManagerClient() override;
 
  protected:
   // Needs to call DBusClient::Init().
   friend class PowerManagerClientTest;
 
   // Create() should be used instead.
   PowerManagerClient();
 
  private:
   DISALLOW_COPY_AND_ASSIGN(PowerManagerClient);
 };
 
 }  // namespace chromeos
 
 #endif  // CHROMEOS_DBUS_POWER_MANAGER_CLIENT_H_