src/ash/system/session_length_limit/tray_session_length_limit.cc

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