Home | History | Annotate | Download | only in message_center 
      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 "ui/message_center/notification_list.h"
      6 
      7 #include "base/bind.h"
      8 #include "base/logging.h"
      9 #include "base/stl_util.h"
     10 #include "base/time/time.h"
     11 #include "base/values.h"
     12 #include "ui/gfx/image/image.h"
     13 #include "ui/message_center/message_center_style.h"
     14 #include "ui/message_center/notification.h"
     15 #include "ui/message_center/notification_blocker.h"
     16 #include "ui/message_center/notification_types.h"
     17 
     18 namespace message_center {
     19 
     20 namespace {
     21 
     22 bool ShouldShowNotificationAsPopup(
     23     const Notification& notification,
     24     const NotificationBlockers& blockers) {
     25   for (size_t i = 0; i < blockers.size(); ++i) {
     26     if (!blockers[i]->ShouldShowNotificationAsPopup(notification.notifier_id()))
     27       return false;
     28   }
     29   return true;
     30 }
     31 
     32 }  // namespace
     33 
     34 bool ComparePriorityTimestampSerial::operator()(Notification* n1,
     35                                                 Notification* n2) {
     36   if (n1->priority() > n2->priority())  // Higher pri go first.
     37     return true;
     38   if (n1->priority() < n2->priority())
     39     return false;
     40   return CompareTimestampSerial()(n1, n2);
     41 }
     42 
     43 bool CompareTimestampSerial::operator()(Notification* n1, Notification* n2) {
     44   if (n1->timestamp() > n2->timestamp())  // Newer come first.
     45     return true;
     46   if (n1->timestamp() < n2->timestamp())
     47     return false;
     48   if (n1->serial_number() > n2->serial_number())  // Newer come first.
     49     return true;
     50   if (n1->serial_number() < n2->serial_number())
     51     return false;
     52   return false;
     53 }
     54 
     55 NotificationList::NotificationList()
     56     : message_center_visible_(false),
     57       quiet_mode_(false) {
     58 }
     59 
     60 NotificationList::~NotificationList() {
     61   STLDeleteContainerPointers(notifications_.begin(), notifications_.end());
     62 }
     63 
     64 void NotificationList::SetMessageCenterVisible(
     65     bool visible,
     66     std::set<std::string>* updated_ids) {
     67   if (message_center_visible_ == visible)
     68     return;
     69 
     70   message_center_visible_ = visible;
     71 
     72   if (!visible)
     73     return;
     74 
     75   for (Notifications::iterator iter = notifications_.begin();
     76        iter != notifications_.end(); ++iter) {
     77     Notification* notification = *iter;
     78     bool was_popup = notification->shown_as_popup();
     79     bool was_read = notification->IsRead();
     80     if (notification->priority() < SYSTEM_PRIORITY)
     81       notification->set_shown_as_popup(true);
     82     notification->set_is_read(true);
     83     if (updated_ids && !(was_popup && was_read))
     84       updated_ids->insert(notification->id());
     85   }
     86 }
     87 
     88 void NotificationList::AddNotification(scoped_ptr<Notification> notification) {
     89   PushNotification(notification.Pass());
     90 }
     91 
     92 void NotificationList::UpdateNotificationMessage(
     93     const std::string& old_id,
     94     scoped_ptr<Notification> new_notification) {
     95   Notifications::iterator iter = GetNotification(old_id);
     96   if (iter == notifications_.end())
     97     return;
     98 
     99   new_notification->CopyState(*iter);
    100 
    101   // Handles priority promotion. If the notification is already dismissed but
    102   // the updated notification has higher priority, it should re-appear as a
    103   // toast.
    104   if ((*iter)->priority() < new_notification->priority()) {
    105     new_notification->set_is_read(false);
    106     new_notification->set_shown_as_popup(false);
    107   }
    108 
    109   // Do not use EraseNotification and PushNotification, since we don't want to
    110   // change unread counts nor to update is_read/shown_as_popup states.
    111   Notification* old = *iter;
    112   notifications_.erase(iter);
    113   delete old;
    114 
    115   // We really don't want duplicate IDs.
    116   DCHECK(GetNotification(new_notification->id()) == notifications_.end());
    117   notifications_.insert(new_notification.release());
    118 }
    119 
    120 void NotificationList::RemoveNotification(const std::string& id) {
    121   EraseNotification(GetNotification(id));
    122 }
    123 
    124 NotificationList::Notifications NotificationList::GetNotificationsByNotifierId(
    125         const NotifierId& notifier_id) {
    126   Notifications notifications;
    127   for (Notifications::iterator iter = notifications_.begin();
    128        iter != notifications_.end(); ++iter) {
    129     if ((*iter)->notifier_id() == notifier_id)
    130       notifications.insert(*iter);
    131   }
    132   return notifications;
    133 }
    134 
    135 bool NotificationList::SetNotificationIcon(const std::string& notification_id,
    136                                            const gfx::Image& image) {
    137   Notifications::iterator iter = GetNotification(notification_id);
    138   if (iter == notifications_.end())
    139     return false;
    140   (*iter)->set_icon(image);
    141   return true;
    142 }
    143 
    144 bool NotificationList::SetNotificationImage(const std::string& notification_id,
    145                                             const gfx::Image& image) {
    146   Notifications::iterator iter = GetNotification(notification_id);
    147   if (iter == notifications_.end())
    148     return false;
    149   (*iter)->set_image(image);
    150   return true;
    151 }
    152 
    153 bool NotificationList::SetNotificationButtonIcon(
    154     const std::string& notification_id, int button_index,
    155     const gfx::Image& image) {
    156   Notifications::iterator iter = GetNotification(notification_id);
    157   if (iter == notifications_.end())
    158     return false;
    159   (*iter)->SetButtonIcon(button_index, image);
    160   return true;
    161 }
    162 
    163 bool NotificationList::HasNotificationOfType(const std::string& id,
    164                                              const NotificationType type) {
    165   Notifications::iterator iter = GetNotification(id);
    166   if (iter == notifications_.end())
    167     return false;
    168 
    169   return (*iter)->type() == type;
    170 }
    171 
    172 bool NotificationList::HasPopupNotifications(
    173     const NotificationBlockers& blockers) {
    174   for (Notifications::iterator iter = notifications_.begin();
    175        iter != notifications_.end(); ++iter) {
    176     if ((*iter)->priority() < DEFAULT_PRIORITY)
    177       break;
    178     if (!ShouldShowNotificationAsPopup(**iter, blockers))
    179       continue;
    180     if (!(*iter)->shown_as_popup())
    181       return true;
    182   }
    183   return false;
    184 }
    185 
    186 NotificationList::PopupNotifications NotificationList::GetPopupNotifications(
    187     const NotificationBlockers& blockers,
    188     std::list<std::string>* blocked_ids) {
    189   PopupNotifications result;
    190   size_t default_priority_popup_count = 0;
    191 
    192   // Collect notifications that should be shown as popups. Start from oldest.
    193   for (Notifications::const_reverse_iterator iter = notifications_.rbegin();
    194        iter != notifications_.rend(); iter++) {
    195     if ((*iter)->shown_as_popup())
    196       continue;
    197 
    198     // No popups for LOW/MIN priority.
    199     if ((*iter)->priority() < DEFAULT_PRIORITY)
    200       continue;
    201 
    202     if (!ShouldShowNotificationAsPopup(**iter, blockers)) {
    203       if (blocked_ids)
    204         blocked_ids->push_back((*iter)->id());
    205       continue;
    206     }
    207 
    208     // Checking limits. No limits for HIGH/MAX priority. DEFAULT priority
    209     // will return at most kMaxVisiblePopupNotifications entries. If the
    210     // popup entries are more, older entries are used. see crbug.com/165768
    211     if ((*iter)->priority() == DEFAULT_PRIORITY &&
    212         default_priority_popup_count++ >= kMaxVisiblePopupNotifications) {
    213       continue;
    214     }
    215 
    216     result.insert(*iter);
    217   }
    218   return result;
    219 }
    220 
    221 void NotificationList::MarkSinglePopupAsShown(
    222     const std::string& id, bool mark_notification_as_read) {
    223   Notifications::iterator iter = GetNotification(id);
    224   DCHECK(iter != notifications_.end());
    225 
    226   if ((*iter)->shown_as_popup())
    227     return;
    228 
    229   // System notification is marked as shown only when marked as read.
    230   if ((*iter)->priority() != SYSTEM_PRIORITY || mark_notification_as_read)
    231     (*iter)->set_shown_as_popup(true);
    232 
    233   // The popup notification is already marked as read when it's displayed.
    234   // Set the is_read() back to false if necessary.
    235   if (!mark_notification_as_read)
    236     (*iter)->set_is_read(false);
    237 }
    238 
    239 void NotificationList::MarkSinglePopupAsDisplayed(const std::string& id) {
    240   Notifications::iterator iter = GetNotification(id);
    241   if (iter == notifications_.end())
    242     return;
    243 
    244   if ((*iter)->shown_as_popup())
    245     return;
    246 
    247   if (!(*iter)->IsRead())
    248     (*iter)->set_is_read(true);
    249 }
    250 
    251 NotificationDelegate* NotificationList::GetNotificationDelegate(
    252     const std::string& id) {
    253   Notifications::iterator iter = GetNotification(id);
    254   if (iter == notifications_.end())
    255     return NULL;
    256   return (*iter)->delegate();
    257 }
    258 
    259 void NotificationList::SetQuietMode(bool quiet_mode) {
    260   quiet_mode_ = quiet_mode;
    261   if (quiet_mode_) {
    262     for (Notifications::iterator iter = notifications_.begin();
    263          iter != notifications_.end();
    264          ++iter) {
    265       (*iter)->set_shown_as_popup(true);
    266     }
    267   }
    268 }
    269 
    270 Notification* NotificationList::GetNotificationById(const std::string& id) {
    271   Notifications::iterator iter = GetNotification(id);
    272   if (iter != notifications_.end())
    273     return *iter;
    274   return NULL;
    275 }
    276 
    277 NotificationList::Notifications NotificationList::GetVisibleNotifications(
    278     const NotificationBlockers& blockers) const {
    279   Notifications result;
    280   for (Notifications::const_iterator iter = notifications_.begin();
    281        iter != notifications_.end(); ++iter) {
    282     bool should_show = true;
    283     for (size_t i = 0; i < blockers.size(); ++i) {
    284       if (!blockers[i]->ShouldShowNotification((*iter)->notifier_id())) {
    285         should_show = false;
    286         break;
    287       }
    288     }
    289     if (should_show)
    290       result.insert(*iter);
    291   }
    292 
    293   return result;
    294 }
    295 
    296 size_t NotificationList::NotificationCount(
    297     const NotificationBlockers& blockers) const {
    298   return GetVisibleNotifications(blockers).size();
    299 }
    300 
    301 size_t NotificationList::UnreadCount(
    302     const NotificationBlockers& blockers) const {
    303   Notifications notifications = GetVisibleNotifications(blockers);
    304   size_t unread_count = 0;
    305   for (Notifications::const_iterator iter = notifications.begin();
    306        iter != notifications.end(); ++iter) {
    307     if (!(*iter)->IsRead())
    308       ++unread_count;
    309   }
    310   return unread_count;
    311 }
    312 
    313 NotificationList::Notifications::iterator NotificationList::GetNotification(
    314     const std::string& id) {
    315   for (Notifications::iterator iter = notifications_.begin();
    316        iter != notifications_.end(); ++iter) {
    317     if ((*iter)->id() == id)
    318       return iter;
    319   }
    320   return notifications_.end();
    321 }
    322 
    323 void NotificationList::EraseNotification(Notifications::iterator iter) {
    324   delete *iter;
    325   notifications_.erase(iter);
    326 }
    327 
    328 void NotificationList::PushNotification(scoped_ptr<Notification> notification) {
    329   // Ensure that notification.id is unique by erasing any existing
    330   // notification with the same id (shouldn't normally happen).
    331   Notifications::iterator iter = GetNotification(notification->id());
    332   bool state_inherited = false;
    333   if (iter != notifications_.end()) {
    334     notification->CopyState(*iter);
    335     state_inherited = true;
    336     EraseNotification(iter);
    337   }
    338   // Add the notification to the the list and mark it unread and unshown.
    339   if (!state_inherited) {
    340     // TODO(mukai): needs to distinguish if a notification is dismissed by
    341     // the quiet mode or user operation.
    342     notification->set_is_read(false);
    343     notification->set_shown_as_popup(message_center_visible_
    344                                      || quiet_mode_
    345                                      || notification->shown_as_popup());
    346   }
    347   // Take ownership. The notification can only be removed from the list
    348   // in EraseNotification(), which will delete it.
    349   notifications_.insert(notification.release());
    350 }
    351 
    352 }  // namespace message_center
    353