зеркало из https://github.com/mozilla/gecko-dev.git
352 строки
12 KiB
JavaScript
352 строки
12 KiB
JavaScript
/* ***** BEGIN LICENSE BLOCK *****
|
|
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
|
|
*
|
|
* The contents of this file are subject to the Mozilla Public License Version
|
|
* 1.1 (the "License"); you may not use this file except in compliance with
|
|
* the License. You may obtain a copy of the License at
|
|
* http://www.mozilla.org/MPL/
|
|
*
|
|
* Software distributed under the License is distributed on an "AS IS" basis,
|
|
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
|
|
* for the specific language governing rights and limitations under the
|
|
* License.
|
|
*
|
|
* The Original Code is Mozilla Mobile Browser.
|
|
*
|
|
* The Initial Developer of the Original Code is Mozilla.
|
|
* Portions created by the Initial Developer are Copyright (C) 2011
|
|
* the Initial Developer. All Rights Reserved.
|
|
*
|
|
* Contributor(s):
|
|
* Mark Finkle <mfinkle@mozilla.com>
|
|
* Wes Johnston <wjohnston@mozilla.com>
|
|
*
|
|
* Alternatively, the contents of this file may be used under the terms of
|
|
* either the GNU General Public License Version 2 or later (the "GPL"), or
|
|
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
|
|
* in which case the provisions of the GPL or the LGPL are applicable instead
|
|
* of those above. If you wish to allow use of your version of this file only
|
|
* under the terms of either the GPL or the LGPL, and not to allow others to
|
|
* use your version of this file under the terms of the MPL, indicate your
|
|
* decision by deleting the provisions above and replace them with the notice
|
|
* and other provisions required by the GPL or the LGPL. If you do not delete
|
|
* the provisions above, a recipient may use your version of this file under
|
|
* the terms of any one of the MPL, the GPL or the LGPL.
|
|
*
|
|
* ***** END LICENSE BLOCK ***** */
|
|
|
|
let EXPORTED_SYMBOLS = ["LocaleRepository"];
|
|
|
|
const Cc = Components.classes;
|
|
const Ci = Components.interfaces;
|
|
const Cu = Components.utils;
|
|
|
|
Cu.import("resource://gre/modules/Services.jsm");
|
|
Cu.import("resource://gre/modules/AddonManager.jsm");
|
|
Cu.import("resource://gre/modules/NetUtil.jsm");
|
|
|
|
// A map between XML keys to LocaleSearchResult keys for string values
|
|
// that require no extra parsing from XML
|
|
const STRING_KEY_MAP = {
|
|
name: "name",
|
|
target_locale: "targetLocale",
|
|
version: "version",
|
|
icon: "iconURL",
|
|
homepage: "homepageURL",
|
|
support: "supportURL",
|
|
strings: "strings"
|
|
};
|
|
|
|
var LocaleRepository = {
|
|
loggingEnabled: false,
|
|
|
|
log: function(aMessage) {
|
|
if (this.loggingEnabled)
|
|
dump(aMessage + "\n");
|
|
},
|
|
|
|
_getUniqueDescendant: function _getUniqueDescendant(aElement, aTagName) {
|
|
let elementsList = aElement.getElementsByTagName(aTagName);
|
|
return (elementsList.length == 1) ? elementsList[0] : null;
|
|
},
|
|
|
|
_getTextContent: function _getTextContent(aElement) {
|
|
let textContent = aElement.textContent.trim();
|
|
return (textContent.length > 0) ? textContent : null;
|
|
},
|
|
|
|
_getDescendantTextContent: function _getDescendantTextContent(aElement, aTagName) {
|
|
let descendant = this._getUniqueDescendant(aElement, aTagName);
|
|
return (descendant != null) ? this._getTextContent(descendant) : null;
|
|
},
|
|
|
|
getLocales: function getLocales(aCallback, aFilters) {
|
|
let url = Services.prefs.getCharPref("extensions.getLocales.get.url");
|
|
|
|
if (!url) {
|
|
aCallback([]);
|
|
return;
|
|
}
|
|
|
|
let buildID = Cc["@mozilla.org/xre/app-info;1"].getService(Ci.nsIXULAppInfo).QueryInterface(Ci.nsIXULRuntime).appBuildID;
|
|
if (aFilters) {
|
|
if (aFilters.buildID)
|
|
buildID = aFilters.buildID;
|
|
}
|
|
buildID = buildID.substring(0,4) + "-" + buildID.substring(4).replace(/\d{2}(?=\d)/g, "$&-");
|
|
url = url.replace(/%BUILDID_EXPANDED%/g, buildID);
|
|
url = Services.urlFormatter.formatURL(url);
|
|
|
|
let request = Cc["@mozilla.org/xmlextras/xmlhttprequest;1"].createInstance(Ci.nsIXMLHttpRequest);
|
|
request.mozBackgroundRequest = true;
|
|
request.open("GET", url, true);
|
|
request.overrideMimeType("text/xml");
|
|
|
|
let self = this;
|
|
request.addEventListener("readystatechange", function () {
|
|
if (request.readyState == 4) {
|
|
if (request.status == 200) {
|
|
self.log("---- got response")
|
|
let documentElement = request.responseXML.documentElement;
|
|
let elements = documentElement.getElementsByTagName("addon");
|
|
let totalResults = elements.length;
|
|
let parsedTotalResults = parseInt(documentElement.getAttribute("total_results"));
|
|
if (parsedTotalResults >= totalResults)
|
|
totalResults = parsedTotalResults;
|
|
|
|
// TODO: Create a real Skip object from installed locales
|
|
self._parseLocales(elements, totalResults, { ids: [], sourceURIs: [] }, aCallback);
|
|
} else {
|
|
Cu.reportError("Locale Repository: Error getting locale from AMO [" + request.status + "]");
|
|
}
|
|
}
|
|
}, false);
|
|
|
|
request.send(null);
|
|
},
|
|
|
|
_parseLocale: function _parseLocale(aElement, aSkip) {
|
|
let skipIDs = (aSkip && aSkip.ids) ? aSkip.ids : [];
|
|
let skipSourceURIs = (aSkip && aSkip.sourceURIs) ? aSkip.sourceURIs : [];
|
|
|
|
let guid = this._getDescendantTextContent(aElement, "guid");
|
|
if (guid == null || skipIDs.indexOf(guid) != -1)
|
|
return null;
|
|
|
|
let addon = new LocaleSearchResult(guid);
|
|
let result = {
|
|
addon: addon,
|
|
xpiURL: null,
|
|
xpiHash: null
|
|
};
|
|
|
|
let self = this;
|
|
for (let node = aElement.firstChild; node; node = node.nextSibling) {
|
|
if (!(node instanceof Ci.nsIDOMElement))
|
|
continue;
|
|
|
|
let localName = node.localName;
|
|
|
|
// Handle case where the wanted string value is located in text content
|
|
// but only if the content is not empty
|
|
if (localName in STRING_KEY_MAP) {
|
|
addon[STRING_KEY_MAP[localName]] = this._getTextContent(node) || addon[STRING_KEY_MAP[localName]];
|
|
continue;
|
|
}
|
|
|
|
// Handle cases that aren't as simple as grabbing the text content
|
|
switch (localName) {
|
|
case "type":
|
|
// Map AMO's type id to corresponding string
|
|
let id = parseInt(node.getAttribute("id"));
|
|
switch (id) {
|
|
case 5:
|
|
addon.type = "language";
|
|
break;
|
|
default:
|
|
this.log("Unknown type id when parsing addon: " + id);
|
|
}
|
|
break;
|
|
case "authors":
|
|
let authorNodes = node.getElementsByTagName("author");
|
|
Array.forEach(authorNodes, function(aAuthorNode) {
|
|
let name = self._getDescendantTextContent(aAuthorNode, "name");
|
|
if (name == null)
|
|
name = self._getTextContent(aAuthorNode);
|
|
let link = self._getDescendantTextContent(aAuthorNode, "link");
|
|
if (name == null && link == null)
|
|
return;
|
|
|
|
let author = { name: name, link: link };
|
|
if (addon.creator == null) {
|
|
addon.creator = author;
|
|
} else {
|
|
if (addon.developers == null)
|
|
addon.developers = [];
|
|
|
|
addon.developers.push(author);
|
|
}
|
|
});
|
|
break;
|
|
case "status":
|
|
let repositoryStatus = parseInt(node.getAttribute("id"));
|
|
if (!isNaN(repositoryStatus))
|
|
addon.repositoryStatus = repositoryStatus;
|
|
break;
|
|
case "all_compatible_os":
|
|
let nodes = node.getElementsByTagName("os");
|
|
addon.isPlatformCompatible = Array.some(nodes, function(aNode) {
|
|
let text = aNode.textContent.toLowerCase().trim();
|
|
return text == "all" || text == Services.appinfo.OS.toLowerCase();
|
|
});
|
|
break;
|
|
case "install":
|
|
// No os attribute means the xpi is compatible with any os
|
|
if (node.hasAttribute("os") && node.getAttribute("os")) {
|
|
let os = node.getAttribute("os").trim().toLowerCase();
|
|
// If the os is not ALL and not the current OS then ignore this xpi
|
|
if (os != "all" && os != Services.appinfo.OS.toLowerCase())
|
|
break;
|
|
}
|
|
|
|
let xpiURL = this._getTextContent(node);
|
|
if (xpiURL == null)
|
|
break;
|
|
|
|
if (skipSourceURIs.indexOf(xpiURL) != -1)
|
|
return null;
|
|
|
|
result.xpiURL = xpiURL;
|
|
try {
|
|
addon.sourceURI = NetUtil.newURI(xpiURL);
|
|
} catch(ex) {
|
|
this.log("Addon has invalid uri: " + addon.sourceURI);
|
|
addon.sourceURI = null;
|
|
}
|
|
|
|
let size = parseInt(node.getAttribute("size"));
|
|
addon.size = (size >= 0) ? size : null;
|
|
|
|
let xpiHash = node.getAttribute("hash");
|
|
if (xpiHash != null)
|
|
xpiHash = xpiHash.trim();
|
|
result.xpiHash = xpiHash ? xpiHash : null;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
},
|
|
|
|
_parseLocales: function _parseLocales(aElements, aTotalResults, aSkip, aCallback) {
|
|
let self = this;
|
|
let results = [];
|
|
for (let i = 0; i < aElements.length; i++) {
|
|
let element = aElements[i];
|
|
|
|
// Ignore add-ons not compatible with this Application
|
|
let tags = this._getUniqueDescendant(element, "compatible_applications");
|
|
if (tags == null)
|
|
continue;
|
|
|
|
let applications = tags.getElementsByTagName("appID");
|
|
let compatible = Array.some(applications, function(aAppNode) {
|
|
if (self._getTextContent(aAppNode) != Services.appinfo.ID)
|
|
return false;
|
|
|
|
let parent = aAppNode.parentNode;
|
|
let minVersion = self._getDescendantTextContent(parent, "min_version");
|
|
let maxVersion = self._getDescendantTextContent(parent, "max_version");
|
|
if (minVersion == null || maxVersion == null)
|
|
return false;
|
|
|
|
let currentVersion = Services.appinfo.version;
|
|
return (Services.vc.compare(minVersion, currentVersion) <= 0 && Services.vc.compare(currentVersion, maxVersion) <= 0);
|
|
});
|
|
|
|
if (!compatible)
|
|
continue;
|
|
|
|
// Add-on meets all requirements, so parse out data
|
|
let result = this._parseLocale(element, aSkip);
|
|
if (result == null)
|
|
continue;
|
|
|
|
// Ignore add-on missing a required attribute
|
|
let requiredAttributes = ["id", "name", "version", "type", "targetLocale", "sourceURI"];
|
|
if (requiredAttributes.some(function(aAttribute) !result.addon[aAttribute]))
|
|
continue;
|
|
|
|
// Add only if the add-on is compatible with the platform
|
|
if (!result.addon.isPlatformCompatible)
|
|
continue;
|
|
|
|
// Add only if there was an xpi compatible with this OS
|
|
if (!result.xpiURL)
|
|
continue;
|
|
|
|
results.push(result);
|
|
|
|
// Ignore this add-on from now on by adding it to the skip array
|
|
aSkip.ids.push(result.addon.id);
|
|
}
|
|
|
|
// Immediately report success if no AddonInstall instances to create
|
|
let pendingResults = results.length;
|
|
if (pendingResults == 0) {
|
|
aCallback([]);
|
|
return;
|
|
}
|
|
|
|
// Create an AddonInstall for each result
|
|
let self = this;
|
|
results.forEach(function(aResult) {
|
|
let addon = aResult.addon;
|
|
let callback = function(aInstall) {
|
|
aResult.addon.install = aInstall;
|
|
pendingResults--;
|
|
if (pendingResults == 0)
|
|
aCallback(results);
|
|
}
|
|
|
|
if (aResult.xpiURL) {
|
|
AddonManager.getInstallForURL(aResult.xpiURL, callback,
|
|
"application/x-xpinstall", aResult.xpiHash,
|
|
addon.name, addon.iconURL, addon.version);
|
|
} else {
|
|
callback(null);
|
|
}
|
|
});
|
|
}
|
|
};
|
|
|
|
function LocaleSearchResult(aId) {
|
|
this.id = aId;
|
|
}
|
|
|
|
LocaleSearchResult.prototype = {
|
|
id: null,
|
|
type: null,
|
|
targetLocale: null,
|
|
name: null,
|
|
addon: null,
|
|
version: null,
|
|
iconURL: null,
|
|
install: null,
|
|
sourceURI: null,
|
|
repositoryStatus: null,
|
|
size: null,
|
|
strings: "",
|
|
updateDate: null,
|
|
isCompatible: true,
|
|
isPlatformCompatible: true,
|
|
providesUpdatesSecurely: true,
|
|
blocklistState: Ci.nsIBlocklistService.STATE_NOT_BLOCKED,
|
|
appDisabled: false,
|
|
userDisabled: false,
|
|
scope: AddonManager.SCOPE_PROFILE,
|
|
isActive: true,
|
|
pendingOperations: AddonManager.PENDING_NONE,
|
|
permissions: 0
|
|
};
|