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 #include "ash/system/session_length_limit/tray_session_length_limit.h" 6 7 #include <algorithm> 8 9 #include "ash/shelf/shelf_types.h" 10 #include "ash/shell.h" 11 #include "ash/system/tray/system_tray.h" 12 #include "ash/system/tray/system_tray_delegate.h" 13 #include "ash/system/tray/system_tray_notifier.h" 14 #include "ash/system/tray/tray_constants.h" 15 #include "ash/system/tray/tray_notification_view.h" 16 #include "ash/system/tray/tray_utils.h" 17 #include "base/location.h" 18 #include "base/logging.h" 19 #include "base/strings/string16.h" 20 #include "base/strings/string_number_conversions.h" 21 #include "base/strings/utf_string_conversions.h" 22 #include "grit/ash_resources.h" 23 #include "grit/ash_strings.h" 24 #include "third_party/skia/include/core/SkColor.h" 25 #include "ui/base/l10n/l10n_util.h" 26 #include "ui/gfx/font.h" 27 #include "ui/gfx/text_constants.h" 28 #include "ui/views/border.h" 29 #include "ui/views/controls/label.h" 30 #include "ui/views/layout/box_layout.h" 31 #include "ui/views/layout/grid_layout.h" 32 #include "ui/views/view.h" 33 34 namespace ash { 35 namespace internal { 36 37 namespace { 38 39 // If the remaining session time falls below this threshold, the user should be 40 // informed that the session is about to expire. 41 const int kExpiringSoonThresholdInSeconds = 5 * 60; // 5 minutes. 42 43 // Color in which the remaining session time is normally shown. 44 const SkColor kRemainingTimeColor = SK_ColorWHITE; 45 // Color in which the remaining session time is shown when it is expiring soon. 46 const SkColor kRemainingTimeExpiringSoonColor = SK_ColorRED; 47 48 views::Label* CreateAndSetupLabel() { 49 views::Label* label = new views::Label; 50 label->SetHorizontalAlignment(gfx::ALIGN_LEFT); 51 SetupLabelForTray(label); 52 gfx::Font font = label->font(); 53 label->SetFont(font.DeriveFont(0, font.GetStyle() & ~gfx::Font::BOLD)); 54 return label; 55 } 56 57 base::string16 IntToTwoDigitString(int value) { 58 DCHECK_GE(value, 0); 59 DCHECK_LE(value, 99); 60 if (value < 10) 61 return ASCIIToUTF16("0") + base::IntToString16(value); 62 return base::IntToString16(value); 63 } 64 65 base::string16 FormatRemainingSessionTimeNotification( 66 const base::TimeDelta& remaining_session_time) { 67 return l10n_util::GetStringFUTF16( 68 IDS_ASH_STATUS_TRAY_REMAINING_SESSION_TIME_NOTIFICATION, 69 Shell::GetInstance()->system_tray_delegate()-> 70 FormatTimeDuration(remaining_session_time)); 71 } 72 73 } // namespace 74 75 namespace tray { 76 77 class RemainingSessionTimeNotificationView : public TrayNotificationView { 78 public: 79 explicit RemainingSessionTimeNotificationView(TraySessionLengthLimit* owner); 80 virtual ~RemainingSessionTimeNotificationView(); 81 82 // TrayNotificationView: 83 virtual void ChildPreferredSizeChanged(views::View* child) OVERRIDE; 84 85 void Update(); 86 87 private: 88 views::Label* label_; 89 90 DISALLOW_COPY_AND_ASSIGN(RemainingSessionTimeNotificationView); 91 }; 92 93 class RemainingSessionTimeTrayView : public views::View { 94 public: 95 RemainingSessionTimeTrayView(const TraySessionLengthLimit* owner, 96 ShelfAlignment shelf_alignment); 97 virtual ~RemainingSessionTimeTrayView(); 98 99 void UpdateClockLayout(ShelfAlignment shelf_alignment); 100 void Update(); 101 102 private: 103 void SetBorder(ShelfAlignment shelf_alignment); 104 105 const TraySessionLengthLimit* owner_; 106 107 views::Label* horizontal_layout_label_; 108 views::Label* vertical_layout_label_hours_left_; 109 views::Label* vertical_layout_label_hours_right_; 110 views::Label* vertical_layout_label_minutes_left_; 111 views::Label* vertical_layout_label_minutes_right_; 112 views::Label* vertical_layout_label_seconds_left_; 113 views::Label* vertical_layout_label_seconds_right_; 114 115 DISALLOW_COPY_AND_ASSIGN(RemainingSessionTimeTrayView); 116 }; 117 118 RemainingSessionTimeNotificationView::RemainingSessionTimeNotificationView( 119 TraySessionLengthLimit* owner) 120 : TrayNotificationView(owner, 121 IDR_AURA_UBER_TRAY_SESSION_LENGTH_LIMIT_TIMER) { 122 label_ = new views::Label; 123 label_->SetHorizontalAlignment(gfx::ALIGN_LEFT); 124 label_->SetMultiLine(true); 125 Update(); 126 InitView(label_); 127 } 128 129 RemainingSessionTimeNotificationView::~RemainingSessionTimeNotificationView() { 130 } 131 132 void RemainingSessionTimeNotificationView::ChildPreferredSizeChanged( 133 views::View* child) { 134 PreferredSizeChanged(); 135 } 136 137 void RemainingSessionTimeNotificationView::Update() { 138 label_->SetText(FormatRemainingSessionTimeNotification( 139 reinterpret_cast<TraySessionLengthLimit*>(owner())-> 140 GetRemainingSessionTime())); 141 } 142 143 RemainingSessionTimeTrayView::RemainingSessionTimeTrayView( 144 const TraySessionLengthLimit* owner, 145 ShelfAlignment shelf_alignment) 146 : owner_(owner), 147 horizontal_layout_label_(NULL), 148 vertical_layout_label_hours_left_(NULL), 149 vertical_layout_label_hours_right_(NULL), 150 vertical_layout_label_minutes_left_(NULL), 151 vertical_layout_label_minutes_right_(NULL), 152 vertical_layout_label_seconds_left_(NULL), 153 vertical_layout_label_seconds_right_(NULL) { 154 UpdateClockLayout(shelf_alignment); 155 } 156 157 RemainingSessionTimeTrayView::~RemainingSessionTimeTrayView() { 158 } 159 160 void RemainingSessionTimeTrayView::UpdateClockLayout( 161 ShelfAlignment shelf_alignment) { 162 SetBorder(shelf_alignment); 163 const bool horizontal_layout = (shelf_alignment == SHELF_ALIGNMENT_BOTTOM || 164 shelf_alignment == SHELF_ALIGNMENT_TOP); 165 if (horizontal_layout && !horizontal_layout_label_) { 166 // Remove labels used for vertical layout. 167 RemoveAllChildViews(true); 168 vertical_layout_label_hours_left_ = NULL; 169 vertical_layout_label_hours_right_ = NULL; 170 vertical_layout_label_minutes_left_ = NULL; 171 vertical_layout_label_minutes_right_ = NULL; 172 vertical_layout_label_seconds_left_ = NULL; 173 vertical_layout_label_seconds_right_ = NULL; 174 175 // Create label used for horizontal layout. 176 horizontal_layout_label_ = CreateAndSetupLabel(); 177 178 // Construct layout. 179 SetLayoutManager( 180 new views::BoxLayout(views::BoxLayout::kHorizontal, 0, 0, 0)); 181 AddChildView(horizontal_layout_label_); 182 183 } else if (!horizontal_layout && horizontal_layout_label_) { 184 // Remove label used for horizontal layout. 185 RemoveAllChildViews(true); 186 horizontal_layout_label_ = NULL; 187 188 // Create labels used for vertical layout. 189 vertical_layout_label_hours_left_ = CreateAndSetupLabel(); 190 vertical_layout_label_hours_right_ = CreateAndSetupLabel(); 191 vertical_layout_label_minutes_left_ = CreateAndSetupLabel(); 192 vertical_layout_label_minutes_right_ = CreateAndSetupLabel(); 193 vertical_layout_label_seconds_left_ = CreateAndSetupLabel(); 194 vertical_layout_label_seconds_right_ = CreateAndSetupLabel(); 195 196 // Construct layout. 197 views::GridLayout* layout = new views::GridLayout(this); 198 SetLayoutManager(layout); 199 views::ColumnSet* columns = layout->AddColumnSet(0); 200 columns->AddPaddingColumn(0, 6); 201 columns->AddColumn(views::GridLayout::CENTER, views::GridLayout::CENTER, 202 0, views::GridLayout::USE_PREF, 0, 0); 203 columns->AddColumn(views::GridLayout::CENTER, views::GridLayout::CENTER, 204 0, views::GridLayout::USE_PREF, 0, 0); 205 layout->AddPaddingRow(0, kTrayLabelItemVerticalPaddingVeriticalAlignment); 206 layout->StartRow(0, 0); 207 layout->AddView(vertical_layout_label_hours_left_); 208 layout->AddView(vertical_layout_label_hours_right_); 209 layout->StartRow(0, 0); 210 layout->AddView(vertical_layout_label_minutes_left_); 211 layout->AddView(vertical_layout_label_minutes_right_); 212 layout->StartRow(0, 0); 213 layout->AddView(vertical_layout_label_seconds_left_); 214 layout->AddView(vertical_layout_label_seconds_right_); 215 layout->AddPaddingRow(0, kTrayLabelItemVerticalPaddingVeriticalAlignment); 216 } 217 Update(); 218 } 219 220 void RemainingSessionTimeTrayView::Update() { 221 const TraySessionLengthLimit::LimitState limit_state = 222 owner_->GetLimitState(); 223 224 if (limit_state == TraySessionLengthLimit::LIMIT_NONE) { 225 SetVisible(false); 226 return; 227 } 228 229 int seconds = owner_->GetRemainingSessionTime().InSeconds(); 230 // If the remaining session time is 100 hours or more, show 99:59:59 instead. 231 seconds = std::min(seconds, 100 * 60 * 60 - 1); // 100 hours - 1 second. 232 int minutes = seconds / 60; 233 seconds %= 60; 234 const int hours = minutes / 60; 235 minutes %= 60; 236 237 const base::string16 hours_str = IntToTwoDigitString(hours); 238 const base::string16 minutes_str = IntToTwoDigitString(minutes); 239 const base::string16 seconds_str = IntToTwoDigitString(seconds); 240 const SkColor color = 241 limit_state == TraySessionLengthLimit::LIMIT_EXPIRING_SOON ? 242 kRemainingTimeExpiringSoonColor : kRemainingTimeColor; 243 244 if (horizontal_layout_label_) { 245 horizontal_layout_label_->SetText(l10n_util::GetStringFUTF16( 246 IDS_ASH_STATUS_TRAY_REMAINING_SESSION_TIME, 247 hours_str, minutes_str, seconds_str)); 248 horizontal_layout_label_->SetEnabledColor(color); 249 } else if (vertical_layout_label_hours_left_) { 250 vertical_layout_label_hours_left_->SetText(hours_str.substr(0, 1)); 251 vertical_layout_label_hours_right_->SetText(hours_str.substr(1, 1)); 252 vertical_layout_label_minutes_left_->SetText(minutes_str.substr(0, 1)); 253 vertical_layout_label_minutes_right_->SetText(minutes_str.substr(1, 1)); 254 vertical_layout_label_seconds_left_->SetText(seconds_str.substr(0, 1)); 255 vertical_layout_label_seconds_right_->SetText(seconds_str.substr(1, 1)); 256 vertical_layout_label_hours_left_->SetEnabledColor(color); 257 vertical_layout_label_hours_right_->SetEnabledColor(color); 258 vertical_layout_label_minutes_left_->SetEnabledColor(color); 259 vertical_layout_label_minutes_right_->SetEnabledColor(color); 260 vertical_layout_label_seconds_left_->SetEnabledColor(color); 261 vertical_layout_label_seconds_right_->SetEnabledColor(color); 262 } 263 264 Layout(); 265 SetVisible(true); 266 } 267 268 void RemainingSessionTimeTrayView::SetBorder(ShelfAlignment shelf_alignment) { 269 if (shelf_alignment == SHELF_ALIGNMENT_BOTTOM || 270 shelf_alignment == SHELF_ALIGNMENT_TOP) { 271 set_border(views::Border::CreateEmptyBorder( 272 0, kTrayLabelItemHorizontalPaddingBottomAlignment, 273 0, kTrayLabelItemHorizontalPaddingBottomAlignment)); 274 } else { 275 set_border(NULL); 276 } 277 } 278 279 } // namespace tray 280 281 TraySessionLengthLimit::TraySessionLengthLimit(SystemTray* system_tray) 282 : SystemTrayItem(system_tray), 283 tray_view_(NULL), 284 notification_view_(NULL), 285 limit_state_(LIMIT_NONE) { 286 Shell::GetInstance()->system_tray_notifier()-> 287 AddSessionLengthLimitObserver(this); 288 Update(); 289 } 290 291 TraySessionLengthLimit::~TraySessionLengthLimit() { 292 Shell::GetInstance()->system_tray_notifier()-> 293 RemoveSessionLengthLimitObserver(this); 294 } 295 296 views::View* TraySessionLengthLimit::CreateTrayView(user::LoginStatus status) { 297 CHECK(tray_view_ == NULL); 298 tray_view_ = new tray::RemainingSessionTimeTrayView( 299 this, system_tray()->shelf_alignment()); 300 return tray_view_; 301 } 302 303 views::View* TraySessionLengthLimit::CreateNotificationView( 304 user::LoginStatus status) { 305 CHECK(notification_view_ == NULL); 306 notification_view_ = new tray::RemainingSessionTimeNotificationView(this); 307 return notification_view_; 308 } 309 310 void TraySessionLengthLimit::DestroyTrayView() { 311 tray_view_ = NULL; 312 } 313 314 void TraySessionLengthLimit::DestroyNotificationView() { 315 notification_view_ = NULL; 316 } 317 318 void TraySessionLengthLimit::UpdateAfterShelfAlignmentChange( 319 ShelfAlignment alignment) { 320 if (tray_view_) 321 tray_view_->UpdateClockLayout(alignment); 322 } 323 324 void TraySessionLengthLimit::OnSessionStartTimeChanged() { 325 Update(); 326 } 327 328 void TraySessionLengthLimit::OnSessionLengthLimitChanged() { 329 Update(); 330 } 331 332 TraySessionLengthLimit::LimitState 333 TraySessionLengthLimit::GetLimitState() const { 334 return limit_state_; 335 } 336 337 base::TimeDelta TraySessionLengthLimit::GetRemainingSessionTime() const { 338 return remaining_session_time_; 339 } 340 341 void TraySessionLengthLimit::ShowAndSpeakNotification() { 342 ShowNotificationView(); 343 Shell::GetInstance()->system_tray_delegate()->MaybeSpeak(UTF16ToUTF8( 344 FormatRemainingSessionTimeNotification(remaining_session_time_))); 345 } 346 347 void TraySessionLengthLimit::Update() { 348 SystemTrayDelegate* delegate = Shell::GetInstance()->system_tray_delegate(); 349 const LimitState previous_limit_state = limit_state_; 350 if (!delegate->GetSessionStartTime(&session_start_time_) || 351 !delegate->GetSessionLengthLimit(&limit_)) { 352 remaining_session_time_ = base::TimeDelta(); 353 limit_state_ = LIMIT_NONE; 354 timer_.reset(); 355 } else { 356 remaining_session_time_ = std::max( 357 limit_ - (base::TimeTicks::Now() - session_start_time_), 358 base::TimeDelta()); 359 limit_state_ = remaining_session_time_.InSeconds() <= 360 kExpiringSoonThresholdInSeconds ? LIMIT_EXPIRING_SOON : LIMIT_SET; 361 if (!timer_) 362 timer_.reset(new base::RepeatingTimer<TraySessionLengthLimit>); 363 if (!timer_->IsRunning()) { 364 // Start a timer that will update the remaining session time every second. 365 timer_->Start(FROM_HERE, 366 base::TimeDelta::FromSeconds(1), 367 this, 368 &TraySessionLengthLimit::Update); 369 } 370 } 371 372 if (notification_view_) 373 notification_view_->Update(); 374 375 switch (limit_state_) { 376 case LIMIT_NONE: 377 HideNotificationView(); 378 break; 379 case LIMIT_SET: 380 if (previous_limit_state == LIMIT_NONE) 381 ShowAndSpeakNotification(); 382 break; 383 case LIMIT_EXPIRING_SOON: 384 if (previous_limit_state == LIMIT_NONE || 385 previous_limit_state == LIMIT_SET) { 386 ShowAndSpeakNotification(); 387 } 388 break; 389 } 390 391 // Update the tray view last so that it can check whether the notification 392 // view is currently visible or not. 393 if (tray_view_) 394 tray_view_->Update(); 395 } 396 397 } // namespace internal 398 } // namespace ash 399