b38dea0597
Share Gaia assets and adapters, keep private profiles and development documents local, and update both public READMEs.
834 lines
27 KiB
JavaScript
Executable file
834 lines
27 KiB
JavaScript
Executable file
/* global LazyLoader, MediaPlaybackWidget, Service,
|
|
SettingsListener, SettingsURL, toneUpgrader, mozIntl */
|
|
|
|
'use strict';
|
|
|
|
var NotificationScreen = {
|
|
name: 'NotificationScreen',
|
|
TOASTER_TIMEOUT: 3500,
|
|
TRANSITION_FRACTION: 0.30,
|
|
TRANSITION_DURATION: 200,
|
|
SWIPE_INERTIA: 100,
|
|
TAP_THRESHOLD: 10,
|
|
SCROLL_THRESHOLD: 10,
|
|
CLEAR_DELAY: 80,
|
|
|
|
_notification: null,
|
|
_containerWidth: null,
|
|
_touchStartX: 0,
|
|
_touchStartY: 0,
|
|
_touchPosX: 0,
|
|
_touching: false,
|
|
_isTap: false,
|
|
_toasterTimeout: null,
|
|
|
|
lockscreenPreview: true,
|
|
silent: false,
|
|
vibrates: true,
|
|
isResending: false,
|
|
resendReceived: 0,
|
|
resendExpecting: 0,
|
|
|
|
/* These applications' notifications will be added in the "priority"
|
|
* notification group
|
|
*/
|
|
PRIORITY_APPLICATIONS: [
|
|
window.location.origin.replace('system.', 'network-alerts.') +
|
|
'/manifest.webapp'
|
|
],
|
|
|
|
/* These applications' notifications will not be notified, it means we won't
|
|
* have:
|
|
* - the banner
|
|
* - the vibration
|
|
* - the sound
|
|
*/
|
|
SILENT_APPLICATIONS: [
|
|
window.location.origin.replace('system.', 'network-alerts.') +
|
|
'/manifest.webapp'
|
|
],
|
|
|
|
getLockScreenContainer: function ns_getLockScreenContainer() {
|
|
// XXX: Bug 1057198 add this as a workaround before we truly
|
|
// make LockScreen as an app.
|
|
var lw = Service.query('LockScreenWindowManager.getInstance');
|
|
if (lw && lw.getNotificationContainer()) {
|
|
return lw.getNotificationContainer();
|
|
} else {
|
|
return null;
|
|
}
|
|
},
|
|
|
|
start: function() {
|
|
window.addEventListener('mozChromeNotificationEvent', this);
|
|
this.notificationsContainer =
|
|
document.getElementById('notifications-container');
|
|
this.container =
|
|
document.getElementById('desktop-notifications-container');
|
|
this.lockScreenContainer = this.getLockScreenContainer();
|
|
this.toaster = document.getElementById('notification-toaster');
|
|
this.ambientIndicator = document.getElementById('ambient-indicator');
|
|
this.toasterIcon = document.getElementById('toaster-icon');
|
|
this.toasterTitle = document.getElementById('toaster-title');
|
|
this.toasterDetail = document.getElementById('toaster-detail');
|
|
this.clearAllButton = document.getElementById('notification-clear');
|
|
|
|
['tap', 'touchstart', 'touchmove', 'touchend', 'touchcancel', 'wheel'].
|
|
forEach(function(evt) {
|
|
this.container.addEventListener(evt, this);
|
|
this.toaster.addEventListener(evt, this);
|
|
}, this);
|
|
|
|
this.clearAllButton.addEventListener('click', this.clearAll.bind(this));
|
|
|
|
// will hold the count of external contributors to the notification
|
|
// screen
|
|
this.externalNotificationsCount = 0;
|
|
this.unreadNotifications = [];
|
|
|
|
window.addEventListener('utilitytrayshow', this);
|
|
// Since UI expect there is a slight delay for the opened notification.
|
|
window.addEventListener('lockscreen-appclosed', this);
|
|
window.addEventListener('visibilitychange', this);
|
|
window.addEventListener('ftuopen', this);
|
|
window.addEventListener('ftudone', this);
|
|
window.addEventListener('desktop-notification-resend', this);
|
|
|
|
this._sound = 'style/notifications/ringtones/notifier_firefox.opus';
|
|
|
|
// set up the media playback widget, but only if |MediaPlaybackWidget| is
|
|
// defined (we don't define it in tests)
|
|
LazyLoader.load(['js/media_playback.js']).then(function() {
|
|
this.mediaPlaybackWidget = new MediaPlaybackWidget(
|
|
document.getElementById('media-playback-container'),
|
|
{nowPlayingAction: 'openapp'});
|
|
}.bind(this))['catch'](function(err) {
|
|
console.error(err);
|
|
});
|
|
|
|
var self = this;
|
|
SettingsListener.observe('notification.ringtone', '', function(value) {
|
|
LazyLoader.load(['shared/js/settings_url.js']).then(function() {
|
|
if (!self.ringtoneURL) {
|
|
self.ringtoneURL = new SettingsURL();
|
|
}
|
|
self._sound = self.ringtoneURL.set(value);
|
|
})['catch'](function(err) {
|
|
console.error(err);
|
|
});
|
|
});
|
|
|
|
// We have new default ringtones in 2.0, so check if the version is upgraded
|
|
// then execute the necessary migration.
|
|
if (Service.query('justUpgraded')) {
|
|
LazyLoader.load('js/tone_upgrader.js').then(function() {
|
|
toneUpgrader.perform('alerttone');
|
|
})['catch'](function(err) {
|
|
console.error(err);
|
|
});
|
|
}
|
|
Service.register('clearAll', this);
|
|
Service.register('addUnreadNotification', this);
|
|
Service.register('removeUnreadNotification', this);
|
|
|
|
this.resendStoredNotifications();
|
|
},
|
|
|
|
handleEvent: function ns_handleEvent(evt) {
|
|
switch (evt.type) {
|
|
case 'mozChromeNotificationEvent':
|
|
var detail = evt.detail;
|
|
switch (detail.type) {
|
|
case 'desktop-notification':
|
|
this.addNotification(detail);
|
|
if (this.isResending) {
|
|
this.resendReceived++;
|
|
this.isResending = (this.resendReceived < this.resendExpecting);
|
|
}
|
|
break;
|
|
case 'desktop-notification-close':
|
|
this.removeNotification(detail.id);
|
|
break;
|
|
}
|
|
break;
|
|
case 'tap':
|
|
var target = evt.target;
|
|
this.tap(target);
|
|
break;
|
|
case 'touchstart':
|
|
this.touchstart(evt);
|
|
break;
|
|
case 'touchmove':
|
|
this.touchmove(evt);
|
|
break;
|
|
case 'touchend':
|
|
this.touchend(evt);
|
|
break;
|
|
case 'touchcancel':
|
|
this.touchcancel(evt);
|
|
break;
|
|
case 'wheel':
|
|
this.wheel(evt);
|
|
break;
|
|
case 'utilitytrayshow':
|
|
this.updateTimestamps();
|
|
this.hideNotificationIndicator();
|
|
break;
|
|
case 'visibilitychange':
|
|
//update timestamps in lockscreen notifications
|
|
if (!document.hidden) {
|
|
this.updateTimestamps();
|
|
}
|
|
break;
|
|
case 'ftuopen':
|
|
this.toaster.removeEventListener('tap', this);
|
|
break;
|
|
case 'ftudone':
|
|
this.toaster.addEventListener('tap', this);
|
|
this.updateNotificationIndicator();
|
|
break;
|
|
case 'desktop-notification-resend':
|
|
this.resendExpecting = evt.detail.number;
|
|
if (this.resendExpecting) {
|
|
this.isResending = true;
|
|
}
|
|
break;
|
|
case 'lockscreen-appclosed':
|
|
// UX require to delay to clear notifications from
|
|
// LockScreen for the actionable LockScreen notifications.
|
|
setTimeout((function() {
|
|
this.clearLockScreen();
|
|
}).bind(this), 400);
|
|
break;
|
|
}
|
|
},
|
|
|
|
cancelSwipe: function ns_cancelSwipe() {
|
|
var notification = this._notification;
|
|
this._notification = null;
|
|
|
|
// If the notification has been moved, animate it back to its original
|
|
// position.
|
|
if (this._touchPosX) {
|
|
notification.addEventListener('transitionend',
|
|
function trListener() {
|
|
notification.removeEventListener('transitionend', trListener);
|
|
notification.classList.remove('snapback');
|
|
});
|
|
notification.classList.add('snapback');
|
|
}
|
|
|
|
notification.style.transform = '';
|
|
},
|
|
|
|
// Swipe handling
|
|
touchstart: function ns_touchstart(evt) {
|
|
if (evt.touches.length !== 1) {
|
|
if (this._touching) {
|
|
this._touching = false;
|
|
this.cancelSwipe();
|
|
}
|
|
return;
|
|
}
|
|
|
|
var target = evt.touches[0].target;
|
|
if (!target.dataset.notificationId) {
|
|
return;
|
|
}
|
|
|
|
this._notification = target;
|
|
this._containerWidth = this.container.clientWidth;
|
|
this._touchStartX = evt.touches[0].pageX;
|
|
this._touchStartY = evt.touches[0].pageY;
|
|
this._touchPosX = 0;
|
|
this._touchStartTime = evt.timeStamp;
|
|
this._touching = true;
|
|
this._isTap = true;
|
|
},
|
|
|
|
touchmove: function ns_touchmove(evt) {
|
|
if (!this._touching) {
|
|
return;
|
|
}
|
|
|
|
var touchDiffY = evt.touches[0].pageY - this._touchStartY;
|
|
|
|
// The notification being touched is the toast
|
|
if (this._notification.classList.contains('displayed')) {
|
|
if (touchDiffY < 0) {
|
|
this.closeToast();
|
|
}
|
|
return;
|
|
}
|
|
|
|
// Otherwise, we're swiping on a notification, which should only be allowed
|
|
// when the utility tray is fully open.
|
|
if (evt.touches.length !== 1 ||
|
|
!Service.query('UtilityTray.shown') ||
|
|
(this._isTap && Math.abs(touchDiffY) >= this.SCROLL_THRESHOLD)) {
|
|
this._touching = false;
|
|
this.cancelSwipe();
|
|
return;
|
|
}
|
|
|
|
this._touchPosX = evt.touches[0].pageX - this._touchStartX;
|
|
if (Math.abs(this._touchPosX) >= this.TAP_THRESHOLD) {
|
|
this._isTap = false;
|
|
this.notificationsContainer.style.overflow = 'hidden';
|
|
}
|
|
if (!this._isTap) {
|
|
evt.preventDefault();
|
|
evt.stopPropagation(); // Prevent this event from bubbling up to the tray.
|
|
this._notification.style.transform =
|
|
'translateX(' + this._touchPosX + 'px)';
|
|
}
|
|
},
|
|
|
|
touchend: function ns_touchend(evt) {
|
|
if (!this._touching) {
|
|
return;
|
|
}
|
|
|
|
evt.preventDefault();
|
|
this._touching = false;
|
|
|
|
this.notificationsContainer.style.overflow = '';
|
|
|
|
if (this._isTap) {
|
|
var event = new CustomEvent('tap', {
|
|
bubbles: true,
|
|
cancelable: true
|
|
});
|
|
this._notification.dispatchEvent(event);
|
|
this._notification = null;
|
|
return;
|
|
}
|
|
|
|
// Taking speed into account to detect swipes
|
|
var deltaT = evt.timeStamp - this._touchStartTime;
|
|
var speed = this._touchPosX / deltaT;
|
|
var inertia = speed * this.SWIPE_INERTIA;
|
|
var finalDelta = Math.abs(this._touchPosX + inertia);
|
|
|
|
if (finalDelta >
|
|
this._containerWidth * this.TRANSITION_FRACTION) {
|
|
if (this._touchPosX < 0) {
|
|
this._notification.classList.add('left');
|
|
}
|
|
|
|
var durationLeft = (1 - (finalDelta / this._containerWidth)) *
|
|
this.TRANSITION_DURATION;
|
|
this.swipeCloseNotification(durationLeft);
|
|
} else {
|
|
this.cancelSwipe();
|
|
}
|
|
},
|
|
|
|
touchcancel: function ns_touchcancel(evt) {
|
|
if (this._touching) {
|
|
evt.preventDefault();
|
|
this._touching = false;
|
|
this.cancelSwipe();
|
|
}
|
|
},
|
|
|
|
wheel: function ns_wheel(evt) {
|
|
if (evt.deltaMode === evt.DOM_DELTA_PAGE && evt.deltaX) {
|
|
this._notification = evt.target;
|
|
this.swipeCloseNotification();
|
|
}
|
|
},
|
|
|
|
tap: function ns_tap(node) {
|
|
var notificationId = node.dataset.notificationId;
|
|
var notificationNode = this.container.querySelector(
|
|
'[data-notification-id="' + notificationId + '"]');
|
|
|
|
var event = document.createEvent('CustomEvent');
|
|
event.initCustomEvent('mozContentNotificationEvent', true, true, {
|
|
type: 'desktop-notification-click',
|
|
id: notificationId
|
|
});
|
|
window.dispatchEvent(event);
|
|
|
|
window.dispatchEvent(new CustomEvent('notification-clicked', {
|
|
detail: {
|
|
id: notificationId
|
|
}
|
|
}));
|
|
|
|
// Desktop notifications are removed when they are clicked (see bug 890440)
|
|
if (notificationNode &&
|
|
notificationNode.dataset.type === 'desktop-notification' &&
|
|
notificationNode.dataset.obsoleteAPI === 'true') {
|
|
this.closeNotification(notificationNode);
|
|
}
|
|
|
|
if (node == this.toaster) {
|
|
this.closeToast();
|
|
} else {
|
|
Service.request('UtilityTray:hide');
|
|
}
|
|
},
|
|
|
|
updateTimestamps: function ns_updateTimestamps() {
|
|
var timestamps = [...document.querySelectorAll('.timestamp')];
|
|
var formatter = mozIntl._gaia.RelativeDate(navigator.languages, {
|
|
style: 'short'
|
|
});
|
|
|
|
timestamps.forEach(timestamp => {
|
|
formatter.formatElement(
|
|
timestamp, new Date(timestamp.dataset.timestamp));
|
|
});
|
|
},
|
|
|
|
updateToaster: function ns_updateToaster(detail, type, dir) {
|
|
if (detail.icon) {
|
|
this.toasterIcon.src = detail.icon;
|
|
this.toasterIcon.hidden = false;
|
|
} else {
|
|
this.toasterIcon.hidden = true;
|
|
}
|
|
|
|
this.toaster.dataset.notificationId = detail.id;
|
|
this.toaster.dataset.type = type;
|
|
this.toaster.lang = detail.lang;
|
|
|
|
this.toasterTitle.textContent = detail.title;
|
|
this.toasterTitle.dir = dir;
|
|
this.toasterDetail.textContent = detail.text;
|
|
this.toasterDetail.dir = dir;
|
|
},
|
|
|
|
addNotification: function ns_addNotification(detail) {
|
|
// LockScreen window may not opened while this singleton got initialized.
|
|
this.lockScreenContainer = this.getLockScreenContainer();
|
|
|
|
var manifestURL = detail.manifestURL || '';
|
|
var behavior = detail.mozbehavior || {};
|
|
var isPriorityNotification =
|
|
this.PRIORITY_APPLICATIONS.indexOf(manifestURL) !== -1;
|
|
var dir = detail.dir === 'ltr' || detail.dir === 'rtl' ?
|
|
detail.dir : 'auto';
|
|
|
|
var notificationContainer =
|
|
(isPriorityNotification) ?
|
|
this.container.querySelector('.priority-notifications') :
|
|
this.container.querySelector('.other-notifications');
|
|
|
|
// We need to animate the ambient indicator when the toast
|
|
// timesout, so we skip updating it here, by passing a skip bool
|
|
this.addUnreadNotification(detail.id, true);
|
|
|
|
var notificationNode = document.createElement('div');
|
|
notificationNode.classList.add('notification');
|
|
notificationNode.setAttribute('role', 'link');
|
|
notificationNode.setAttribute('tabindex', 0);
|
|
|
|
notificationNode.dataset.notificationId = detail.id;
|
|
notificationNode.dataset.noClear = behavior.noclear ? 'true' : 'false';
|
|
notificationNode.lang = detail.lang;
|
|
|
|
notificationNode.dataset.obsoleteAPI = 'false';
|
|
if (typeof detail.id === 'string' &&
|
|
detail.id.indexOf('app-notif-') === 0) {
|
|
notificationNode.dataset.obsoleteAPI = 'true';
|
|
}
|
|
var type = detail.type || 'desktop-notification';
|
|
notificationNode.dataset.type = type;
|
|
notificationNode.dataset.manifestURL = manifestURL;
|
|
var icon;
|
|
if (detail.icon) {
|
|
icon = document.createElement('img');
|
|
icon.src = detail.icon;
|
|
icon.setAttribute('role', 'presentation');
|
|
notificationNode.appendChild(icon);
|
|
}
|
|
|
|
var titleContainer = document.createElement('div');
|
|
titleContainer.classList.add('title-container');
|
|
|
|
var title = document.createElement('div');
|
|
title.classList.add('title');
|
|
title.textContent = detail.title;
|
|
title.dir = dir;
|
|
|
|
titleContainer.appendChild(title);
|
|
|
|
var time = document.createElement('span');
|
|
var timestamp = detail.timestamp ? new Date(detail.timestamp) : new Date();
|
|
time.classList.add('timestamp');
|
|
time.dataset.timestamp = timestamp;
|
|
var formatter = mozIntl._gaia.RelativeDate(navigator.languages, {
|
|
style: 'short'
|
|
});
|
|
formatter.formatElement(time, timestamp);
|
|
titleContainer.appendChild(time);
|
|
|
|
notificationNode.appendChild(titleContainer);
|
|
|
|
var message = document.createElement('div');
|
|
message.classList.add('detail');
|
|
var messageContent = document.createElement('div');
|
|
messageContent.classList.add('detail-content');
|
|
messageContent.textContent = detail.text;
|
|
messageContent.dir = dir;
|
|
message.appendChild(messageContent);
|
|
notificationNode.appendChild(message);
|
|
|
|
var notifSelector = '[data-notification-id="' + detail.id + '"]';
|
|
var oldNotif = notificationContainer.querySelector(notifSelector);
|
|
if (oldNotif) {
|
|
// The whole node cannot be replaced because CSS animations are re-started
|
|
oldNotif.replaceChild(titleContainer,
|
|
oldNotif.querySelector('.title-container'));
|
|
oldNotif.replaceChild(message, oldNotif.querySelector('.detail'));
|
|
var oldIcon = oldNotif.querySelector('img');
|
|
if (icon) {
|
|
oldIcon ? oldIcon.src = icon.src : oldNotif.insertBefore(icon,
|
|
oldNotif.firstChild);
|
|
} else if (oldIcon) {
|
|
oldNotif.removeChild(oldIcon);
|
|
}
|
|
// but we still need to update type and lang.
|
|
oldNotif.dataset.type = type;
|
|
oldNotif.lang = detail.lang;
|
|
|
|
notificationNode = oldNotif;
|
|
} else {
|
|
notificationContainer.insertBefore(notificationNode,
|
|
notificationContainer.firstElementChild);
|
|
}
|
|
|
|
var event = document.createEvent('CustomEvent');
|
|
event.initCustomEvent('mozContentNotificationEvent', true, true, {
|
|
type: 'desktop-notification-show',
|
|
id: detail.id
|
|
});
|
|
window.dispatchEvent(event);
|
|
|
|
// We turn the screen on if needed in order to let
|
|
// the user see the notification toaster unless we're on a call
|
|
if (!Service.query('screenEnabled') &&
|
|
!behavior.noscreen &&
|
|
!Service.query('onCall') &&
|
|
(!Service.query('locked') || this.lockscreenPreview)) {
|
|
Service.request('turnScreenOn');
|
|
}
|
|
|
|
var notify = !('noNotify' in detail) &&
|
|
// don't notify for network-alerts notifications
|
|
(this.SILENT_APPLICATIONS.indexOf(manifestURL) === -1);
|
|
|
|
// Notification toaster
|
|
if (notify) {
|
|
this.updateToaster(detail, type, dir);
|
|
if (this.lockscreenPreview || !window.Service.query('locked')) {
|
|
this.toaster.classList.add('displayed');
|
|
|
|
if (this._toasterTimeout) {
|
|
clearTimeout(this._toasterTimeout);
|
|
}
|
|
|
|
this._toasterTimeout = setTimeout((function() {
|
|
this.closeToast();
|
|
this._toasterTimeout = null;
|
|
}).bind(this), this.TOASTER_TIMEOUT);
|
|
}
|
|
}
|
|
|
|
// Adding it to the lockscreen if locked and the privacy setting
|
|
// does not prevent it.
|
|
if (Service.query('locked') && this.lockscreenPreview) {
|
|
this.addLockScreenNotification(detail.id,
|
|
notificationNode.cloneNode(true));
|
|
}
|
|
|
|
if (notify && !this.isResending &&
|
|
(!Service.query('locked') || this.lockscreenPreview)) {
|
|
if (!this.silent && !behavior.nosound) {
|
|
var ringtonePlayer = new Audio();
|
|
var telephony = window.navigator.mozTelephony;
|
|
|
|
ringtonePlayer.src = behavior.soundFile || this._sound;
|
|
|
|
if (telephony && telephony.active) {
|
|
ringtonePlayer.mozAudioChannelType = 'telephony';
|
|
ringtonePlayer.volume = 0.3;
|
|
} else {
|
|
ringtonePlayer.mozAudioChannelType = 'notification';
|
|
}
|
|
ringtonePlayer.play();
|
|
window.setTimeout(function smsRingtoneEnder() {
|
|
ringtonePlayer.pause();
|
|
ringtonePlayer.removeAttribute('src');
|
|
ringtonePlayer.load();
|
|
}, 4000);
|
|
}
|
|
|
|
if (this.vibrates && !behavior.novibrate) {
|
|
var pattern = [200, 200, 200];
|
|
if (behavior.vibrationPattern && behavior.vibrationPattern.length &&
|
|
behavior.vibrationPattern[0] > 0) {
|
|
pattern = behavior.vibrationPattern;
|
|
}
|
|
|
|
// bug 1030310: disable vibration for the email app when asleep
|
|
// bug 1050023: disable vibration for downloads when asleep
|
|
var vibrateWhenAsleep =
|
|
type.indexOf('download-notification-downloading') === -1 &&
|
|
manifestURL.indexOf('email.gaiamobile.org') === -1;
|
|
|
|
if (vibrateWhenAsleep || !document.hidden) {
|
|
navigator.vibrate(pattern);
|
|
}
|
|
}
|
|
}
|
|
|
|
// must be at least one notification now
|
|
this.clearAllButton.disabled = false;
|
|
|
|
return notificationNode;
|
|
},
|
|
|
|
/**
|
|
* Give a notification node and add it to LockScreen via event.
|
|
*/
|
|
addLockScreenNotification: function ns_addLockScreenNotification(id, node) {
|
|
window.dispatchEvent(
|
|
new window.CustomEvent('lockscreen-notification-request-append', { detail:
|
|
{
|
|
id: id,
|
|
node: node
|
|
}
|
|
}));
|
|
},
|
|
|
|
swipeCloseNotification: function ns_swipeCloseNotification(duration) {
|
|
var notification = this._notification;
|
|
this._notification = null;
|
|
|
|
var toaster = this.toaster;
|
|
var self = this;
|
|
notification.addEventListener('transitionend', function trListener() {
|
|
notification.removeEventListener('transitionend', trListener);
|
|
|
|
self.closeNotification(notification);
|
|
|
|
if (notification != toaster) {
|
|
return;
|
|
}
|
|
|
|
// Putting back the toaster in a clean state for the next notification
|
|
toaster.style.display = 'none';
|
|
setTimeout(function nextLoop() {
|
|
toaster.style.MozTransition = '';
|
|
toaster.style.MozTransform = '';
|
|
toaster.classList.remove('displayed');
|
|
toaster.classList.remove('disappearing');
|
|
|
|
setTimeout(function nextLoop() {
|
|
toaster.style.display = 'block';
|
|
});
|
|
});
|
|
});
|
|
|
|
notification.classList.add('disappearing');
|
|
duration = duration || this.TRANSITION_DURATION;
|
|
notification.style.transitionDuration = duration + 'ms';
|
|
notification.style.transform = '';
|
|
},
|
|
|
|
addUnreadNotification: function ns_addUnreadNotification(id, skipUpdate) {
|
|
if (Service.query('UtilityTray.shown')) {
|
|
return;
|
|
}
|
|
this.unreadNotifications.push(id);
|
|
if (!skipUpdate) {
|
|
this.updateNotificationIndicator();
|
|
}
|
|
},
|
|
|
|
removeUnreadNotification: function ns_removeUnreadNotification(id) {
|
|
var notifIndex = this.unreadNotifications.indexOf(id);
|
|
if (notifIndex > -1) {
|
|
this.unreadNotifications.splice(notifIndex, 1);
|
|
}
|
|
this.updateNotificationIndicator();
|
|
},
|
|
|
|
hideNotificationIndicator: function ns_hideNotificationIndicator() {
|
|
if (this.unreadNotifications.length > 0) {
|
|
this.unreadNotifications = [];
|
|
}
|
|
this.updateNotificationIndicator();
|
|
},
|
|
|
|
updateNotificationIndicator: function ns_updateNotificationIndicator() {
|
|
if (this.unreadNotifications.length) {
|
|
// If the ftu is running we should not show the ambient indicator
|
|
// because the statusbar is not accessible
|
|
if (Service.query('isFtuRunning')) {
|
|
return;
|
|
}
|
|
this.ambientIndicator.classList.add('unread');
|
|
navigator.mozL10n.setAttributes(
|
|
this.ambientIndicator,
|
|
'statusbarNotifications-unread',
|
|
{n: this.unreadNotifications.length}
|
|
);
|
|
} else {
|
|
this.ambientIndicator.classList.remove('unread');
|
|
this.ambientIndicator.removeAttribute('aria-label');
|
|
}
|
|
|
|
Service.request('UtilityTray:updateNotificationCount');
|
|
},
|
|
|
|
closeToast: function ns_closeToast() {
|
|
this.toaster.classList.remove('displayed');
|
|
this.updateNotificationIndicator();
|
|
},
|
|
|
|
closeNotification: function ns_closeNotification(notificationNode) {
|
|
var notificationId = notificationNode.dataset.notificationId;
|
|
this.removeNotification(notificationId);
|
|
},
|
|
|
|
removeLockScreenNotification:
|
|
function ns_removeLockScreenNotification(notificationId) {
|
|
var lockScreenNotificationNode;
|
|
var notifSelector = '[data-notification-id="' + notificationId + '"]';
|
|
this.lockScreenContainer = this.getLockScreenContainer();
|
|
if (this.lockScreenContainer) {
|
|
lockScreenNotificationNode =
|
|
this.lockScreenContainer.querySelector(notifSelector);
|
|
}
|
|
|
|
if (lockScreenNotificationNode) {
|
|
var lockScreenNotificationParentNode =
|
|
lockScreenNotificationNode.parentNode;
|
|
lockScreenNotificationParentNode.removeChild(lockScreenNotificationNode);
|
|
window.dispatchEvent(
|
|
new window.CustomEvent('lockscreen-notification-request-remove', {
|
|
containerEmpty: !lockScreenNotificationParentNode.firstElementChild
|
|
}));
|
|
}
|
|
},
|
|
|
|
removeNotification: function ns_removeNotification(notificationId) {
|
|
var notifSelector = '[data-notification-id="' + notificationId + '"]';
|
|
var notificationNode = this.container.querySelector(notifSelector);
|
|
if (notificationNode) {
|
|
notificationNode.remove();
|
|
}
|
|
var event = document.createEvent('CustomEvent');
|
|
event.initCustomEvent('mozContentNotificationEvent', true, true, {
|
|
type: 'desktop-notification-close',
|
|
id: notificationId
|
|
});
|
|
window.dispatchEvent(event);
|
|
// UX require to give a tiny delay for actionable notification on
|
|
// LockScreen.
|
|
setTimeout((function() {
|
|
this.removeLockScreenNotification(notificationId);
|
|
}).bind(this), 400);
|
|
|
|
this.removeUnreadNotification(notificationId);
|
|
if (!this.container.querySelector('.notification')) {
|
|
// no notifications left
|
|
this.clearAllButton.disabled = true;
|
|
}
|
|
},
|
|
|
|
clearAll: function ns_clearAll() {
|
|
var notifications = this.container.querySelectorAll('.notification');
|
|
var clearable = [].slice.apply(notifications)
|
|
.filter(function isClearable(notification) {
|
|
return notification.dataset.noClear !== 'true';
|
|
});
|
|
var notification;
|
|
this.clearAllButton.disabled = true;
|
|
// When focus is on a disabled element, Gecko will not dispatch any keyboard
|
|
// events to it (the disabled element) and its parent.
|
|
// The clearAll Button is focused but disabled right away after
|
|
// user click it. We need to blur the focus immediately, otherwise System
|
|
// app could not receive any keyboard events. See more detail on
|
|
// http://bugzil.la/1106844
|
|
this.clearAllButton.blur();
|
|
if (!clearable.length) {
|
|
return;
|
|
}
|
|
// Adding a callback to the last cleared notification to defer
|
|
// the destroying of the notifications after the last disappear
|
|
var lastClearable = clearable[clearable.length - 1];
|
|
var removeAll = (function removeAll() {
|
|
lastClearable.removeEventListener('transitionend', removeAll);
|
|
for (var notification of clearable) {
|
|
this.closeNotification(notification);
|
|
}
|
|
}).bind(this);
|
|
lastClearable.addEventListener('transitionend', removeAll);
|
|
|
|
var disappearingClass = document.dir === 'ltr' ?
|
|
'disappearing-via-clear-all' : 'disappearing-via-clear-all-left';
|
|
for (var index = 0, max = clearable.length; index < max; index++) {
|
|
notification = clearable[index];
|
|
notification.style.transitionDelay = (this.CLEAR_DELAY * index) + 'ms';
|
|
notification.classList.add(disappearingClass);
|
|
notification.style.transform = '';
|
|
}
|
|
},
|
|
|
|
clearLockScreen: function ns_clearLockScreen() {
|
|
// The LockScreenWindow may not be instantiated yet.
|
|
if (!this.lockScreenContainer) {
|
|
return;
|
|
}
|
|
while (this.lockScreenContainer.firstElementChild) {
|
|
var element = this.lockScreenContainer.firstElementChild;
|
|
this.lockScreenContainer.removeChild(element);
|
|
}
|
|
window.dispatchEvent(
|
|
new window.CustomEvent('lockscreen-notification-request-clear'));
|
|
},
|
|
|
|
resendStoredNotifications: function() {
|
|
if ('mozSettings' in navigator && navigator.mozSettings) {
|
|
var key = 'notifications.resend';
|
|
var req = navigator.mozSettings.createLock().get(key);
|
|
req.onsuccess = req.onerror = function onsuccess() {
|
|
var resendEnabled = req.result[key] || false;
|
|
if (!resendEnabled) {
|
|
return;
|
|
}
|
|
|
|
var resendCallback = (function(number) {
|
|
window.dispatchEvent(
|
|
new CustomEvent('desktop-notification-resend',
|
|
{ detail: { number: number } }));
|
|
}).bind(this);
|
|
|
|
if ('mozChromeNotifications' in navigator) {
|
|
navigator.mozChromeNotifications.
|
|
mozResendAllNotifications(resendCallback);
|
|
}
|
|
};
|
|
}
|
|
}
|
|
};
|
|
|
|
SettingsListener.observe(
|
|
'lockscreen.notifications-preview.enabled', true, function(value) {
|
|
|
|
NotificationScreen.lockscreenPreview = value;
|
|
});
|
|
|
|
SettingsListener.observe('audio.volume.notification', 7, function(value) {
|
|
NotificationScreen.silent = (value === 0);
|
|
});
|
|
|
|
SettingsListener.observe('vibration.enabled', true, function(value) {
|
|
NotificationScreen.vibrates = value;
|
|
});
|