The Tor Browser: comparison mobile/android/modules/WebappManager.jsm

--1:000000000000
+:077b5367a95e
+/* 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/. */
+"use strict";
+this.EXPORTED_SYMBOLS = ["WebappManager"];
+const { classes: Cc, interfaces: Ci, utils: Cu } = Components;
+const UPDATE_URL_PREF = "browser.webapps.updateCheckUrl";
+Cu.import("resource://gre/modules/AppsUtils.jsm");
+Cu.import("resource://gre/modules/XPCOMUtils.jsm");
+Cu.import("resource://gre/modules/Services.jsm");
+Cu.import("resource://gre/modules/NetUtil.jsm");
+Cu.import("resource://gre/modules/FileUtils.jsm");
+Cu.import("resource://gre/modules/DOMRequestHelper.jsm");
+Cu.import("resource://gre/modules/Webapps.jsm");
+Cu.import("resource://gre/modules/osfile.jsm");
+Cu.import("resource://gre/modules/Promise.jsm");
+Cu.import("resource://gre/modules/Task.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "Notifications", "resource://gre/modules/Notifications.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "sendMessageToJava", "resource://gre/modules/Messaging.jsm");
+XPCOMUtils.defineLazyModuleGetter(this, "PluralForm", "resource://gre/modules/PluralForm.jsm");
+XPCOMUtils.defineLazyGetter(this, "Strings", function() {
+return Services.strings.createBundle("chrome://browser/locale/webapp.properties");
+});
+function debug(aMessage) {
+// We use *dump* instead of Services.console.logStringMessage so the messages
+// have the INFO level of severity instead of the ERROR level.  And we don't
+// append a newline character to the end of the message because *dump* spills
+// into the Android native logging system, which strips newlines from messages
+// and breaks messages into lines automatically at display time (i.e. logcat).
+#ifdef DEBUG
+dump(aMessage);
+#endif
+}
+this.WebappManager = {
+__proto__: DOMRequestIpcHelper.prototype,
+get _testing() {
+try {
+return Services.prefs.getBoolPref("browser.webapps.testing");
+} catch(ex) {
+return false;
+}
+},
+install: function(aMessage, aMessageManager) {
+if (this._testing) {
+// Go directly to DOM.  Do not download/install APK, do not collect $200.
+DOMApplicationRegistry.doInstall(aMessage, aMessageManager);
+return;
+}
+this._installApk(aMessage, aMessageManager);
+},
+installPackage: function(aMessage, aMessageManager) {
+if (this._testing) {
+// Go directly to DOM.  Do not download/install APK, do not collect $200.
+DOMApplicationRegistry.doInstallPackage(aMessage, aMessageManager);
+return;
+}
+this._installApk(aMessage, aMessageManager);
+},
+_installApk: function(aMessage, aMessageManager) { return Task.spawn((function*() {
+let filePath;
+try {
+filePath = yield this._downloadApk(aMessage.app.manifestURL);
+} catch(ex) {
+aMessage.error = ex;
+aMessageManager.sendAsyncMessage("Webapps:Install:Return:KO", aMessage);
+debug("error downloading APK: " + ex);
+return;
+}
+sendMessageToJava({
+type: "Webapps:InstallApk",
+filePath: filePath,
+data: JSON.stringify(aMessage),
+});
+}).bind(this)); },
+_downloadApk: function(aManifestUrl) {
+debug("_downloadApk for " + aManifestUrl);
+let deferred = Promise.defer();
+// Get the endpoint URL and convert it to an nsIURI/nsIURL object.
+const GENERATOR_URL_PREF = "browser.webapps.apkFactoryUrl";
+const GENERATOR_URL_BASE = Services.prefs.getCharPref(GENERATOR_URL_PREF);
+let generatorUrl = NetUtil.newURI(GENERATOR_URL_BASE).QueryInterface(Ci.nsIURL);
+// Populate the query part of the URL with the manifest URL parameter.
+let params = {
+manifestUrl: aManifestUrl,
+};
+generatorUrl.query =
+[p + "=" + encodeURIComponent(params[p]) for (p in params)].join("&");
+debug("downloading APK from " + generatorUrl.spec);
+let file = Cc["@mozilla.org/download-manager;1"].
+getService(Ci.nsIDownloadManager).
+defaultDownloadsDirectory.
+clone();
+file.append(aManifestUrl.replace(/[^a-zA-Z0-9]/gi, "") + ".apk");
+file.createUnique(Ci.nsIFile.NORMAL_FILE_TYPE, FileUtils.PERMS_FILE);
+debug("downloading APK to " + file.path);
+let worker = new ChromeWorker("resource://gre/modules/WebappManagerWorker.js");
+worker.onmessage = function(event) {
+let { type, message } = event.data;
+worker.terminate();
+if (type == "success") {
+deferred.resolve(file.path);
+} else { // type == "failure"
+debug("error downloading APK: " + message);
+deferred.reject(message);
+}
+}
+// Trigger the download.
+worker.postMessage({ url: generatorUrl.spec, path: file.path });
+return deferred.promise;
+},
+askInstall: function(aData) {
+let file = Cc["@mozilla.org/file/local;1"].createInstance(Ci.nsILocalFile);
+file.initWithPath(aData.profilePath);
+// We don't yet support pre-installing an appcache because it isn't clear
+// how to do it without degrading the user experience (since users expect
+// apps to be available after the system tells them they've been installed,
+// which has already happened) and because nsCacheService shuts down
+// when we trigger the native install dialog and doesn't re-init itself
+// afterward (TODO: file bug about this behavior).
+if ("appcache_path" in aData.app.manifest) {
+debug("deleting appcache_path from manifest: " + aData.app.manifest.appcache_path);
+delete aData.app.manifest.appcache_path;
+}
+DOMApplicationRegistry.registryReady.then(() => {
+DOMApplicationRegistry.confirmInstall(aData, file, (function(aManifest) {
+let localeManifest = new ManifestHelper(aManifest, aData.app.origin);
+// aData.app.origin may now point to the app: url that hosts this app.
+sendMessageToJava({
+type: "Webapps:Postinstall",
+apkPackageName: aData.app.apkPackageName,
+origin: aData.app.origin,
+});
+this.writeDefaultPrefs(file, localeManifest);
+}).bind(this));
+});
+},
+launch: function({ manifestURL, origin }) {
+debug("launchWebapp: " + manifestURL);
+sendMessageToJava({
+type: "Webapps:Open",
+manifestURL: manifestURL,
+origin: origin
+});
+},
+uninstall: function(aData) {
+debug("uninstall: " + aData.manifestURL);
+if (this._testing) {
+// We don't have to do anything, as the registry does all the work.
+return;
+}
+// TODO: uninstall the APK.
+},
+autoInstall: function(aData) {
+let oldApp = DOMApplicationRegistry.getAppByManifestURL(aData.manifestURL);
+if (oldApp) {
+// If the app is already installed, update the existing installation.
+this._autoUpdate(aData, oldApp);
+return;
+}
+let mm = {
+sendAsyncMessage: function (aMessageName, aData) {
+// TODO hook this back to Java to report errors.
+debug("sendAsyncMessage " + aMessageName + ": " + JSON.stringify(aData));
+}
+};
+let origin = Services.io.newURI(aData.manifestURL, null, null).prePath;
+let message = aData.request || {
+app: {
+origin: origin,
+receipts: [],
+}
+};
+if (aData.updateManifest) {
+if (aData.zipFilePath) {
+aData.updateManifest.package_path = aData.zipFilePath;
+}
+message.app.updateManifest = aData.updateManifest;
+}
+// The manifest url may be subtly different between the
+// time the APK was built and the APK being installed.
+// Thus, we should take the APK as the source of truth.
+message.app.manifestURL = aData.manifestURL;
+message.app.manifest = aData.manifest;
+message.app.apkPackageName = aData.apkPackageName;
+message.profilePath = aData.profilePath;
+message.mm = mm;
+message.apkInstall = true;
+DOMApplicationRegistry.registryReady.then(() => {
+switch (aData.type) { // can be hosted or packaged.
+case "hosted":
+DOMApplicationRegistry.doInstall(message, mm);
+break;
+case "packaged":
+message.isPackage = true;
+DOMApplicationRegistry.doInstallPackage(message, mm);
+break;
+}
+});
+},
+_autoUpdate: function(aData, aOldApp) { return Task.spawn((function*() {
+debug("_autoUpdate app of type " + aData.type);
+if (aOldApp.apkPackageName != aData.apkPackageName) {
+// This happens when the app was installed as a shortcut via the old
+// runtime and is now being updated to an APK.
+debug("update apkPackageName from " + aOldApp.apkPackageName + " to " + aData.apkPackageName);
+aOldApp.apkPackageName = aData.apkPackageName;
+}
+if (aData.type == "hosted") {
+let oldManifest = yield DOMApplicationRegistry.getManifestFor(aData.manifestURL);
+DOMApplicationRegistry.updateHostedApp(aData, aOldApp.id, aOldApp, oldManifest, aData.manifest);
+} else {
+DOMApplicationRegistry.updatePackagedApp(aData, aOldApp.id, aOldApp, aData.manifest);
+}
+}).bind(this)); },
+_checkingForUpdates: false,
+checkForUpdates: function(userInitiated) { return Task.spawn((function*() {
+debug("checkForUpdates");
+// Don't start checking for updates if we're already doing so.
+// TODO: Consider cancelling the old one and starting a new one anyway
+// if the user requested this one.
+if (this._checkingForUpdates) {
+debug("already checking for updates");
+return;
+}
+this._checkingForUpdates = true;
+try {
+let installedApps = yield this._getInstalledApps();
+if (installedApps.length === 0) {
+return;
+}
+// Map APK names to APK versions.
+let apkNameToVersion = yield this._getAPKVersions(installedApps.map(app =>
+app.apkPackageName).filter(apkPackageName => !!apkPackageName)
+);
+// Map manifest URLs to APK versions, which is what the service needs
+// in order to tell us which apps are outdated; and also map them to app
+// objects, which the downloader/installer uses to download/install APKs.
+// XXX Will this cause us to update apps without packages, and if so,
+// does that satisfy the legacy migration story?
+let manifestUrlToApkVersion = {};
+let manifestUrlToApp = {};
+for (let app of installedApps) {
+manifestUrlToApkVersion[app.manifestURL] = apkNameToVersion[app.apkPackageName] || 0;
+manifestUrlToApp[app.manifestURL] = app;
+}
+let outdatedApps = yield this._getOutdatedApps(manifestUrlToApkVersion, userInitiated);
+if (outdatedApps.length === 0) {
+// If the user asked us to check for updates, tell 'em we came up empty.
+if (userInitiated) {
+this._notify({
+title: Strings.GetStringFromName("noUpdatesTitle"),
+message: Strings.GetStringFromName("noUpdatesMessage"),
+icon: "drawable://alert_app",
+});
+}
+return;
+}
+let names = [manifestUrlToApp[url].name for (url of outdatedApps)].join(", ");
+let accepted = yield this._notify({
+title: PluralForm.get(outdatedApps.length, Strings.GetStringFromName("downloadUpdateTitle")).
+replace("#1", outdatedApps.length),
+message: Strings.formatStringFromName("downloadUpdateMessage", [names], 1),
+icon: "drawable://alert_app",
+}).dismissed;
+if (accepted) {
+yield this._updateApks([manifestUrlToApp[url] for (url of outdatedApps)]);
+}
+}
+// There isn't a catch block because we want the error to propagate through
+// the promise chain, so callers can receive it and choose to respond to it.
+finally {
+// Ensure we update the _checkingForUpdates flag even if there's an error;
+// otherwise the process will get stuck and never check for updates again.
+this._checkingForUpdates = false;
+}
+}).bind(this)); },
+_getAPKVersions: function(packageNames) {
+let deferred = Promise.defer();
+sendMessageToJava({
+type: "Webapps:GetApkVersions",
+packageNames: packageNames
+}, data => deferred.resolve(data.versions));
+return deferred.promise;
+},
+_getInstalledApps: function() {
+let deferred = Promise.defer();
+DOMApplicationRegistry.getAll(apps => deferred.resolve(apps));
+return deferred.promise;
+},
+_getOutdatedApps: function(installedApps, userInitiated) {
+let deferred = Promise.defer();
+let data = JSON.stringify({ installed: installedApps });
+let notification;
+if (userInitiated) {
+notification = this._notify({
+title: Strings.GetStringFromName("checkingForUpdatesTitle"),
+message: Strings.GetStringFromName("checkingForUpdatesMessage"),
+// TODO: replace this with an animated icon.
+icon: "drawable://alert_app",
+progress: NaN,
+});
+}
+let request = Cc["@mozilla.org/xmlextras/xmlhttprequest;1"].
+createInstance(Ci.nsIXMLHttpRequest).
+QueryInterface(Ci.nsIXMLHttpRequestEventTarget);
+request.mozBackgroundRequest = true;
+request.open("POST", Services.prefs.getCharPref(UPDATE_URL_PREF), true);
+request.channel.loadFlags = Ci.nsIChannel.LOAD_ANONYMOUS |
+Ci.nsIChannel.LOAD_BYPASS_CACHE |
+Ci.nsIChannel.INHIBIT_CACHING;
+request.onload = function() {
+if (userInitiated) {
+notification.cancel();
+}
+deferred.resolve(JSON.parse(this.response).outdated);
+};
+request.onerror = function() {
+if (userInitiated) {
+notification.cancel();
+}
+deferred.reject(this.status || this.statusText);
+};
+request.setRequestHeader("Content-Type", "application/json");
+request.setRequestHeader("Content-Length", data.length);
+request.send(data);
+return deferred.promise;
+},
+_updateApks: function(aApps) { return Task.spawn((function*() {
+// Notify the user that we're in the progress of downloading updates.
+let downloadingNames = [app.name for (app of aApps)].join(", ");
+let notification = this._notify({
+title: PluralForm.get(aApps.length, Strings.GetStringFromName("downloadingUpdateTitle")).
+replace("#1", aApps.length),
+message: Strings.formatStringFromName("downloadingUpdateMessage", [downloadingNames], 1),
+// TODO: replace this with an animated icon.  UpdateService uses
+// android.R.drawable.stat_sys_download, but I don't think we can reference
+// a system icon with a drawable: URL here, so we'll have to craft our own.
+icon: "drawable://alert_download",
+// TODO: make this a determinate progress indicator once we can determine
+// the sizes of the APKs and observe their progress.
+progress: NaN,
+});
+// Download the APKs for the given apps.  We do this serially to avoid
+// saturating the user's network connection.
+// TODO: download APKs in parallel (or at least more than one at a time)
+// if it seems reasonable.
+let downloadedApks = [];
+let downloadFailedApps = [];
+for (let app of aApps) {
+try {
+let filePath = yield this._downloadApk(app.manifestURL);
+downloadedApks.push({ app: app, filePath: filePath });
+} catch(ex) {
+downloadFailedApps.push(app);
+}
+}
+notification.cancel();
+// Notify the user if any downloads failed, but don't do anything
+// when the user accepts/cancels the notification.
+// In the future, we might prompt the user to retry the download.
+if (downloadFailedApps.length > 0) {
+let downloadFailedNames = [app.name for (app of downloadFailedApps)].join(", ");
+this._notify({
+title: PluralForm.get(downloadFailedApps.length, Strings.GetStringFromName("downloadFailedTitle")).
+replace("#1", downloadFailedApps.length),
+message: Strings.formatStringFromName("downloadFailedMessage", [downloadFailedNames], 1),
+icon: "drawable://alert_app",
+});
+}
+// If we weren't able to download any APKs, then there's nothing more to do.
+if (downloadedApks.length === 0) {
+return;
+}
+// Prompt the user to update the apps for which we downloaded APKs, and wait
+// until they accept/cancel the notification.
+let downloadedNames = [apk.app.name for (apk of downloadedApks)].join(", ");
+let accepted = yield this._notify({
+title: PluralForm.get(downloadedApks.length, Strings.GetStringFromName("installUpdateTitle")).
+replace("#1", downloadedApks.length),
+message: Strings.formatStringFromName("installUpdateMessage", [downloadedNames], 1),
+icon: "drawable://alert_app",
+}).dismissed;
+if (accepted) {
+// The user accepted the notification, so install the downloaded APKs.
+for (let apk of downloadedApks) {
+let msg = {
+app: apk.app,
+// TODO: figure out why Webapps:InstallApk needs the "from" property.
+from: apk.app.installOrigin,
+};
+sendMessageToJava({
+type: "Webapps:InstallApk",
+filePath: apk.filePath,
+data: JSON.stringify(msg),
+});
+}
+} else {
+// The user cancelled the notification, so remove the downloaded APKs.
+for (let apk of downloadedApks) {
+try {
+yield OS.file.remove(apk.filePath);
+} catch(ex) {
+debug("error removing " + apk.filePath + " for cancelled update: " + ex);
+}
+}
+}
+}).bind(this)); },
+_notify: function(aOptions) {
+dump("_notify: " + aOptions.title);
+// Resolves to true if the notification is "clicked" (i.e. touched)
+// and false if the notification is "cancelled" by swiping it away.
+let dismissed = Promise.defer();
+// TODO: make notifications expandable so users can expand them to read text
+// that gets cut off in standard notifications.
+let id = Notifications.create({
+title: aOptions.title,
+message: aOptions.message,
+icon: aOptions.icon,
+progress: aOptions.progress,
+onClick: function(aId, aCookie) {
+dismissed.resolve(true);
+},
+onCancel: function(aId, aCookie) {
+dismissed.resolve(false);
+},
+});
+// Return an object with a promise that resolves when the notification
+// is dismissed by the user along with a method for cancelling it,
+// so callers who want to wait for user action can do so, while those
+// who want to control the notification's lifecycle can do that instead.
+return {
+dismissed: dismissed.promise,
+cancel: function() {
+Notifications.cancel(id);
+},
+};
+},
+autoUninstall: function(aData) {
+DOMApplicationRegistry.registryReady.then(() => {
+for (let id in DOMApplicationRegistry.webapps) {
+let app = DOMApplicationRegistry.webapps[id];
+if (aData.apkPackageNames.indexOf(app.apkPackageName) > -1) {
+debug("attempting to uninstall " + app.name);
+DOMApplicationRegistry.uninstall(
+app.manifestURL,
+function() {
+debug("success uninstalling " + app.name);
+},
+function(error) {
+debug("error uninstalling " + app.name + ": " + error);
+}
+);
+}
+}
+});
+},
+writeDefaultPrefs: function(aProfile, aManifest) {
+// build any app specific default prefs
+let prefs = [];
+if (aManifest.orientation) {
+let orientation = aManifest.orientation;
+if (Array.isArray(orientation)) {
+orientation = orientation.join(",");
+}
+prefs.push({ name: "app.orientation.default", value: orientation });
+}
+// write them into the app profile
+let defaultPrefsFile = aProfile.clone();
+defaultPrefsFile.append(this.DEFAULT_PREFS_FILENAME);
+this._writeData(defaultPrefsFile, prefs);
+},
+_writeData: function(aFile, aPrefs) {
+if (aPrefs.length > 0) {
+let array = new TextEncoder().encode(JSON.stringify(aPrefs));
+OS.File.writeAtomic(aFile.path, array, { tmpPath: aFile.path + ".tmp" }).then(null, function onError(reason) {
+debug("Error writing default prefs: " + reason);
+});
+}
+},
+DEFAULT_PREFS_FILENAME: "default-prefs.js",
+};

The Tor Browser / file comparison

comparison: mobile/android/modules/WebappManager.jsm

mobile/android/modules/WebappManager.jsm