Home | History | Annotate | Download | only in session_length_limit 
      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.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   gfx::Font font = label->font();
     58   label->SetFont(font.DeriveFont(0, font.GetStyle() & ~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 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 SetBorder(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   SetBorder(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::SetBorder(ShelfAlignment shelf_alignment) {
    266   if (shelf_alignment == SHELF_ALIGNMENT_BOTTOM ||
    267       shelf_alignment == SHELF_ALIGNMENT_TOP) {
    268     set_border(views::Border::CreateEmptyBorder(
    269         0, kTrayLabelItemHorizontalPaddingBottomAlignment,
    270         0, kTrayLabelItemHorizontalPaddingBottomAlignment));
    271   } else {
    272     set_border(NULL);
    273   }
    274 }
    275 
    276 }  // namespace tray
    277 
    278 // static
    279 const char TraySessionLengthLimit::kNotificationId[] =
    280     "chrome://session/timeout";
    281 
    282 TraySessionLengthLimit::TraySessionLengthLimit(SystemTray* system_tray)
    283     : SystemTrayItem(system_tray),
    284       tray_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 void TraySessionLengthLimit::DestroyTrayView() {
    304   tray_view_ = NULL;
    305 }
    306 
    307 void TraySessionLengthLimit::UpdateAfterShelfAlignmentChange(
    308     ShelfAlignment alignment) {
    309   if (tray_view_)
    310     tray_view_->UpdateClockLayout(alignment);
    311 }
    312 
    313 void TraySessionLengthLimit::OnSessionStartTimeChanged() {
    314   Update();
    315 }
    316 
    317 void TraySessionLengthLimit::OnSessionLengthLimitChanged() {
    318   Update();
    319 }
    320 
    321 TraySessionLengthLimit::LimitState
    322     TraySessionLengthLimit::GetLimitState() const {
    323   return limit_state_;
    324 }
    325 
    326 base::TimeDelta TraySessionLengthLimit::GetRemainingSessionTime() const {
    327   return remaining_session_time_;
    328 }
    329 
    330 void TraySessionLengthLimit::Update() {
    331   SystemTrayDelegate* delegate = Shell::GetInstance()->system_tray_delegate();
    332   const LimitState previous_limit_state = limit_state_;
    333   if (!delegate->GetSessionStartTime(&session_start_time_) ||
    334       !delegate->GetSessionLengthLimit(&limit_)) {
    335     remaining_session_time_ = base::TimeDelta();
    336     limit_state_ = LIMIT_NONE;
    337     timer_.reset();
    338   } else {
    339     remaining_session_time_ = std::max(
    340         limit_ - (base::TimeTicks::Now() - session_start_time_),
    341         base::TimeDelta());
    342     limit_state_ = remaining_session_time_.InSeconds() <=
    343         kExpiringSoonThresholdInSeconds ? LIMIT_EXPIRING_SOON : LIMIT_SET;
    344     if (!timer_)
    345       timer_.reset(new base::RepeatingTimer<TraySessionLengthLimit>);
    346     if (!timer_->IsRunning()) {
    347       // Start a timer that will update the remaining session time every second.
    348       timer_->Start(FROM_HERE,
    349                     base::TimeDelta::FromSeconds(1),
    350                     this,
    351                     &TraySessionLengthLimit::Update);
    352     }
    353   }
    354 
    355   switch (limit_state_) {
    356     case LIMIT_NONE:
    357       message_center::MessageCenter::Get()->RemoveNotification(
    358           kNotificationId, false /* by_user */);
    359       break;
    360     case LIMIT_SET:
    361       CreateOrUpdateNotification(
    362           kNotificationId,
    363           remaining_session_time_,
    364           previous_limit_state == LIMIT_NONE);
    365       break;
    366     case LIMIT_EXPIRING_SOON:
    367       CreateOrUpdateNotification(
    368           kNotificationId,
    369           remaining_session_time_,
    370           previous_limit_state == LIMIT_NONE ||
    371           previous_limit_state == LIMIT_SET);
    372       break;
    373   }
    374 
    375   // Update the tray view last so that it can check whether the notification
    376   // view is currently visible or not.
    377   if (tray_view_)
    378     tray_view_->Update();
    379 }
    380 
    381 bool TraySessionLengthLimit::IsTrayViewVisibleForTest() {
    382   return tray_view_ && tray_view_->visible();
    383 }
    384 
    385 }  // namespace internal
    386 }  // namespace ash
    387