ui/message_center/notification_list.h

   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 #ifndef UI_MESSAGE_CENTER_NOTIFICATION_LIST_H_
   6 #define UI_MESSAGE_CENTER_NOTIFICATION_LIST_H_
   7
   8 #include <list>
   9 #include <set>
  10 #include <string>
  11
  12 #include "base/gtest_prod_util.h"
  13 #include "ui/message_center/message_center_export.h"
  14 #include "ui/message_center/notification_blocker.h"
  15 #include "ui/message_center/notification_types.h"
  16
  17 namespace base {
  18 class DictionaryValue;
  19 class TimeDelta;
  20 }
  21
  22 namespace gfx {
  23 class Image;
  24 }
  25
  26 namespace message_center {
  27
  28 namespace test {
  29 class NotificationListTest;
  30 }
  31
  32 class Notification;
  33 class NotificationDelegate;
  34 struct NotifierId;
  35
  36 // Comparers used to auto-sort the lists of Notifications.
  37 struct MESSAGE_CENTER_EXPORT ComparePriorityTimestampSerial {
  38   bool operator()(Notification* n1, Notification* n2);
  39 };
  40
  41 struct MESSAGE_CENTER_EXPORT CompareTimestampSerial {
  42   bool operator()(Notification* n1, Notification* n2);
  43 };
  44
  45 // A helper class to manage the list of notifications.
  46 class MESSAGE_CENTER_EXPORT NotificationList {
  47  public:
  48   // Auto-sorted set. Matches the order in which Notifications are shown in
  49   // Notification Center.
  50   typedef std::set<Notification*, ComparePriorityTimestampSerial> Notifications;
  51
  52   // Auto-sorted set used to return the Notifications to be shown as popup
  53   // toasts.
  54   typedef std::set<Notification*, CompareTimestampSerial> PopupNotifications;
  55
  56   explicit NotificationList();
  57   virtual ~NotificationList();
  58
  59   // Affects whether or not a message has been "read". Collects the set of
  60   // ids whose state have changed and set to |udpated_ids|. NULL if updated
  61   // ids don't matter.
  62   void SetMessageCenterVisible(bool visible,
  63                                std::set<std::string>* updated_ids);
  64
  65   void AddNotification(scoped_ptr<Notification> notification);
  66
  67   void UpdateNotificationMessage(const std::string& old_id,
  68                                  scoped_ptr<Notification> new_notification);
  69
  70   void RemoveNotification(const std::string& id);
  71
  72   Notifications GetNotificationsByNotifierId(const NotifierId& notifier_id);
  73
  74   // Returns true if the notification exists and was updated.
  75   bool SetNotificationIcon(const std::string& notification_id,
  76                            const gfx::Image& image);
  77
  78   // Returns true if the notification exists and was updated.
  79   bool SetNotificationImage(const std::string& notification_id,
  80                             const gfx::Image& image);
  81
  82   // Returns true if the notification and button exist and were updated.
  83   bool SetNotificationButtonIcon(const std::string& notification_id,
  84                                  int button_index,
  85                                  const gfx::Image& image);
  86
  87   // Returns true if |id| matches a notification in the list and that
  88   // notification's type matches the given type.
  89   bool HasNotificationOfType(const std::string& id,
  90                              const NotificationType type);
  91
  92   // Returns false if the first notification has been shown as a popup (which
  93   // means that all notifications have been shown).
  94   bool HasPopupNotifications(const NotificationBlockers& blockers);
  95
  96   // Returns the recent notifications of the priority higher then LOW,
  97   // that have not been shown as a popup. kMaxVisiblePopupNotifications are
  98   // used to limit the number of notifications for the DEFAULT priority.
  99   // It also stores the list of notification ids which is blocked by |blockers|
 100   // to |blocked_ids|. |blocked_ids| can be NULL if the caller doesn't care
 101   // which notifications are blocked.
 102   PopupNotifications GetPopupNotifications(
 103       const NotificationBlockers& blockers,
 104       std::list<std::string>* blocked_ids);
 105
 106   // Marks a specific popup item as shown. Set |mark_notification_as_read| to
 107   // true in case marking the notification as read too.
 108   void MarkSinglePopupAsShown(const std::string& id,
 109                               bool mark_notification_as_read);
 110
 111   // Marks a specific popup item as displayed.
 112   void MarkSinglePopupAsDisplayed(const std::string& id);
 113
 114   NotificationDelegate* GetNotificationDelegate(const std::string& id);
 115
 116   bool quiet_mode() const { return quiet_mode_; }
 117
 118   // Sets the current quiet mode status to |quiet_mode|.
 119   void SetQuietMode(bool quiet_mode);
 120
 121   // Sets the current quiet mode to true. The quiet mode will expire in the
 122   // specified time-delta from now.
 123   void EnterQuietModeWithExpire(const base::TimeDelta& expires_in);
 124
 125   // Returns the notification with the corresponding id. If not found, returns
 126   // NULL. Notification instance is owned by this list.
 127   Notification* GetNotificationById(const std::string& id);
 128
 129   // Returns all visible notifications, in a (priority-timestamp) order.
 130   // Suitable for rendering notifications in a MessageCenter.
 131   Notifications GetVisibleNotifications(
 132       const NotificationBlockers& blockers) const;
 133   size_t NotificationCount(const NotificationBlockers& blockers) const;
 134   size_t UnreadCount(const NotificationBlockers& blockers) const;
 135
 136   bool is_message_center_visible() const { return message_center_visible_; }
 137
 138  private:
 139   friend class NotificationListTest;
 140   FRIEND_TEST_ALL_PREFIXES(NotificationListTest,
 141                            TestPushingShownNotification);
 142
 143   // Iterates through the list and returns the first notification matching |id|.
 144   Notifications::iterator GetNotification(const std::string& id);
 145
 146   void EraseNotification(Notifications::iterator iter);
 147
 148   void PushNotification(scoped_ptr<Notification> notification);
 149
 150   Notifications notifications_;
 151   bool message_center_visible_;
 152   bool quiet_mode_;
 153
 154   DISALLOW_COPY_AND_ASSIGN(NotificationList);
 155 };
 156
 157 }  // namespace message_center
 158
 159 #endif // UI_MESSAGE_CENTER_NOTIFICATION_LIST_H_