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