Home | History | Annotate | Download | only in dbus 
      1 // Copyright (c) 2013 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_POLICY_CONTROLLER_H_
      6 #define CHROMEOS_DBUS_POWER_POLICY_CONTROLLER_H_
      7 
      8 #include <map>
      9 #include <string>
     10 
     11 #include "base/basictypes.h"
     12 #include "base/compiler_specific.h"
     13 #include "chromeos/chromeos_export.h"
     14 #include "chromeos/dbus/dbus_thread_manager_observer.h"
     15 #include "chromeos/dbus/power_manager/policy.pb.h"
     16 #include "chromeos/dbus/power_manager_client.h"
     17 
     18 namespace chromeos {
     19 
     20 class DBusThreadManager;
     21 
     22 // PowerPolicyController is responsible for sending Chrome's assorted power
     23 // management preferences to the Chrome OS power manager.
     24 class CHROMEOS_EXPORT PowerPolicyController
     25     : public DBusThreadManagerObserver,
     26       public PowerManagerClient::Observer {
     27  public:
     28   // Note: Do not change these values; they are used by preferences.
     29   enum Action {
     30     ACTION_SUSPEND      = 0,
     31     ACTION_STOP_SESSION = 1,
     32     ACTION_SHUT_DOWN    = 2,
     33     ACTION_DO_NOTHING   = 3,
     34   };
     35 
     36   // Values of various power-management-related preferences.
     37   struct PrefValues {
     38     PrefValues();
     39 
     40     int ac_screen_dim_delay_ms;
     41     int ac_screen_off_delay_ms;
     42     int ac_screen_lock_delay_ms;
     43     int ac_idle_warning_delay_ms;
     44     int ac_idle_delay_ms;
     45     int battery_screen_dim_delay_ms;
     46     int battery_screen_off_delay_ms;
     47     int battery_screen_lock_delay_ms;
     48     int battery_idle_warning_delay_ms;
     49     int battery_idle_delay_ms;
     50     Action ac_idle_action;
     51     Action battery_idle_action;
     52     Action lid_closed_action;
     53     bool use_audio_activity;
     54     bool use_video_activity;
     55     double ac_brightness_percent;
     56     double battery_brightness_percent;
     57     bool allow_screen_wake_locks;
     58     bool enable_screen_lock;
     59     double presentation_screen_dim_delay_factor;
     60     double user_activity_screen_dim_delay_factor;
     61     bool wait_for_initial_user_activity;
     62   };
     63 
     64   // Returns a string describing |policy|.  Useful for tests.
     65   static std::string GetPolicyDebugString(
     66       const power_manager::PowerManagementPolicy& policy);
     67 
     68   // Delay in milliseconds between the screen being turned off and the
     69   // screen being locked. Used if the |enable_screen_lock| pref is set but
     70   // |*_screen_lock_delay_ms| are unset or set to higher values than what
     71   // this constant would imply.
     72   static const int kScreenLockAfterOffDelayMs;
     73 
     74   PowerPolicyController();
     75   virtual ~PowerPolicyController();
     76 
     77   void Init(DBusThreadManager* manager);
     78 
     79   // Updates |prefs_policy_| with |values| and sends an updated policy.
     80   void ApplyPrefs(const PrefValues& values);
     81 
     82   // Resets |prefs_policy_| to its defaults and sends an updated policy.
     83   void ClearPrefs();
     84 
     85   // Registers a request to temporarily prevent the screen from getting
     86   // dimmed or turned off or the system from suspending in response to user
     87   // inactivity and sends an updated policy.  |reason| is a human-readable
     88   // description of the reason the lock was created.  Returns a unique ID
     89   // that can be passed to RemoveWakeLock() later.
     90   int AddScreenWakeLock(const std::string& reason);
     91   int AddSystemWakeLock(const std::string& reason);
     92 
     93   // Unregisters a request previously created via AddScreenWakeLock() or
     94   // AddSystemWakeLock() and sends an updated policy.
     95   void RemoveWakeLock(int id);
     96 
     97   // DBusThreadManagerObserver implementation:
     98   virtual void OnDBusThreadManagerDestroying(DBusThreadManager* manager)
     99       OVERRIDE;
    100 
    101   // PowerManagerClient::Observer implementation:
    102   virtual void PowerManagerRestarted() OVERRIDE;
    103 
    104  private:
    105   friend class PowerPrefsTest;
    106 
    107   typedef std::map<int, std::string> WakeLockMap;
    108 
    109   // Sends a policy based on |prefs_policy_| to the power manager.
    110   void SendCurrentPolicy();
    111 
    112   // Sends an empty policy to the power manager to reset its configuration.
    113   void SendEmptyPolicy();
    114 
    115   DBusThreadManager* manager_;  // not owned
    116   PowerManagerClient* client_;  // not owned
    117 
    118   // Policy derived from values passed to ApplyPrefs().
    119   power_manager::PowerManagementPolicy prefs_policy_;
    120 
    121   // Was ApplyPrefs() called?
    122   bool prefs_were_set_;
    123 
    124   // Maps from an ID representing a request to prevent the screen from
    125   // getting dimmed or turned off or to prevent the system from suspending
    126   // to the reason for the request.
    127   WakeLockMap screen_wake_locks_;
    128   WakeLockMap system_wake_locks_;
    129 
    130   // Should entries in |screen_wake_locks_| be honored?  If false, screen
    131   // wake locks are just treated as system wake locks instead.
    132   bool honor_screen_wake_locks_;
    133 
    134   // Next ID to be used by AddScreenWakeLock() or AddSystemWakeLock().
    135   int next_wake_lock_id_;
    136 
    137   DISALLOW_COPY_AND_ASSIGN(PowerPolicyController);
    138 };
    139 
    140 }  // namespace chromeos
    141 
    142 #endif  // CHROMEOS_DBUS_POWER_POLICY_CONTROLLER_H_
    143