/* -*- indent-tabs-mode: nil; js-indent-level: 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/. */ #filter substitution XPCOMUtils.defineLazyModuleGetter(this, "DeferredTask", "resource://gre/modules/DeferredTask.jsm"); const TYPE_MAYBE_FEED = "application/vnd.mozilla.maybe.feed"; const TYPE_MAYBE_AUDIO_FEED = "application/vnd.mozilla.maybe.audio.feed"; const TYPE_MAYBE_VIDEO_FEED = "application/vnd.mozilla.maybe.video.feed"; const PREF_SHOW_FIRST_RUN_UI = "browser.feeds.showFirstRunUI"; const PREF_SELECTED_APP = "browser.feeds.handlers.application"; const PREF_SELECTED_WEB = "browser.feeds.handlers.webservice"; const PREF_SELECTED_ACTION = "browser.feeds.handler"; const PREF_SELECTED_READER = "browser.feeds.handler.default"; const PREF_VIDEO_SELECTED_APP = "browser.videoFeeds.handlers.application"; const PREF_VIDEO_SELECTED_WEB = "browser.videoFeeds.handlers.webservice"; const PREF_VIDEO_SELECTED_ACTION = "browser.videoFeeds.handler"; const PREF_VIDEO_SELECTED_READER = "browser.videoFeeds.handler.default"; const PREF_AUDIO_SELECTED_APP = "browser.audioFeeds.handlers.application"; const PREF_AUDIO_SELECTED_WEB = "browser.audioFeeds.handlers.webservice"; const PREF_AUDIO_SELECTED_ACTION = "browser.audioFeeds.handler"; const PREF_AUDIO_SELECTED_READER = "browser.audioFeeds.handler.default"; const PREF_UPDATE_DELAY = 2000; const SETTABLE_PREFS = new Set([ PREF_VIDEO_SELECTED_ACTION, PREF_AUDIO_SELECTED_ACTION, PREF_SELECTED_ACTION, PREF_VIDEO_SELECTED_READER, PREF_AUDIO_SELECTED_READER, PREF_SELECTED_READER, PREF_VIDEO_SELECTED_WEB, PREF_AUDIO_SELECTED_WEB, PREF_SELECTED_WEB ]); const EXECUTABLE_PREFS = new Set([ PREF_SELECTED_APP, PREF_VIDEO_SELECTED_APP, PREF_AUDIO_SELECTED_APP ]); const VALID_ACTIONS = new Set(["ask", "reader", "bookmarks"]); const VALID_READERS = new Set(["web", "client", "default", "bookmarks"]); XPCOMUtils.defineLazyPreferenceGetter(this, "SHOULD_LOG", "feeds.log", false); function LOG(str) { if (SHOULD_LOG) dump("*** Feeds: " + str + "\n"); } function getPrefActionForType(t) { switch (t) { case Ci.nsIFeed.TYPE_VIDEO: return PREF_VIDEO_SELECTED_ACTION; case Ci.nsIFeed.TYPE_AUDIO: return PREF_AUDIO_SELECTED_ACTION; default: return PREF_SELECTED_ACTION; } } function getPrefReaderForType(t) { switch (t) { case Ci.nsIFeed.TYPE_VIDEO: return PREF_VIDEO_SELECTED_READER; case Ci.nsIFeed.TYPE_AUDIO: return PREF_AUDIO_SELECTED_READER; default: return PREF_SELECTED_READER; } } function getPrefWebForType(t) { switch (t) { case Ci.nsIFeed.TYPE_VIDEO: return PREF_VIDEO_SELECTED_WEB; case Ci.nsIFeed.TYPE_AUDIO: return PREF_AUDIO_SELECTED_WEB; default: return PREF_SELECTED_WEB; } } function getPrefAppForType(t) { switch (t) { case Ci.nsIFeed.TYPE_VIDEO: return PREF_VIDEO_SELECTED_APP; case Ci.nsIFeed.TYPE_AUDIO: return PREF_AUDIO_SELECTED_APP; default: return PREF_SELECTED_APP; } } /** * Maps a feed type to a maybe-feed mimetype. */ function getMimeTypeForFeedType(aFeedType) { switch (aFeedType) { case Ci.nsIFeed.TYPE_VIDEO: return TYPE_MAYBE_VIDEO_FEED; case Ci.nsIFeed.TYPE_AUDIO: return TYPE_MAYBE_AUDIO_FEED; default: return TYPE_MAYBE_FEED; } } /** * The Feed Handler object manages discovery of RSS/ATOM feeds in web pages * and shows UI when they are discovered. */ var FeedHandler = { _prefChangeCallback: null, /** Called when the user clicks on the Subscribe to This Page... menu item, * or when the user clicks the feed button when the page contains multiple * feeds. * Builds a menu of unique feeds associated with the page, and if there * is only one, shows the feed inline in the browser window. * @param container * The feed list container (menupopup or subview) to be populated. * @param isSubview * Whether we're creating a subview (true) or menu (false/undefined) * @return true if the menu/subview should be shown, false if there was only * one feed and the feed should be shown inline in the browser * window (do not show the menupopup/subview). */ buildFeedList(container, isSubview) { let feeds = gBrowser.selectedBrowser.feeds; if (!isSubview && feeds == null) { // XXX hack -- menu opening depends on setting of an "open" // attribute, and the menu refuses to open if that attribute is // set (because it thinks it's already open). onpopupshowing gets // called after the attribute is unset, and it doesn't get unset // if we return false. so we unset it here; otherwise, the menu // refuses to work past this point. container.parentNode.removeAttribute("open"); return false; } for (let i = container.childNodes.length - 1; i >= 0; --i) { let node = container.childNodes[i]; if (isSubview && node.localName == "label") continue; container.removeChild(node); } if (!feeds || feeds.length <= 1) return false; // Build the menu showing the available feed choices for viewing. let itemNodeType = isSubview ? "toolbarbutton" : "menuitem"; for (let feedInfo of feeds) { let item = document.createElement(itemNodeType); let baseTitle = feedInfo.title || feedInfo.href; item.setAttribute("label", baseTitle); item.setAttribute("feed", feedInfo.href); item.setAttribute("tooltiptext", feedInfo.href); item.setAttribute("crop", "center"); let className = "feed-" + itemNodeType; if (isSubview) { className += " subviewbutton"; } item.setAttribute("class", className); container.appendChild(item); } return true; }, /** * Subscribe to a given feed. Called when * 1. Page has a single feed and user clicks feed icon in location bar * 2. Page has a single feed and user selects Subscribe menu item * 3. Page has multiple feeds and user selects from feed icon popup (or subview) * 4. Page has multiple feeds and user selects from Subscribe submenu * @param href * The feed to subscribe to. May be null, in which case the * event target's feed attribute is examined. * @param event * The event this method is handling. Used to decide where * to open the preview UI. (Optional, unless href is null) */ subscribeToFeed(href, event) { // Just load the feed in the content area to either subscribe or show the // preview UI if (!href) href = event.target.getAttribute("feed"); urlSecurityCheck(href, gBrowser.contentPrincipal, Ci.nsIScriptSecurityManager.DISALLOW_INHERIT_PRINCIPAL); let feedURI = makeURI(href, document.characterSet); // Use the feed scheme so X-Moz-Is-Feed will be set // The value doesn't matter if (/^https?$/.test(feedURI.scheme)) href = "feed:" + href; this.loadFeed(href, event); }, loadFeed(href, event) { let feeds = gBrowser.selectedBrowser.feeds; try { openUILink(href, event, { ignoreAlt: true }); } finally { // We might default to a livebookmarks modal dialog, // so reset that if the user happens to click it again gBrowser.selectedBrowser.feeds = feeds; } }, get _feedMenuitem() { delete this._feedMenuitem; return this._feedMenuitem = document.getElementById("singleFeedMenuitemState"); }, get _feedMenupopup() { delete this._feedMenupopup; return this._feedMenupopup = document.getElementById("multipleFeedsMenuState"); }, /** * Update the browser UI to show whether or not feeds are available when * a page is loaded or the user switches tabs to a page that has feeds. */ updateFeeds() { if (this._updateFeedTimeout) clearTimeout(this._updateFeedTimeout); let feeds = gBrowser.selectedBrowser.feeds; let haveFeeds = feeds && feeds.length > 0; let feedButton = document.getElementById("feed-button"); if (feedButton) { if (haveFeeds) { feedButton.removeAttribute("disabled"); } else { feedButton.setAttribute("disabled", "true"); } } if (!haveFeeds) { this._feedMenuitem.setAttribute("disabled", "true"); this._feedMenuitem.removeAttribute("hidden"); this._feedMenupopup.setAttribute("hidden", "true"); return; } if (feeds.length > 1) { this._feedMenuitem.setAttribute("hidden", "true"); this._feedMenupopup.removeAttribute("hidden"); } else { this._feedMenuitem.setAttribute("feed", feeds[0].href); this._feedMenuitem.removeAttribute("disabled"); this._feedMenuitem.removeAttribute("hidden"); this._feedMenupopup.setAttribute("hidden", "true"); } }, addFeed(link, browserForLink) { if (!browserForLink.feeds) browserForLink.feeds = []; browserForLink.feeds.push({ href: link.href, title: link.title }); // If this addition was for the current browser, update the UI. For // background browsers, we'll update on tab switch. if (browserForLink == gBrowser.selectedBrowser) { // Batch updates to avoid updating the UI for multiple onLinkAdded events // fired within 100ms of each other. if (this._updateFeedTimeout) clearTimeout(this._updateFeedTimeout); this._updateFeedTimeout = setTimeout(this.updateFeeds.bind(this), 100); } }, /** * Get the human-readable display name of a file. This could be the * application name. * @param file * A nsIFile to look up the name of * @return The display name of the application represented by the file. */ _getFileDisplayName(file) { #ifdef XP_WIN if (file instanceof Ci.nsILocalFileWin) { try { return file.getVersionInfoField("FileDescription"); } catch (e) {} } #elif XP_MACOSX if (file instanceof Ci.nsILocalFileMac) { try { return file.bundleDisplayName; } catch (e) {} } #endif return file.leafName; }, _chooseClientApp(aTitle, aTypeName, aBrowser) { const prefName = getPrefAppForType(aTypeName); let fp = Cc["@mozilla.org/filepicker;1"].createInstance(Ci.nsIFilePicker); fp.init(window, aTitle, Ci.nsIFilePicker.modeOpen); fp.appendFilters(Ci.nsIFilePicker.filterApps); fp.open((aResult) => { if (aResult == Ci.nsIFilePicker.returnOK) { let selectedApp = fp.file; if (selectedApp) { // XXXben - we need to compare this with the running instance // executable just don't know how to do that via script // XXXmano TBD: can probably add this to nsIShellService let appName = ""; #ifdef XP_WIN appName = "@MOZ_APP_NAME@.exe"; #elif XP_MACOSX appName = "@MOZ_MACBUNDLE_NAME@"; #else appName = "@MOZ_APP_NAME@-bin"; #endif if (fp.file.leafName != appName) { Services.prefs.setComplexValue(prefName, Ci.nsILocalFile, selectedApp); aBrowser.messageManager.sendAsyncMessage("FeedWriter:SetApplicationLauncherMenuItem", { name: this._getFileDisplayName(selectedApp), type: "SelectedAppMenuItem" }); } } } }); }, executeClientApp(aSpec, aTitle, aSubtitle, aFeedHandler) { // aFeedHandler is either "default", indicating the system default reader, or a pref-name containing // an nsILocalFile pointing to the feed handler's executable. let clientApp = null; if (aFeedHandler == "default") { clientApp = Cc["@mozilla.org/browser/shell-service;1"] .getService(Ci.nsIShellService) .defaultFeedReader; } else { clientApp = Services.prefs.getComplexValue(aFeedHandler, Ci.nsILocalFile); } // For the benefit of applications that might know how to deal with more // URLs than just feeds, send feed: URLs in the following format: // // http urls: replace scheme with feed, e.g. // http://foo.com/index.rdf -> feed://foo.com/index.rdf // other urls: prepend feed: scheme, e.g. // https://foo.com/index.rdf -> feed:https://foo.com/index.rdf let feedURI = NetUtil.newURI(aSpec); if (feedURI.schemeIs("http")) { feedURI.scheme = "feed"; aSpec = feedURI.spec; } else { aSpec = "feed:" + aSpec; } // Retrieving the shell service might fail on some systems, most // notably systems where GNOME is not installed. try { let ss = Cc["@mozilla.org/browser/shell-service;1"] .getService(Ci.nsIShellService); ss.openApplicationWithURI(clientApp, aSpec); } catch (e) { // If we couldn't use the shell service, fallback to using a // nsIProcess instance let p = Cc["@mozilla.org/process/util;1"] .createInstance(Ci.nsIProcess); p.init(clientApp); p.run(false, [aSpec], 1); } }, // nsISupports QueryInterface: XPCOMUtils.generateQI([Ci.nsIObserver, Ci.nsISupportsWeakReference]), init() { window.messageManager.addMessageListener("FeedWriter:ChooseClientApp", this); window.messageManager.addMessageListener("FeedWriter:GetSubscriptionUI", this); window.messageManager.addMessageListener("FeedWriter:SetFeedPrefsAndSubscribe", this); window.messageManager.addMessageListener("FeedWriter:ShownFirstRun", this); Services.ppmm.addMessageListener("FeedConverter:ExecuteClientApp", this); const prefs = Services.prefs; prefs.addObserver(PREF_SELECTED_ACTION, this, true); prefs.addObserver(PREF_SELECTED_READER, this, true); prefs.addObserver(PREF_SELECTED_WEB, this, true); prefs.addObserver(PREF_VIDEO_SELECTED_ACTION, this, true); prefs.addObserver(PREF_VIDEO_SELECTED_READER, this, true); prefs.addObserver(PREF_VIDEO_SELECTED_WEB, this, true); prefs.addObserver(PREF_AUDIO_SELECTED_ACTION, this, true); prefs.addObserver(PREF_AUDIO_SELECTED_READER, this, true); prefs.addObserver(PREF_AUDIO_SELECTED_WEB, this, true); }, uninit() { Services.ppmm.removeMessageListener("FeedConverter:ExecuteClientApp", this); this._prefChangeCallback = null; }, // nsIObserver observe(subject, topic, data) { if (topic == "nsPref:changed") { LOG(`Pref changed ${data}`) if (this._prefChangeCallback) { this._prefChangeCallback.disarm(); } // Multiple prefs are set at the same time, debounce to reduce noise // This can happen in one feed and we want to message all feed pages this._prefChangeCallback = new DeferredTask(() => { this._prefChanged(data); }, PREF_UPDATE_DELAY); this._prefChangeCallback.arm(); } }, _prefChanged(prefName) { // Don't observe for PREF_*SELECTED_APP as user likely just picked one // That is also handled by SetApplicationLauncherMenuItem call // Rather than the others which happen on subscription switch (prefName) { case PREF_SELECTED_READER: case PREF_SELECTED_WEB: case PREF_VIDEO_SELECTED_READER: case PREF_VIDEO_SELECTED_WEB: case PREF_AUDIO_SELECTED_READER: case PREF_AUDIO_SELECTED_WEB: case PREF_SELECTED_ACTION: case PREF_VIDEO_SELECTED_ACTION: case PREF_AUDIO_SELECTED_ACTION: const response = { default: this._getReaderForType(Ci.nsIFeed.TYPE_FEED), [Ci.nsIFeed.TYPE_AUDIO]: this._getReaderForType(Ci.nsIFeed.TYPE_AUDIO), [Ci.nsIFeed.TYPE_VIDEO]: this._getReaderForType(Ci.nsIFeed.TYPE_VIDEO) }; Services.mm.broadcastAsyncMessage("FeedWriter:PreferenceUpdated", response); break; } }, _initSubscriptionUIResponse(feedType) { const wccr = Cc["@mozilla.org/embeddor.implemented/web-content-handler-registrar;1"]. getService(Ci.nsIWebContentConverterService); const handlersRaw = wccr.getContentHandlers(getMimeTypeForFeedType(feedType)); const handlers = []; for (let handler of handlersRaw) { LOG(`Handler found: ${handler}`); handlers.push({ name: handler.name, uri: handler.uri }); } let showFirstRunUI = true; // eslint-disable-next-line mozilla/use-default-preference-values try { showFirstRunUI = Services.prefs.getBoolPref(PREF_SHOW_FIRST_RUN_UI); } catch (ex) { } const response = { handlers, showFirstRunUI }; let selectedClientApp; const feedTypePref = getPrefAppForType(feedType); try { selectedClientApp = Services.prefs.getComplexValue(feedTypePref, Ci.nsILocalFile); } catch (ex) { // Just do nothing, then we won't bother populating } let defaultClientApp = null; try { // This can sometimes not exist defaultClientApp = Cc["@mozilla.org/browser/shell-service;1"] .getService(Ci.nsIShellService) .defaultFeedReader; } catch (ex) { // Just do nothing, then we don't bother populating } if (selectedClientApp && selectedClientApp.exists()) { if (defaultClientApp && selectedClientApp.path != defaultClientApp.path) { // Only set the default menu item if it differs from the selected one response.defaultMenuItem = this._getFileDisplayName(defaultClientApp); } response.selectedMenuItem = this._getFileDisplayName(selectedClientApp); } response.reader = this._getReaderForType(feedType); return response; }, _setPref(aPrefName, aPrefValue, aIsComplex = false) { LOG(`FeedWriter._setPref ${aPrefName}`); // Ensure we have a pref that is settable if (aPrefName && SETTABLE_PREFS.has(aPrefName)) { if (aIsComplex) { const supportsString = Cc["@mozilla.org/supports-string;1"]. createInstance(Ci.nsISupportsString); supportsString.data = aPrefValue; Services.prefs.setComplexValue(aPrefName, Ci.nsISupportsString, supportsString); } else { Services.prefs.setCharPref(aPrefName, aPrefValue); } } else { LOG(`FeedWriter._setPref ${aPrefName} not allowed`); } }, _getReaderForType(feedType) { let prefs = Services.prefs; let handler = "bookmarks"; let url; // eslint-disable-next-line mozilla/use-default-preference-values try { handler = prefs.getCharPref(getPrefReaderForType(feedType)); } catch (ex) { } if (handler === "web") { try { url = prefs.getComplexValue(getPrefWebForType(feedType), Ci.nsISupportsString).data; } catch (ex) { LOG("FeedWriter._setSelectedHandler: invalid or no handler in prefs"); url = null; } } const alwaysUse = this._getAlwaysUseState(feedType); const action = prefs.getCharPref(getPrefActionForType(feedType)); return { handler, url, alwaysUse, action }; }, _getAlwaysUseState(feedType) { try { return Services.prefs.getCharPref(getPrefActionForType(feedType)) != "ask"; } catch (ex) { } return false; }, receiveMessage(msg) { let handler; switch (msg.name) { case "FeedWriter:GetSubscriptionUI": const response = this._initSubscriptionUIResponse(msg.data.feedType); msg.target.messageManager .sendAsyncMessage("FeedWriter:GetSubscriptionUIResponse", response); break; case "FeedWriter:ChooseClientApp": this._chooseClientApp(msg.data.title, msg.data.feedType, msg.target); break; case "FeedWriter:ShownFirstRun": Services.prefs.setBoolPref(PREF_SHOW_FIRST_RUN_UI, false); break; case "FeedWriter:SetFeedPrefsAndSubscribe": const settings = msg.data; if (!settings.action || !VALID_ACTIONS.has(settings.action)) { LOG(`Invalid action ${settings.action}`); return; } if (!settings.reader || !VALID_READERS.has(settings.reader)) { LOG(`Invalid reader ${settings.reader}`); return; } const actionPref = getPrefActionForType(settings.feedType); this._setPref(actionPref, settings.action); const readerPref = getPrefReaderForType(settings.feedType); this._setPref(readerPref, settings.reader); handler = null; switch (settings.reader) { case "web": // This is a web set URI by content using window.registerContentHandler() // Lets make sure we know about it before setting it const webPref = getPrefWebForType(settings.feedType); let wccr = Cc["@mozilla.org/embeddor.implemented/web-content-handler-registrar;1"]. getService(Ci.nsIWebContentConverterService); // If the user provided an invalid web URL this function won't give us a reference handler = wccr.getWebContentHandlerByURI(getMimeTypeForFeedType(settings.feedType), settings.uri); if (handler) { this._setPref(webPref, settings.uri, true); if (settings.useAsDefault) { wccr.setAutoHandler(getMimeTypeForFeedType(settings.feedType), handler); } msg.target.messageManager .sendAsyncMessage("FeedWriter:SetFeedPrefsAndSubscribeResponse", { redirect: handler.getHandlerURI(settings.feedLocation) }); } else { LOG(`No handler found for web ${settings.feedType} ${settings.uri}`); } break; default: const feedService = Cc["@mozilla.org/browser/feeds/result-service;1"]. getService(Ci.nsIFeedResultService); feedService.addToClientReader(settings.feedLocation, settings.feedTitle, settings.feedSubtitle, settings.feedType, settings.reader); } break; case "FeedConverter:ExecuteClientApp": // Always check feedHandler is from a set array of executable prefs if (EXECUTABLE_PREFS.has(msg.data.feedHandler)) { this.executeClientApp(msg.data.spec, msg.data.title, msg.data.subtitle, msg.data.feedHandler); } else { LOG(`FeedConverter:ExecuteClientApp - Will not exec ${msg.data.feedHandler}`); } break; } }, };