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 #include "chromeos/dbus/power_policy_controller.h"
      6 
      7 #include "base/format_macros.h"
      8 #include "base/logging.h"
      9 #include "base/strings/string_util.h"
     10 #include "base/strings/stringprintf.h"
     11 #include "chromeos/dbus/dbus_thread_manager.h"
     12 
     13 namespace chromeos {
     14 
     15 namespace {
     16 
     17 // Appends a description of |field|, a field within |delays|, a
     18 // power_manager::PowerManagementPolicy::Delays object, to |str|, an
     19 // std::string, if the field is set.  |name| is a char* describing the
     20 // field.
     21 #define APPEND_DELAY(str, delays, field, name)                                 \
     22     {                                                                          \
     23       if (delays.has_##field())                                                \
     24         str += base::StringPrintf(name "=%" PRId64 " ", delays.field());       \
     25     }
     26 
     27 // Appends descriptions of all of the set delays in |delays|, a
     28 // power_manager::PowerManagementPolicy::Delays object, to |str|, an
     29 // std::string.  |prefix| should be a char* containing either "ac" or
     30 // "battery".
     31 #define APPEND_DELAYS(str, delays, prefix)                                     \
     32     {                                                                          \
     33       APPEND_DELAY(str, delays, screen_dim_ms, prefix "_screen_dim_ms");       \
     34       APPEND_DELAY(str, delays, screen_off_ms, prefix "_screen_off_ms");       \
     35       APPEND_DELAY(str, delays, screen_lock_ms, prefix "_screen_lock_ms");     \
     36       APPEND_DELAY(str, delays, idle_warning_ms, prefix "_idle_warning_ms");   \
     37       APPEND_DELAY(str, delays, idle_ms, prefix "_idle_ms");                   \
     38     }
     39 
     40 // Returns the power_manager::PowerManagementPolicy_Action value
     41 // corresponding to |action|.
     42 power_manager::PowerManagementPolicy_Action GetProtoAction(
     43     PowerPolicyController::Action action) {
     44   switch (action) {
     45     case PowerPolicyController::ACTION_SUSPEND:
     46       return power_manager::PowerManagementPolicy_Action_SUSPEND;
     47     case PowerPolicyController::ACTION_STOP_SESSION:
     48       return power_manager::PowerManagementPolicy_Action_STOP_SESSION;
     49     case PowerPolicyController::ACTION_SHUT_DOWN:
     50       return power_manager::PowerManagementPolicy_Action_SHUT_DOWN;
     51     case PowerPolicyController::ACTION_DO_NOTHING:
     52       return power_manager::PowerManagementPolicy_Action_DO_NOTHING;
     53     default:
     54       NOTREACHED() << "Unhandled action " << action;
     55       return power_manager::PowerManagementPolicy_Action_DO_NOTHING;
     56   }
     57 }
     58 
     59 }  // namespace
     60 
     61 const int PowerPolicyController::kScreenLockAfterOffDelayMs = 10000;  // 10 sec.
     62 
     63 // -1 is interpreted as "unset" by powerd, resulting in powerd's default
     64 // delays being used instead.  There are no similarly-interpreted values
     65 // for the other fields, unfortunately (but the constructor-assigned values
     66 // will only reach powerd if Chrome messes up and forgets to override them
     67 // with the pref-assigned values).
     68 PowerPolicyController::PrefValues::PrefValues()
     69     : ac_screen_dim_delay_ms(-1),
     70       ac_screen_off_delay_ms(-1),
     71       ac_screen_lock_delay_ms(-1),
     72       ac_idle_warning_delay_ms(-1),
     73       ac_idle_delay_ms(-1),
     74       battery_screen_dim_delay_ms(-1),
     75       battery_screen_off_delay_ms(-1),
     76       battery_screen_lock_delay_ms(-1),
     77       battery_idle_warning_delay_ms(-1),
     78       battery_idle_delay_ms(-1),
     79       ac_idle_action(ACTION_SUSPEND),
     80       battery_idle_action(ACTION_SUSPEND),
     81       lid_closed_action(ACTION_SUSPEND),
     82       use_audio_activity(true),
     83       use_video_activity(true),
     84       ac_brightness_percent(-1.0),
     85       battery_brightness_percent(-1.0),
     86       allow_screen_wake_locks(true),
     87       enable_auto_screen_lock(false),
     88       presentation_screen_dim_delay_factor(1.0),
     89       user_activity_screen_dim_delay_factor(1.0),
     90       wait_for_initial_user_activity(false) {}
     91 
     92 // static
     93 std::string PowerPolicyController::GetPolicyDebugString(
     94     const power_manager::PowerManagementPolicy& policy) {
     95   std::string str;
     96   if (policy.has_ac_delays())
     97     APPEND_DELAYS(str, policy.ac_delays(), "ac");
     98   if (policy.has_battery_delays())
     99     APPEND_DELAYS(str, policy.battery_delays(), "battery");
    100   if (policy.has_ac_idle_action())
    101     str += base::StringPrintf("ac_idle=%d ", policy.ac_idle_action());
    102   if (policy.has_battery_idle_action())
    103     str += base::StringPrintf("battery_idle=%d ", policy.battery_idle_action());
    104   if (policy.has_lid_closed_action())
    105     str += base::StringPrintf("lid_closed=%d ", policy.lid_closed_action());
    106   if (policy.has_use_audio_activity())
    107     str += base::StringPrintf("use_audio=%d ", policy.use_audio_activity());
    108   if (policy.has_use_video_activity())
    109     str += base::StringPrintf("use_video=%d ", policy.use_audio_activity());
    110   if (policy.has_ac_brightness_percent()) {
    111     str += base::StringPrintf("ac_brightness_percent=%f ",
    112         policy.ac_brightness_percent());
    113   }
    114   if (policy.has_battery_brightness_percent()) {
    115     str += base::StringPrintf("battery_brightness_percent=%f ",
    116         policy.battery_brightness_percent());
    117   }
    118   if (policy.has_presentation_screen_dim_delay_factor()) {
    119     str += base::StringPrintf("presentation_screen_dim_delay_factor=%f ",
    120         policy.presentation_screen_dim_delay_factor());
    121   }
    122   if (policy.has_user_activity_screen_dim_delay_factor()) {
    123     str += base::StringPrintf("user_activity_screen_dim_delay_factor=%f ",
    124         policy.user_activity_screen_dim_delay_factor());
    125   }
    126   if (policy.has_wait_for_initial_user_activity()) {
    127     str += base::StringPrintf("wait_for_initial_user_activity=%d ",
    128         policy.wait_for_initial_user_activity());
    129   }
    130   if (policy.has_reason())
    131     str += base::StringPrintf("reason=\"%s\" ", policy.reason().c_str());
    132   base::TrimWhitespace(str, base::TRIM_TRAILING, &str);
    133   return str;
    134 }
    135 
    136 PowerPolicyController::PowerPolicyController()
    137     : client_(NULL),
    138       prefs_were_set_(false),
    139       honor_screen_wake_locks_(true),
    140       next_wake_lock_id_(1) {
    141 }
    142 
    143 PowerPolicyController::~PowerPolicyController() {
    144   if (client_) {
    145     client_->RemoveObserver(this);
    146     client_ = NULL;
    147   }
    148 }
    149 
    150 void PowerPolicyController::Init(DBusThreadManager* manager) {
    151   client_ = manager->GetPowerManagerClient();
    152   client_->AddObserver(this);
    153 }
    154 
    155 void PowerPolicyController::ApplyPrefs(const PrefValues& values) {
    156   prefs_policy_.Clear();
    157 
    158   power_manager::PowerManagementPolicy::Delays* delays =
    159       prefs_policy_.mutable_ac_delays();
    160   delays->set_screen_dim_ms(values.ac_screen_dim_delay_ms);
    161   delays->set_screen_off_ms(values.ac_screen_off_delay_ms);
    162   delays->set_screen_lock_ms(values.ac_screen_lock_delay_ms);
    163   delays->set_idle_warning_ms(values.ac_idle_warning_delay_ms);
    164   delays->set_idle_ms(values.ac_idle_delay_ms);
    165 
    166   // If auto screen-locking is enabled, ensure that the screen is locked soon
    167   // after it's turned off due to user inactivity.
    168   int64 lock_ms = delays->screen_off_ms() + kScreenLockAfterOffDelayMs;
    169   if (values.enable_auto_screen_lock && delays->screen_off_ms() > 0 &&
    170       (delays->screen_lock_ms() <= 0 || lock_ms < delays->screen_lock_ms()) &&
    171       lock_ms < delays->idle_ms()) {
    172     delays->set_screen_lock_ms(lock_ms);
    173   }
    174 
    175   delays = prefs_policy_.mutable_battery_delays();
    176   delays->set_screen_dim_ms(values.battery_screen_dim_delay_ms);
    177   delays->set_screen_off_ms(values.battery_screen_off_delay_ms);
    178   delays->set_screen_lock_ms(values.battery_screen_lock_delay_ms);
    179   delays->set_idle_warning_ms(values.battery_idle_warning_delay_ms);
    180   delays->set_idle_ms(values.battery_idle_delay_ms);
    181 
    182   lock_ms = delays->screen_off_ms() + kScreenLockAfterOffDelayMs;
    183   if (values.enable_auto_screen_lock && delays->screen_off_ms() > 0 &&
    184       (delays->screen_lock_ms() <= 0 || lock_ms < delays->screen_lock_ms()) &&
    185       lock_ms < delays->idle_ms()) {
    186     delays->set_screen_lock_ms(lock_ms);
    187   }
    188 
    189   prefs_policy_.set_ac_idle_action(GetProtoAction(values.ac_idle_action));
    190   prefs_policy_.set_battery_idle_action(
    191       GetProtoAction(values.battery_idle_action));
    192   prefs_policy_.set_lid_closed_action(GetProtoAction(values.lid_closed_action));
    193   prefs_policy_.set_use_audio_activity(values.use_audio_activity);
    194   prefs_policy_.set_use_video_activity(values.use_video_activity);
    195   if (values.ac_brightness_percent >= 0.0)
    196     prefs_policy_.set_ac_brightness_percent(values.ac_brightness_percent);
    197   if (values.battery_brightness_percent >= 0.0) {
    198     prefs_policy_.set_battery_brightness_percent(
    199         values.battery_brightness_percent);
    200   }
    201   prefs_policy_.set_presentation_screen_dim_delay_factor(
    202       values.presentation_screen_dim_delay_factor);
    203   prefs_policy_.set_user_activity_screen_dim_delay_factor(
    204       values.user_activity_screen_dim_delay_factor);
    205   prefs_policy_.set_wait_for_initial_user_activity(
    206       values.wait_for_initial_user_activity);
    207 
    208   honor_screen_wake_locks_ = values.allow_screen_wake_locks;
    209 
    210   prefs_were_set_ = true;
    211   SendCurrentPolicy();
    212 }
    213 
    214 int PowerPolicyController::AddScreenWakeLock(const std::string& reason) {
    215   int id = next_wake_lock_id_++;
    216   screen_wake_locks_[id] = reason;
    217   SendCurrentPolicy();
    218   return id;
    219 }
    220 
    221 int PowerPolicyController::AddSystemWakeLock(const std::string& reason) {
    222   int id = next_wake_lock_id_++;
    223   system_wake_locks_[id] = reason;
    224   SendCurrentPolicy();
    225   return id;
    226 }
    227 
    228 void PowerPolicyController::RemoveWakeLock(int id) {
    229   if (!screen_wake_locks_.erase(id) && !system_wake_locks_.erase(id))
    230     LOG(WARNING) << "Ignoring request to remove nonexistent wake lock " << id;
    231   else
    232     SendCurrentPolicy();
    233 }
    234 
    235 void PowerPolicyController::PowerManagerRestarted() {
    236   SendCurrentPolicy();
    237 }
    238 
    239 void PowerPolicyController::SendCurrentPolicy() {
    240   std::string reason;
    241 
    242   power_manager::PowerManagementPolicy policy = prefs_policy_;
    243   if (prefs_were_set_)
    244     reason = "Prefs";
    245 
    246   if (honor_screen_wake_locks_ && !screen_wake_locks_.empty()) {
    247     policy.mutable_ac_delays()->set_screen_dim_ms(0);
    248     policy.mutable_ac_delays()->set_screen_off_ms(0);
    249     policy.mutable_ac_delays()->set_screen_lock_ms(0);
    250     policy.mutable_battery_delays()->set_screen_dim_ms(0);
    251     policy.mutable_battery_delays()->set_screen_off_ms(0);
    252     policy.mutable_battery_delays()->set_screen_lock_ms(0);
    253   }
    254 
    255   if (!screen_wake_locks_.empty() || !system_wake_locks_.empty()) {
    256     if (!policy.has_ac_idle_action() || policy.ac_idle_action() ==
    257         power_manager::PowerManagementPolicy_Action_SUSPEND) {
    258       policy.set_ac_idle_action(
    259           power_manager::PowerManagementPolicy_Action_DO_NOTHING);
    260     }
    261     if (!policy.has_battery_idle_action() || policy.battery_idle_action() ==
    262         power_manager::PowerManagementPolicy_Action_SUSPEND) {
    263       policy.set_battery_idle_action(
    264           power_manager::PowerManagementPolicy_Action_DO_NOTHING);
    265     }
    266   }
    267 
    268   for (WakeLockMap::const_iterator it = screen_wake_locks_.begin();
    269        it != screen_wake_locks_.end(); ++it) {
    270     reason += (reason.empty() ? "" : ", ") + it->second;
    271   }
    272   for (WakeLockMap::const_iterator it = system_wake_locks_.begin();
    273        it != system_wake_locks_.end(); ++it) {
    274     reason += (reason.empty() ? "" : ", ") + it->second;
    275   }
    276 
    277   if (!reason.empty())
    278     policy.set_reason(reason);
    279   client_->SetPolicy(policy);
    280 }
    281 
    282 }  // namespace chromeos
    283