browser/themes/BuiltInThemes.sys.mjs

   1 /* This Source Code Form is subject to the terms of the Mozilla Public
   2  * License, v. 2.0. If a copy of the MPL was not distributed with this
   3  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   4
   5 import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
   6
   7 const lazy = {};
   8
   9 ChromeUtils.defineESModuleGetters(lazy, {
  10   AddonManager: "resource://gre/modules/AddonManager.sys.mjs",
  11   BuiltInThemeConfig: "resource:///modules/BuiltInThemeConfig.sys.mjs",
  12 });
  13
  14 const ColorwayL10n = new Localization(["browser/colorways.ftl"], true);
  15
  16 const kActiveThemePref = "extensions.activeThemeID";
  17 const kRetainedThemesPref = "browser.theme.retainedExpiredThemes";
  18
  19 const ColorwayIntensityIdPostfixToL10nMap = [
  20   ["-soft-colorway@mozilla.org", "colorway-intensity-soft"],
  21   ["-balanced-colorway@mozilla.org", "colorway-intensity-balanced"],
  22   ["-bold-colorway@mozilla.org", "colorway-intensity-bold"],
  23 ];
  24
  25 XPCOMUtils.defineLazyPreferenceGetter(
  26   lazy,
  27   "retainedThemes",
  28   kRetainedThemesPref,
  29   null,
  30   null,
  31   val => {
  32     if (!val) {
  33       return [];
  34     }
  35
  36     let parsedVal;
  37     try {
  38       parsedVal = JSON.parse(val);
  39     } catch (ex) {
  40       console.log(`${kRetainedThemesPref} has invalid value.`);
  41       return [];
  42     }
  43
  44     return parsedVal;
  45   }
  46 );
  47
  48 class _BuiltInThemes {
  49   /**
  50    * The list of themes to be installed. This is exposed on the class so tests
  51    * can set custom config files.
  52    */
  53   builtInThemeMap = lazy.BuiltInThemeConfig;
  54
  55   /**
  56    * @param {string} id An addon's id string.
  57    * @returns {string}
  58    *   If `id` refers to a built-in theme, returns a path pointing to the
  59    *   theme's preview image. Null otherwise.
  60    */
  61   previewForBuiltInThemeId(id) {
  62     let theme = this.builtInThemeMap.get(id);
  63     if (theme) {
  64       return `${theme.path}preview.svg`;
  65     }
  66
  67     return null;
  68   }
  69
  70   /**
  71    * If the active theme is built-in, this function calls
  72    * AddonManager.maybeInstallBuiltinAddon for that theme.
  73    */
  74   maybeInstallActiveBuiltInTheme() {
  75     const activeThemeID = Services.prefs.getStringPref(
  76       kActiveThemePref,
  77       "default-theme@mozilla.org"
  78     );
  79     let activeBuiltInTheme = this.builtInThemeMap.get(activeThemeID);
  80
  81     if (activeBuiltInTheme) {
  82       lazy.AddonManager.maybeInstallBuiltinAddon(
  83         activeThemeID,
  84         activeBuiltInTheme.version,
  85         `resource://builtin-themes/${activeBuiltInTheme.path}`
  86       );
  87     }
  88   }
  89
  90   /**
  91    * Ensures that all built-in themes are installed and expired themes are
  92    * uninstalled.
  93    */
  94   async ensureBuiltInThemes() {
  95     let installPromises = [];
  96     installPromises.push(this._uninstallExpiredThemes());
  97
  98     const now = new Date();
  99     for (let [id, themeInfo] of this.builtInThemeMap.entries()) {
 100       if (
 101         !themeInfo.expiry ||
 102         lazy.retainedThemes.includes(id) ||
 103         new Date(themeInfo.expiry) > now
 104       ) {
 105         installPromises.push(
 106           lazy.AddonManager.maybeInstallBuiltinAddon(
 107             id,
 108             themeInfo.version,
 109             themeInfo.path
 110           )
 111         );
 112       }
 113     }
 114
 115     await Promise.all(installPromises);
 116   }
 117
 118   /**
 119    * @param {string} id
 120    *   A theme's ID.
 121    * @returns {boolean}
 122    *   Returns true if the theme is expired. False otherwise.
 123    * @note This looks up the id in a Map rather than accessing a property on
 124    *   the addon itself. That makes calls to this function O(m) where m is the
 125    *   total number of built-in themes offered now or in the past. Since we
 126    *   are using a Map, calls are O(1) in the average case.
 127    */
 128   themeIsExpired(id) {
 129     let themeInfo = this.builtInThemeMap.get(id);
 130     return themeInfo?.expiry && new Date(themeInfo.expiry) < new Date();
 131   }
 132
 133   /**
 134    * @param {string} id
 135    *   The theme's id.
 136    * @return {boolean}
 137    *   True if the theme with id `id` is both expired and retained. That is,
 138    *   the user has the ability to use it after its expiry date.
 139    */
 140   isRetainedExpiredTheme(id) {
 141     return lazy.retainedThemes.includes(id) && this.themeIsExpired(id);
 142   }
 143
 144   /**
 145    * @param {string} id
 146    *   The theme's id.
 147    * @return {boolean}
 148    *   True if the theme with id `id` is from the currently active theme.
 149    */
 150   isActiveTheme(id) {
 151     return (
 152       id ===
 153       Services.prefs.getStringPref(
 154         kActiveThemePref,
 155         "default-theme@mozilla.org"
 156       )
 157     );
 158   }
 159
 160   /**
 161    * Uninstalls themes after they expire. If the expired theme is active, then
 162    * it is not uninstalled. Instead, it is saved so that the user can use it
 163    * indefinitely.
 164    */
 165   async _uninstallExpiredThemes() {
 166     const activeThemeID = Services.prefs.getStringPref(
 167       kActiveThemePref,
 168       "default-theme@mozilla.org"
 169     );
 170     const now = new Date();
 171     const expiredThemes = Array.from(this.builtInThemeMap.entries()).filter(
 172       ([id, themeInfo]) =>
 173         !!themeInfo.expiry &&
 174         !lazy.retainedThemes.includes(id) &&
 175         new Date(themeInfo.expiry) <= now
 176     );
 177     for (let [id] of expiredThemes) {
 178       if (id == activeThemeID) {
 179         let shouldRetain = true;
 180
 181         try {
 182           let addon = await lazy.AddonManager.getAddonByID(id);
 183           if (addon) {
 184             // Only add the id to the retain themes pref if it is
 185             // also a built-in themes (and don't if it was migrated
 186             // xpi files installed in the user profile).
 187             shouldRetain = addon.isBuiltinColorwayTheme;
 188           }
 189         } catch (e) {
 190           console.error(
 191             `Failed to retrieve active theme AddonWrapper ${id}`,
 192             e
 193           );
 194         }
 195
 196         if (shouldRetain) {
 197           this._retainLimitedTimeTheme(id);
 198         }
 199       } else {
 200         try {
 201           let addon = await lazy.AddonManager.getAddonByID(id);
 202           // Only uninstall the expired colorways theme if they are not
 203           // migrated builtins (because on migrated to xpi files
 204           // installed in the user profile they are also removed
 205           // from the retainedExpiredThemes pref).
 206           if (addon?.isBuiltinColorwayTheme) {
 207             await addon.uninstall();
 208           }
 209         } catch (e) {
 210           console.error(`Failed to uninstall expired theme ${id}`, e);
 211         }
 212       }
 213     }
 214   }
 215
 216   /**
 217    * Set a pref to ensure that the user can continue to use a specified theme
 218    * past its expiry date.
 219    * @param {string} id
 220    *   The ID of the theme to retain.
 221    */
 222   _retainLimitedTimeTheme(id) {
 223     if (!lazy.retainedThemes.includes(id)) {
 224       lazy.retainedThemes.push(id);
 225       Services.prefs.setStringPref(
 226         kRetainedThemesPref,
 227         JSON.stringify(lazy.retainedThemes)
 228       );
 229     }
 230   }
 231
 232   /**
 233    * Removes from the retained expired theme list colorways themes that have been
 234    * migrated from the one installed in the built-in XPIProvider location
 235    * to an AMO hosted xpi installed in the user profile XPIProvider location.
 236    * @param {string} id
 237    *   The ID of the theme to remove from the retained themes list.
 238    */
 239
 240   unretainMigratedColorwayTheme(id) {
 241     if (lazy.retainedThemes.includes(id)) {
 242       const retainedThemes = lazy.retainedThemes.filter(
 243         retainedThemeId => retainedThemeId !== id
 244       );
 245       Services.prefs.setStringPref(
 246         kRetainedThemesPref,
 247         JSON.stringify(retainedThemes)
 248       );
 249     }
 250   }
 251
 252   /**
 253    * Colorway collections are usually divided into and presented as "groups".
 254    * A group either contains closely related colorways, e.g. stemming from the
 255    * same base color but with different intensities (soft, balanced, and bold),
 256    * or if the current collection doesn't have intensities, each colorway is
 257    * their own group. Group name localization is optional.
 258    * @param {string} id
 259    *   The ID of the colorway add-on.
 260    * @return {string}
 261    *   Localized colorway group name. null if there's no such name, in which
 262    *   case the caller should fall back on getting a name from the add-on API.
 263    */
 264   getLocalizedColorwayGroupName(colorwayId) {
 265     return this._getColorwayString(colorwayId, "groupName");
 266   }
 267
 268   /**
 269    * @param {string} id
 270    *   The ID of the colorway add-on.
 271    * @return {string}
 272    *   L10nId for intensity value of the colorway with the provided id, null if
 273    *   there's none.
 274    */
 275   getColorwayIntensityL10nId(colorwayId) {
 276     const result = ColorwayIntensityIdPostfixToL10nMap.find(
 277       ([postfix, l10nId]) => colorwayId.endsWith(postfix)
 278     );
 279     return result ? result[1] : null;
 280   }
 281
 282   /**
 283    * @param {string} id
 284    *   The ID of the colorway add-on.
 285    * @return {string}
 286    *   Localized description of the colorway with the provided id, null if
 287    *   there's none.
 288    */
 289   getLocalizedColorwayDescription(colorwayId) {
 290     return this._getColorwayString(colorwayId, "description");
 291   }
 292
 293   _getColorwayString(colorwayId, stringType) {
 294     let l10nId = this.builtInThemeMap.get(colorwayId)?.l10nId?.[stringType];
 295     let s;
 296     if (l10nId) {
 297       [s] = ColorwayL10n.formatMessagesSync([
 298         {
 299           id: l10nId,
 300         },
 301       ]);
 302     }
 303     return s?.value || null;
 304   }
 305 }
 306
 307 export var BuiltInThemes = new _BuiltInThemes();