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.
5 #ifndef UI_MESSAGE_CENTER_MESSAGE_CENTER_IMPL_H_
6 #define UI_MESSAGE_CENTER_MESSAGE_CENTER_IMPL_H_
11 #include "base/memory/scoped_vector.h"
12 #include "base/memory/weak_ptr.h"
13 #include "base/stl_util.h"
14 #include "base/time/time.h"
15 #include "base/timer/timer.h"
16 #include "ui/message_center/message_center.h"
17 #include "ui/message_center/message_center_observer.h"
18 #include "ui/message_center/message_center_types.h"
19 #include "ui/message_center/notification_blocker.h"
20 #include "ui/message_center/notifier_settings.h"
22 namespace message_center
{
23 class NotificationDelegate
;
24 class MessageCenterImpl
;
28 class PopupTimersController
;
30 // A class that manages timeout behavior for notification popups. One instance
31 // is created per notification popup.
34 // Accepts a notification ID, time until callback, and a reference to the
35 // controller which will be called back. The reference is a weak pointer so
36 // that timers never cause a callback on a destructed object.
37 PopupTimer(const std::string
& id
,
38 base::TimeDelta timeout
,
39 base::WeakPtr
<PopupTimersController
> controller
);
42 // Starts running the timer. Barring a Pause or Reset call, the timer will
43 // call back to |controller| after |timeout| seconds.
46 // Stops the timer, and retains the amount of time that has passed so that on
47 // subsequent calls to Start the timer will continue where it left off.
50 // Stops the timer, and resets the amount of time that has passed so that
51 // calling Start results in a timeout equal to the initial timeout setting.
54 base::TimeDelta
get_timeout() const { return timeout_
; }
57 // Notification ID for which this timer applies.
58 const std::string id_
;
60 // Total time that should pass while active before calling TimerFinished.
61 base::TimeDelta timeout_
;
63 // If paused, the amount of time that passed before pause.
64 base::TimeDelta passed_
;
66 // The time that the timer was last started.
67 base::Time start_time_
;
69 // Callback recipient.
70 base::WeakPtr
<PopupTimersController
> timer_controller_
;
73 scoped_ptr
<base::OneShotTimer
<PopupTimersController
> > timer_
;
75 DISALLOW_COPY_AND_ASSIGN(PopupTimer
);
78 // A class that manages all the timers running for individual notification popup
79 // windows. It supports weak pointers in order to allow safe callbacks when
81 class MESSAGE_CENTER_EXPORT PopupTimersController
82 : public base::SupportsWeakPtr
<PopupTimersController
>,
83 public MessageCenterObserver
{
85 explicit PopupTimersController(MessageCenter
* message_center
);
86 virtual ~PopupTimersController();
88 // MessageCenterObserver implementation.
89 virtual void OnNotificationDisplayed(
90 const std::string
& id
,
91 const DisplaySource source
) OVERRIDE
;
92 virtual void OnNotificationUpdated(const std::string
& id
) OVERRIDE
;
93 virtual void OnNotificationRemoved(const std::string
& id
, bool by_user
)
96 // Callback for each timer when its time is up.
97 virtual void TimerFinished(const std::string
& id
);
99 // Pauses all running timers.
102 // Continues all managed timers.
105 // Removes all managed timers.
108 // Starts a timer (by creating a PopupTimer) for |id|.
109 void StartTimer(const std::string
& id
,
110 const base::TimeDelta
& timeout_in_seconds
);
112 // Stops a single timer, reverts it to a new timeout, and restarts it.
113 void ResetTimer(const std::string
& id
,
114 const base::TimeDelta
& timeout_in_seconds
);
116 // Pauses a single timer, such that it will continue where it left off after a
117 // call to StartAll or StartTimer.
118 void PauseTimer(const std::string
& id
);
120 // Removes and cancels a single popup timer, if it exists.
121 void CancelTimer(const std::string
& id
);
124 // Weak, this class is owned by MessageCenterImpl.
125 MessageCenter
* message_center_
;
127 // The PopupTimerCollection contains all the managed timers by their ID. They
128 // are owned by this class, and deleted by |popup_deleter_| on destructon or
129 // when explicitly cancelled.
130 typedef std::map
<std::string
, PopupTimer
*> PopupTimerCollection
;
131 PopupTimerCollection popup_timers_
;
132 STLValueDeleter
<PopupTimerCollection
> popup_deleter_
;
134 DISALLOW_COPY_AND_ASSIGN(PopupTimersController
);
137 } // namespace internal
139 // The default implementation of MessageCenter.
140 class MessageCenterImpl
: public MessageCenter
,
141 public NotificationBlocker::Observer
,
142 public message_center::NotifierSettingsObserver
{
145 virtual ~MessageCenterImpl();
147 // MessageCenter overrides:
148 virtual void AddObserver(MessageCenterObserver
* observer
) OVERRIDE
;
149 virtual void RemoveObserver(MessageCenterObserver
* observer
) OVERRIDE
;
150 virtual void AddNotificationBlocker(NotificationBlocker
* blocker
) OVERRIDE
;
151 virtual void RemoveNotificationBlocker(NotificationBlocker
* blocker
) OVERRIDE
;
152 virtual void SetVisibility(Visibility visible
) OVERRIDE
;
153 virtual bool IsMessageCenterVisible() const OVERRIDE
;
154 virtual size_t NotificationCount() const OVERRIDE
;
155 virtual size_t UnreadNotificationCount() const OVERRIDE
;
156 virtual bool HasPopupNotifications() const OVERRIDE
;
157 virtual bool IsQuietMode() const OVERRIDE
;
158 virtual bool HasClickedListener(const std::string
& id
) OVERRIDE
;
159 virtual message_center::Notification
* FindVisibleNotificationById(
160 const std::string
& id
) OVERRIDE
;
161 virtual const NotificationList::Notifications
& GetVisibleNotifications()
163 virtual NotificationList::PopupNotifications
GetPopupNotifications() OVERRIDE
;
164 virtual void AddNotification(scoped_ptr
<Notification
> notification
) OVERRIDE
;
165 virtual void UpdateNotification(const std::string
& old_id
,
166 scoped_ptr
<Notification
> new_notification
)
168 virtual void RemoveNotification(const std::string
& id
, bool by_user
) OVERRIDE
;
169 virtual void RemoveAllNotifications(bool by_user
) OVERRIDE
;
170 virtual void RemoveAllVisibleNotifications(bool by_user
) OVERRIDE
;
171 virtual void SetNotificationIcon(const std::string
& notification_id
,
172 const gfx::Image
& image
) OVERRIDE
;
173 virtual void SetNotificationImage(const std::string
& notification_id
,
174 const gfx::Image
& image
) OVERRIDE
;
175 virtual void SetNotificationButtonIcon(const std::string
& notification_id
,
177 const gfx::Image
& image
) OVERRIDE
;
178 virtual void DisableNotificationsByNotifier(
179 const NotifierId
& notifier_id
) OVERRIDE
;
180 virtual void ClickOnNotification(const std::string
& id
) OVERRIDE
;
181 virtual void ClickOnNotificationButton(const std::string
& id
,
182 int button_index
) OVERRIDE
;
183 virtual void MarkSinglePopupAsShown(const std::string
& id
,
184 bool mark_notification_as_read
) OVERRIDE
;
185 virtual void DisplayedNotification(
186 const std::string
& id
,
187 const DisplaySource source
) OVERRIDE
;
188 virtual void SetNotifierSettingsProvider(
189 NotifierSettingsProvider
* provider
) OVERRIDE
;
190 virtual NotifierSettingsProvider
* GetNotifierSettingsProvider() OVERRIDE
;
191 virtual void SetQuietMode(bool in_quiet_mode
) OVERRIDE
;
192 virtual void EnterQuietModeWithExpire(
193 const base::TimeDelta
& expires_in
) OVERRIDE
;
194 virtual void RestartPopupTimers() OVERRIDE
;
195 virtual void PausePopupTimers() OVERRIDE
;
197 // NotificationBlocker::Observer overrides:
198 virtual void OnBlockingStateChanged(NotificationBlocker
* blocker
) OVERRIDE
;
200 // message_center::NotifierSettingsObserver overrides:
201 virtual void UpdateIconImage(const NotifierId
& notifier_id
,
202 const gfx::Image
& icon
) OVERRIDE
;
203 virtual void NotifierGroupChanged() OVERRIDE
;
204 virtual void NotifierEnabledChanged(const NotifierId
& notifier_id
,
205 bool enabled
) OVERRIDE
;
208 virtual void DisableTimersForTest() OVERRIDE
;
211 struct NotificationCache
{
213 ~NotificationCache();
214 void Rebuild(const NotificationList::Notifications
& notifications
);
215 void RecountUnread();
217 NotificationList::Notifications visible_notifications
;
221 void RemoveNotifications(bool by_user
, const NotificationBlockers
& blockers
);
222 void RemoveNotificationsForNotifierId(const NotifierId
& notifier_id
);
224 scoped_ptr
<NotificationList
> notification_list_
;
225 NotificationCache notification_cache_
;
226 ObserverList
<MessageCenterObserver
> observer_list_
;
227 scoped_ptr
<internal::PopupTimersController
> popup_timers_controller_
;
228 scoped_ptr
<base::OneShotTimer
<MessageCenterImpl
> > quiet_mode_timer_
;
229 NotifierSettingsProvider
* settings_provider_
;
230 std::vector
<NotificationBlocker
*> blockers_
;
232 // Queue for the notifications to delay the addition/updates when the message
233 // center is visible.
234 scoped_ptr
<internal::ChangeQueue
> notification_queue_
;
236 DISALLOW_COPY_AND_ASSIGN(MessageCenterImpl
);
239 } // namespace message_center
241 #endif // UI_MESSAGE_CENTER_MESSAGE_CENTER_H_