summaryrefslogtreecommitdiffstats
path: root/toolkit/components/alerts/nsIAlertsService.idl
blob: de1f78bbab9a5784c274d2515b54c616ba961b98 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "nsISupports.idl"
#include "nsIObserver.idl"

interface imgIRequest;
interface nsICancelable;
interface nsIPrincipal;
interface nsIURI;

%{C++
#define ALERT_NOTIFICATION_CONTRACTID "@mozilla.org/alert-notification;1"
%}

[scriptable, uuid(a71a637d-de1d-47c6-a8d2-c60b2596f471)]
interface nsIAlertNotificationImageListener : nsISupports
{
  /**
   * Called when the image finishes loading.
   *
   * @param aUserData An opaque parameter passed to |loadImage|.
   * @param aRequest  The image request.
   */
  void onImageReady(in nsISupports aUserData, in imgIRequest aRequest);

  /**
   * Called if the alert doesn't have an image, or if the image request times
   * out or fails.
   *
   * @param aUserData An opaque parameter passed to |loadImage|.
   */
  void onImageMissing(in nsISupports aUserData);
};

[scriptable, uuid(a054c2c9-2787-4686-859c-45609d790056)]
interface nsIAlertAction : nsISupports
{
  /**
   * Returns a string identifying a user action to be displayed on the alert.
   *
   * This string is an opaque identifier that identifies an action in potential
   * callbacks; it is not displayed to the user.
   */
  readonly attribute AString action;

  /**
   * Returns a string containing action text to be shown to the user.
   */
  readonly attribute AString title;

  /**
   * Returns a string containing the URL of an icon to display with the action.
   */
  readonly attribute AString iconURL;

  /**
   * On Windows, chrome-privileged notifications -- i.e., those with a
   * non-actionable principal -- can have actions that are activated by Windows
   * and not processed by Firefox.  When `windowsSystemActivationType` is true,
   * we request Windows to process `action`.  At the time of writing, Windows
   * recognizes the following actions:
   *
   * - `action="dismiss"` dismisses the alert entirely.
   * - `action="snooze"` snoozes the alert, generally making it disappear before
   *   reappearing a Windows-determined amount of time later.
   *
   * On non-Windows, this field is ignored.
   */
  readonly attribute boolean windowsSystemActivationType;
};

[scriptable, uuid(cf2e4cb6-4b8f-4eca-aea9-d51a8f9f7a50)]
interface nsIAlertNotification : nsISupports
{
  /** Initializes an alert notification. */
  void init([optional] in AString aName,
            [optional] in AString aImageURL,
            [optional] in AString aTitle,
            [optional] in AString aText,
            [optional] in boolean aTextClickable,
            [optional] in AString aCookie,
            [optional] in AString aDir,
            [optional] in AString aLang,
            [optional] in AString aData,
            [optional] in nsIPrincipal aPrincipal,
            [optional] in boolean aInPrivateBrowsing,
            [optional] in boolean aRequireInteraction,
            [optional] in boolean aSilent,
            [optional] in Array<uint32_t> aVibrate);

  /**
   * The name of the notification. On Windows and Android, the name is hashed
   * and used as a notification ID. Notifications will replace previous
   * notifications with the same name.
   */
  readonly attribute AString name;

  /**
   * A URL identifying the image to put in the alert. The OS X backend limits
   * the amount of time it will wait for the image to load to six seconds. After
   * that time, the alert will show without an image.
   */
  readonly attribute AString imageURL;

  /** The title for the alert. */
  readonly attribute AString title;

  /** The contents of the alert. */
  readonly attribute AString text;

  /**
   * Controls the click behavior. If true, the alert listener will be notified
   * when the user clicks on the alert.
   */
  readonly attribute boolean textClickable;

  /**
   * An opaque cookie that will be passed to the alert listener for each
   * callback.
   */
  readonly attribute AString cookie;

  /**
   * Bidi override for the title and contents. Valid values are "auto", "ltr",
   * or "rtl". Ignored if the backend doesn't support localization.
   */
  readonly attribute AString dir;

  /**
   * Language of the title and text. Ignored if the backend doesn't support
   * localization.
   */
  readonly attribute AString lang;

  /**
   * A Base64-encoded structured clone buffer containing data associated with
   * this alert. Only used for web notifications. Chrome callers should use a
   * cookie instead.
   */
  readonly attribute AString data;

  /**
   * The principal of the page that created the alert. Used for IPC security
   * checks, and to determine whether the alert is actionable.
   */
  readonly attribute nsIPrincipal principal;

  /**
   * The URI of the page that created the alert. |null| if the alert is not
   * actionable.
   */
  readonly attribute nsIURI URI;

  /**
   * Controls the image loading behavior. If true, the image request will be
   * loaded anonymously (without cookies or authorization tokens).
   */
  readonly attribute boolean inPrivateBrowsing;

  /**
   * Indicates that the notification should remain readily available until
   * the user activates or dismisses the notification.
   */
  readonly attribute boolean requireInteraction;

  /**
   * When set, indicates that no sounds or vibrations should be made.
   */
  readonly attribute boolean silent;

  /**
   * A vibration pattern to run with the display of the notification. A
   * vibration pattern can be an array with as few as one member. The values
   * are times in milliseconds where the even indices (0, 2, 4, etc.) indicate
   * how long to vibrate and the odd indices indicate how long to pause. For
   * example, [300, 100, 400] would vibrate 300ms, pause 100ms, then vibrate
   * 400ms.
   */
  readonly attribute Array<uint32_t> vibrate;

  /**
   * Actions available for users to choose from for interacting with
   * the notification.
   *
   * Implemented only for the system backend on Windows.
   */
  attribute Array<nsIAlertAction> actions;

  /**
   * Indicates whether this alert should show the source string and action
   * buttons. False for system alerts (which can omit the principal), or
   * expanded, system, and null principals.
   */
  readonly attribute boolean actionable;

  /**
   * The host and port of the originating page, or an empty string if the alert
   * is not actionable.
   */
  readonly attribute AString source;

  /**
   * A URL to navigate to if the application is relaunched in to complete
   * interaction with this alert.
   */
  attribute AString launchURL;

  /**
   * Loads the image associated with this alert.
   *
   * @param aTimeout  The number of milliseconds to wait before cancelling the
   *                  image request. If zero, there is no timeout.
   * @param aListener An |nsIAlertNotificationImageListener| implementation,
   *                  notified when the image loads. The listener is kept alive
   *                  until the request completes.
   * @param aUserData An opaque parameter passed to the listener's methods.
   *                  Not used by the libnotify backend, but the OS X backend
   *                  passes the pending notification.
   */
  nsICancelable loadImage(in unsigned long aTimeout,
                          in nsIAlertNotificationImageListener aListener,
                          [optional] in nsISupports aUserData);
};

[scriptable, uuid(f7a36392-d98b-4141-a7d7-4e46642684e3)]
interface nsIAlertsService : nsISupports
{
  void showPersistentNotification(in AString aPersistentData,
                                  in nsIAlertNotification aAlert,
                                  [optional] in nsIObserver aAlertListener);

  void showAlert(in nsIAlertNotification aAlert,
                 [optional] in nsIObserver aAlertListener);
  /**
   * Initializes and shows an |nsIAlertNotification| with the given parameters.
   *
   * @param aAlertListener Used for callbacks. May be null if the caller
   *                       doesn't care about callbacks.
   * @see nsIAlertNotification for descriptions of all other parameters.
   * @throws NS_ERROR_NOT_AVAILABLE If the notification cannot be displayed.
   *
   * The following arguments will be passed to the alertListener's observe()
   * method:
   *   subject - null
   *   topic   - "alertfinished" when the alert goes away
   *             "alertdisablecallback" when alerts should be disabled for the principal
   *             "alertsettingscallback" when alert settings should be opened
   *             "alertclickcallback" when the text is clicked
   *             "alertshow" when the alert is shown
   *   data    - the value of the cookie parameter passed to showAlertNotification.
   *
   * @note Depending on current circumstances (if the user's in a fullscreen
   *       application, for instance), the alert might not be displayed at all.
   *       In that case, if an alert listener is passed in it will receive the
   *       "alertfinished" notification immediately.
   */
  void showAlertNotification(in AString aImageURL,
                             in AString aTitle,
                             in AString aText,
                             [optional] in boolean aTextClickable,
                             [optional] in AString aCookie,
                             [optional] in nsIObserver aAlertListener,
                             [optional] in AString aName,
                             [optional] in AString aDir,
                             [optional] in AString aLang,
                             [optional] in AString aData,
                             [optional] in nsIPrincipal aPrincipal,
                             [optional] in boolean aInPrivateBrowsing,
                             [optional] in boolean aRequireInteraction);

  /**
   * Close alerts created by the service.
   *
   * @param aName          The name of the notification to close. If no name
   *                       is provided then only a notification created with
   *                       no name (if any) will be closed.
   * @param aContextClosed The notification was implicitly closed, e.g. by tab
   *                       or window closure. This is necessary to track as some
   *                       platforms intentionally leave the notification visible
   *                       unless explicitly closed, e.g. by notification.close().
   */
  void closeAlert([optional] in AString aName, [optional] in boolean aContextClosed);

};

[scriptable, uuid(c5d63e3a-259d-45a8-b964-8377967cb4d2)]
interface nsIAlertsDoNotDisturb : nsISupports
{
  /**
   * Toggles a manual Do Not Disturb mode for the service to reduce the amount
   * of disruption that alerts cause the user.
   * This may mean only displaying them in a notification tray/center or not
   * displaying them at all. If a system backend already supports a similar
   * feature controlled by the user, enabling this may not have any impact on
   * code to show an alert. e.g. on OS X, the system will take care not
   * disrupting a user if we simply create a notification like usual.
   */
  attribute bool manualDoNotDisturb;

  /**
   * Toggles a mode for the service to suppress all notifications from
   * being dispatched when sharing the screen via the getMediaDisplay
   * API.
   */
  attribute bool suppressForScreenSharing;
};

[scriptable, uuid(fc6d7f0a-0cf6-4268-8c71-ab640842b9b1)]
interface nsIAlertsIconData : nsISupports
{
  /**
   * Shows an alert with an icon. Web notifications use the favicon of the
   * page that created the alert. If the favicon is not in the Places database,
   * |aIconSize| will be zero.
  */
  void showAlertWithIconData(in nsIAlertNotification aAlert,
                             [optional] in nsIObserver aAlertListener,
                             [optional] in uint32_t aIconSize,
                             [const, array, size_is(aIconSize)] in uint8_t
                                                                aIconData);
};

[scriptable, uuid(f3c82915-bf60-41ea-91ce-6c46b22e381a)]
interface nsIAlertsIconURI : nsISupports
{
  /**
   * Shows an alert with an icon URI. Web notifications use |moz-anno:|
   * URIs to reference favicons from Places. If the page doesn't have a
   * favicon, |aIconURI| will be |null|.
   */
  void showAlertWithIconURI(in nsIAlertNotification aAlert,
                            [optional] in nsIObserver aAlertListener,
                            [optional] in nsIURI aIconURI);
};