ui/message_center/notification.h

   1 // Copyright (c) 2013 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_H_
   6 #define UI_MESSAGE_CENTER_NOTIFICATION_H_
   7
   8 #include <string>
   9 #include <vector>
  10
  11 #include "base/strings/string16.h"
  12 #include "base/time/time.h"
  13 #include "base/values.h"
  14 #include "ui/gfx/image/image.h"
  15 #include "ui/message_center/message_center_export.h"
  16 #include "ui/message_center/notification_delegate.h"
  17 #include "ui/message_center/notification_types.h"
  18 #include "ui/message_center/notifier_settings.h"
  19
  20 namespace message_center {
  21
  22 struct MESSAGE_CENTER_EXPORT NotificationItem {
  23   base::string16 title;
  24   base::string16 message;
  25
  26   NotificationItem(const base::string16& title, const base::string16& message);
  27 };
  28
  29 struct MESSAGE_CENTER_EXPORT ButtonInfo {
  30   base::string16 title;
  31   gfx::Image icon;
  32
  33   ButtonInfo(const base::string16& title);
  34 };
  35
  36 class MESSAGE_CENTER_EXPORT RichNotificationData {
  37  public:
  38   RichNotificationData();
  39   RichNotificationData(const RichNotificationData& other);
  40   ~RichNotificationData();
  41
  42   int priority;
  43   bool never_timeout;
  44   base::Time timestamp;
  45   base::string16 context_message;
  46   gfx::Image image;
  47   gfx::Image small_image;
  48   std::vector<NotificationItem> items;
  49   int progress;
  50   std::vector<ButtonInfo> buttons;
  51   bool should_make_spoken_feedback_for_popup_updates;
  52   bool clickable;
  53 };
  54
  55 class MESSAGE_CENTER_EXPORT Notification {
  56  public:
  57   Notification(NotificationType type,
  58                const std::string& id,
  59                const base::string16& title,
  60                const base::string16& message,
  61                const gfx::Image& icon,
  62                const base::string16& display_source,
  63                const NotifierId& notifier_id,
  64                const RichNotificationData& optional_fields,
  65                NotificationDelegate* delegate);
  66
  67   Notification(const Notification& other);
  68   Notification& operator=(const Notification& other);
  69   virtual ~Notification();
  70
  71   // Copies the internal on-memory state from |base|, i.e. shown_as_popup,
  72   // is_read, and never_timeout.
  73   void CopyState(Notification* base);
  74
  75   NotificationType type() const { return type_; }
  76   void set_type(NotificationType type) { type_ = type; }
  77
  78   const std::string& id() const { return id_; }
  79
  80   const base::string16& title() const { return title_; }
  81   void set_title(const base::string16& title) { title_ = title; }
  82
  83   const base::string16& message() const { return message_; }
  84   void set_message(const base::string16& message) { message_ = message; }
  85
  86   // A display string for the source of the notification.
  87   const base::string16& display_source() const { return display_source_; }
  88
  89   const NotifierId& notifier_id() const { return notifier_id_; }
  90
  91   void set_profile_id(const std::string& profile_id) {
  92     notifier_id_.profile_id = profile_id;
  93   }
  94
  95   // Begin unpacked values from optional_fields.
  96   int priority() const { return optional_fields_.priority; }
  97   void set_priority(int priority) { optional_fields_.priority = priority; }
  98
  99   base::Time timestamp() const { return optional_fields_.timestamp; }
 100   void set_timestamp(const base::Time& timestamp) {
 101     optional_fields_.timestamp = timestamp;
 102   }
 103
 104   const base::string16& context_message() const {
 105     return optional_fields_.context_message;
 106   }
 107   void set_context_message(const base::string16& context_message) {
 108     optional_fields_.context_message = context_message;
 109   }
 110
 111   const std::vector<NotificationItem>& items() const {
 112     return optional_fields_.items;
 113   }
 114   void set_items(const std::vector<NotificationItem>& items) {
 115     optional_fields_.items = items;
 116   }
 117
 118   int progress() const { return optional_fields_.progress; }
 119   void set_progress(int progress) { optional_fields_.progress = progress; }
 120   // End unpacked values.
 121
 122   // Images fetched asynchronously.
 123   const gfx::Image& icon() const { return icon_; }
 124   void set_icon(const gfx::Image& icon) { icon_ = icon; }
 125
 126   const gfx::Image& image() const { return optional_fields_.image; }
 127   void set_image(const gfx::Image& image) { optional_fields_.image = image; }
 128
 129   const gfx::Image& small_image() const { return optional_fields_.small_image; }
 130   void set_small_image(const gfx::Image& image) {
 131     optional_fields_.small_image = image;
 132   }
 133
 134   // Buttons, with icons fetched asynchronously.
 135   const std::vector<ButtonInfo>& buttons() const {
 136     return optional_fields_.buttons;
 137   }
 138   void set_buttons(const std::vector<ButtonInfo>& buttons) {
 139     optional_fields_.buttons = buttons;
 140   }
 141   void SetButtonIcon(size_t index, const gfx::Image& icon);
 142
 143   bool shown_as_popup() const { return shown_as_popup_; }
 144   void set_shown_as_popup(bool shown_as_popup) {
 145     shown_as_popup_ = shown_as_popup;
 146   }
 147
 148   // Read status in the message center.
 149   bool IsRead() const;
 150   void set_is_read(bool read) { is_read_ = read; }
 151
 152   // Used to keep the order of notifications with the same timestamp.
 153   // The notification with lesser serial_number is considered 'older'.
 154   unsigned serial_number() { return serial_number_; }
 155
 156   // Marks this explicitly to prevent the timeout dismiss of notification.
 157   // This is used by webkit notifications to keep the existing behavior.
 158   void set_never_timeout(bool never_timeout) {
 159     optional_fields_.never_timeout = never_timeout;
 160   }
 161
 162   bool never_timeout() const { return optional_fields_.never_timeout; }
 163
 164   bool clickable() const { return optional_fields_.clickable; }
 165   void set_clickable(bool clickable) {
 166     optional_fields_.clickable = clickable;
 167   }
 168
 169   NotificationDelegate* delegate() const { return delegate_.get(); }
 170
 171   const RichNotificationData& rich_notification_data() const {
 172     return optional_fields_;
 173   }
 174
 175   // Set the priority to SYSTEM. The system priority user needs to call this
 176   // method explicitly, to avoid setting it accidentally.
 177   void SetSystemPriority();
 178
 179   // Delegate actions.
 180   void Display() const { delegate()->Display(); }
 181   void Error() const { delegate()->Error(); }
 182   bool HasClickedListener() const { return delegate()->HasClickedListener(); }
 183   void Click() const { delegate()->Click(); }
 184   void ButtonClick(int index) const { delegate()->ButtonClick(index); }
 185   void Close(bool by_user) const { delegate()->Close(by_user); }
 186
 187   // Helper method to create a simple system notification. |click_callback|
 188   // will be invoked when the notification is clicked.
 189   static scoped_ptr<Notification> CreateSystemNotification(
 190       const std::string& notification_id,
 191       const base::string16& title,
 192       const base::string16& message,
 193       const gfx::Image& icon,
 194       const std::string& system_component_id,
 195       const base::Closure& click_callback);
 196
 197  protected:
 198   // The type of notification we'd like displayed.
 199   NotificationType type_;
 200
 201   std::string id_;
 202   base::string16 title_;
 203   base::string16 message_;
 204
 205   // Image data for the associated icon, used by Ash when available.
 206   gfx::Image icon_;
 207
 208   // The display string for the source of the notification.  Could be
 209   // the same as origin_url_, or the name of an extension.
 210   base::string16 display_source_;
 211
 212  private:
 213   NotifierId notifier_id_;
 214   unsigned serial_number_;
 215   RichNotificationData optional_fields_;
 216   bool shown_as_popup_;  // True if this has been shown as a popup.
 217   bool is_read_;  // True if this has been seen in the message center.
 218
 219   // A proxy object that allows access back to the JavaScript object that
 220   // represents the notification, for firing events.
 221   scoped_refptr<NotificationDelegate> delegate_;
 222 };
 223
 224 }  // namespace message_center
 225
 226 #endif  // UI_MESSAGE_CENTER_NOTIFICATION_H_