Revision control
Copy as Markdown
Other Tools
/* -*- Mode: JavaScript; 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
const lazy = {};
ChromeUtils.defineESModuleGetters(lazy, {
});
export const NotificationScheduler = {
/**
* Callbacks for the current promise
*
* @type {Set<Function>}
*/
_callbacks: new Set(),
/**
* Current state of the promise.
*
* @type {boolean}
*/
fulfilled: false,
/**
* Notification id of the current promise.
*
* @type {string}
*/
id: null,
/**
* If the user is currently active.
*
* @type {boolean}
*/
active: false,
/**
* The threshold in px for how much of the window can be offscreen and still show
* a notification.
*
* @type {number}
*/
_windowThreshold: 120,
/**
* Initialize the notification scheduler with the current notificationManager
* setup the idle callback and the interaction event listeners that are global.
*
* @param {NotificationManager} notificationManager - The current notification
* manager used by inAppNotifications.
*/
init(notificationManager) {
try {
this._idleService = Cc[
"@mozilla.org/widget/useridleservice;1"
].getService(Ci.nsIUserIdleService);
this._idleService.addIdleObserver(this, 30);
} catch (error) {
console.error(error);
}
if (this._idleService.idleTime < 5000) {
this.active = true;
}
notificationManager.addEventListener(
NotificationManager.NOTIFICATION_INTERACTION_EVENT,
this
);
notificationManager.addEventListener(
NotificationManager.CLEAR_NOTIFICATION_EVENT,
this
);
Services.obs.addObserver(this, "xul-window-visible");
Services.obs.addObserver(this, "document-shown");
},
observe(_subject, topic) {
let update = false;
switch (topic) {
case "active":
case "idle":
case "idle-daily": {
// Just check for active because we only care if its active not which type
// of idle it might be.
const newState = topic === "active";
update = this.active !== newState;
this.active = newState;
break;
}
case "document-shown":
case "xul-window-visible":
update = true;
break;
default:
return;
}
if (!update) {
return;
}
this._callbacks.forEach(callback => callback());
},
handleEvent() {
this.reset();
},
/**
* Reset the state of the scheduler for a new notification.
*
*/
reset() {
this.fulfilled = true;
// Check for any pending callbacks and call them to reject those promises.
for (const callback of this._callbacks) {
callback();
}
// Clear the callbacks and reset the current notification has been dismissed.
this._callbacks = new Set();
this.fulfilled = false;
this.id = null;
},
/**
* Check if the given window is on screen.
*
* @param {window} usedWindow - The window to check position of.
* @returns {boolean} If the window is visible
*/
_checkScreen(usedWindow) {
// Screen information and window positions are not reliable on Linux.
// We err on the side of caution and thus assume the window is fully visible.
if (AppConstants.platform === "linux") {
return true;
}
const leftVisible =
usedWindow.screenX >= usedWindow.screen.availLeft - this._windowThreshold;
const rightVisible =
usedWindow.screenX + usedWindow.outerWidth <=
usedWindow.screen.availLeft +
usedWindow.screen.availWidth +
this._windowThreshold;
const topVisible =
usedWindow.screenY >= usedWindow.screen.availTop - this._windowThreshold;
const bottomVisible =
usedWindow.screenY + usedWindow.outerHeight <=
usedWindow.screen.availTop +
usedWindow.screen.availHeight +
this._windowThreshold;
return leftVisible && rightVisible && topVisible && bottomVisible;
},
/**
* Returns a promise that is either resolved once all of the listeners report
* that the user is active or reject once the notification has been interacted
* with.
*
* @param {object} [waitForActiveOptions={}] - The options to waitForActive.
* @param {?window} [waitForActiveOptions.currentWindow=null] - The window to listen
* for events on
* @param {string} waitForActiveOptions.id - The id of the notification to
* show
*
* @returns {Promise<void>}
*/
async waitForActive({ currentWindow = null, id } = {}) {
// Create a state object based on the listeners passed in.
const currentState = {
active: this.active,
focus: false,
visible: false,
onScreen: false,
};
// Create a promise to be awaited
const { resolve, reject, promise } = Promise.withResolvers();
let interval;
let timeout;
// The following functions are inside this method for scoping reasons
/**
* The callback that is called whenever one of the states updates or the
* promise is fulfilled
*
* @returns {void}
*/
const callback = () => {
if (this.fulfilled) {
cleanup();
return;
}
const activeWindow = Services.focus.activeWindow;
const usedWindow = currentWindow || activeWindow;
// Check if the window is visible on screen
currentState.onScreen = usedWindow && this._checkScreen(usedWindow);
// Set the current visible state
currentState.visible = !usedWindow?.document.hidden;
// Set the current idle or active state.
currentState.active = this.active;
// Set the current focus state
currentState.focus = activeWindow === usedWindow;
// If we dont have a currentWindow (donation_tab or donation_browser) we
// can't listen for resize or move events on a window to know when to
// recheck if the window is onScreen so we have to use an interval.
if (!currentWindow && !currentState.onScreen && activeWindow) {
interval = lazy.setInterval(callback, 5000);
} else if (interval) {
lazy.clearInterval(interval);
interval = undefined;
}
// Check if all the listeners are true resolve the promise to show the
// notification, then delete this promise from the active ones.
if (Object.values(currentState).every(value => value)) {
resolve();
cleanup();
this._callbacks.delete(callback);
if (!this._callbacks.size) {
this.id = null;
this.fulfilled = false;
}
}
};
function cleanup() {
reject(new Error(`Cleaning up active user lock for ${id}`));
if (timeout) {
lazy.clearTimeout(timeout);
}
if (interval) {
lazy.clearInterval(interval);
}
// If we were not sent a window bail and don't setup window listeners.
if (!currentWindow) {
return;
}
currentWindow.document.removeEventListener("visibilitychange", callback);
currentWindow.removeEventListener("activate", handleUnload);
currentWindow.windowRoot?.removeEventListener(
"MozUpdateWindowPos",
callback
);
currentWindow.removeEventListener("unload", handleUnload);
currentWindow.removeEventListener("resize", callback);
}
// If we get a bew notifiction before the only one is dismissed update state.
if (this.id && this.id !== id) {
this.reset();
this.id = id;
}
this._callbacks.add(callback);
if (!currentWindow) {
callback();
await promise;
return;
}
const handleUnload = () => {
cleanup();
this._callbacks.delete(callback);
};
function debounceCallback() {
lazy.clearTimeout(timeout);
timeout = lazy.setTimeout(callback, 1000);
}
// If we have a currentWindow listen for events on it
// Monitor if the window has become active
currentWindow.addEventListener("activate", callback);
currentWindow.addEventListener("unload", handleUnload);
// Monitor for changes from the visibility api
currentWindow.document.addEventListener("visibilitychange", callback);
// Monitor if the window is on screen
currentWindow.addEventListener("resize", debounceCallback);
currentWindow.windowRoot.addEventListener(
"MozUpdateWindowPos",
debounceCallback
);
callback();
await promise;
},
};