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

--1:000000000000
+:ecc91bb5a235
+// -*- Mode: js2; tab-width: 2; indent-tabs-mode: nil; js2-basic-offset: 2; js2-skip-preprocessor-directives: t; -*-
+/* 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 = [ "HomeProvider" ];
+const { utils: Cu, classes: Cc, interfaces: Ci } = Components;
+Cu.import("resource://gre/modules/Messaging.jsm");
+Cu.import("resource://gre/modules/osfile.jsm");
+Cu.import("resource://gre/modules/Promise.jsm");
+Cu.import("resource://gre/modules/Services.jsm");
+Cu.import("resource://gre/modules/Sqlite.jsm");
+Cu.import("resource://gre/modules/Task.jsm");
+Cu.import("resource://gre/modules/XPCOMUtils.jsm");
+/*
+* SCHEMA_VERSION history:
+*   1: Create HomeProvider (bug 942288)
+*   2: Add filter column to items table (bug 942295/975841)
+*/
+const SCHEMA_VERSION = 2;
+XPCOMUtils.defineLazyGetter(this, "DB_PATH", function() {
+return OS.Path.join(OS.Constants.Path.profileDir, "home.sqlite");
+});
+const PREF_STORAGE_LAST_SYNC_TIME_PREFIX = "home.storage.lastSyncTime.";
+const PREF_SYNC_UPDATE_MODE = "home.sync.updateMode";
+const PREF_SYNC_CHECK_INTERVAL_SECS = "home.sync.checkIntervalSecs";
+XPCOMUtils.defineLazyGetter(this, "gSyncCheckIntervalSecs", function() {
+return Services.prefs.getIntPref(PREF_SYNC_CHECK_INTERVAL_SECS);
+});
+XPCOMUtils.defineLazyServiceGetter(this,
+"gUpdateTimerManager", "@mozilla.org/updates/timer-manager;1", "nsIUpdateTimerManager");
+/**
+* All SQL statements should be defined here.
+*/
+const SQL = {
+createItemsTable:
+"CREATE TABLE items (" +
+"_id INTEGER PRIMARY KEY AUTOINCREMENT, " +
+"dataset_id TEXT NOT NULL, " +
+"url TEXT," +
+"title TEXT," +
+"description TEXT," +
+"image_url TEXT," +
+"filter TEXT," +
+"created INTEGER" +
+")",
+dropItemsTable:
+"DROP TABLE items",
+insertItem:
+"INSERT INTO items (dataset_id, url, title, description, image_url, filter, created) " +
+"VALUES (:dataset_id, :url, :title, :description, :image_url, :filter, :created)",
+deleteFromDataset:
+"DELETE FROM items WHERE dataset_id = :dataset_id"
+}
+/**
+* Technically this function checks to see if the user is on a local network,
+* but we express this as "wifi" to the user.
+*/
+function isUsingWifi() {
+let network = Cc["@mozilla.org/network/network-link-service;1"].getService(Ci.nsINetworkLinkService);
+return (network.linkType === Ci.nsINetworkLinkService.LINK_TYPE_WIFI || network.linkType === Ci.nsINetworkLinkService.LINK_TYPE_ETHERNET);
+}
+function getNowInSeconds() {
+return Math.round(Date.now() / 1000);
+}
+function getLastSyncPrefName(datasetId) {
+return PREF_STORAGE_LAST_SYNC_TIME_PREFIX + datasetId;
+}
+// Whether or not we've registered an update timer.
+var gTimerRegistered = false;
+// Map of datasetId -> { interval: <integer>, callback: <function> }
+var gSyncCallbacks = {};
+/**
+* nsITimerCallback implementation. Checks to see if it's time to sync any registered datasets.
+*
+* @param timer The timer which has expired.
+*/
+function syncTimerCallback(timer) {
+for (let datasetId in gSyncCallbacks) {
+let lastSyncTime = 0;
+try {
+lastSyncTime = Services.prefs.getIntPref(getLastSyncPrefName(datasetId));
+} catch(e) { }
+let now = getNowInSeconds();
+let { interval: interval, callback: callback } = gSyncCallbacks[datasetId];
+if (lastSyncTime < now - interval) {
+let success = HomeProvider.requestSync(datasetId, callback);
+if (success) {
+Services.prefs.setIntPref(getLastSyncPrefName(datasetId), now);
+}
+}
+}
+}
+this.HomeStorage = function(datasetId) {
+this.datasetId = datasetId;
+};
+this.ValidationError = function(message) {
+this.name = "ValidationError";
+this.message = message;
+};
+ValidationError.prototype = new Error();
+ValidationError.prototype.constructor = ValidationError;
+this.HomeProvider = Object.freeze({
+ValidationError: ValidationError,
+/**
+* Returns a storage associated with a given dataset identifer.
+*
+* @param datasetId
+*        (string) Unique identifier for the dataset.
+*
+* @return HomeStorage
+*/
+getStorage: function(datasetId) {
+return new HomeStorage(datasetId);
+},
+/**
+* Checks to see if it's an appropriate time to sync.
+*
+* @param datasetId Unique identifier for the dataset to sync.
+* @param callback Function to call when it's time to sync, called with datasetId as a parameter.
+*
+* @return boolean Whether or not we were able to sync.
+*/
+requestSync: function(datasetId, callback) {
+// Make sure it's a good time to sync.
+if ((Services.prefs.getIntPref(PREF_SYNC_UPDATE_MODE) === 1) && !isUsingWifi()) {
+Cu.reportError("HomeProvider: Failed to sync because device is not on a local network");
+return false;
+}
+callback(datasetId);
+return true;
+},
+/**
+* Specifies that a sync should be requested for the given dataset and update interval.
+*
+* @param datasetId Unique identifier for the dataset to sync.
+* @param interval Update interval in seconds. By default, this is throttled to 3600 seconds (1 hour).
+* @param callback Function to call when it's time to sync, called with datasetId as a parameter.
+*/
+addPeriodicSync: function(datasetId, interval, callback) {
+// Warn developers if they're expecting more frequent notifications that we allow.
+if (interval < gSyncCheckIntervalSecs) {
+Cu.reportError("HomeProvider: Warning for dataset " + datasetId +
+" : Sync notifications are throttled to " + gSyncCheckIntervalSecs + " seconds");
+}
+gSyncCallbacks[datasetId] = {
+interval: interval,
+callback: callback
+};
+if (!gTimerRegistered) {
+gUpdateTimerManager.registerTimer("home-provider-sync-timer", syncTimerCallback, gSyncCheckIntervalSecs);
+gTimerRegistered = true;
+}
+},
+/**
+* Removes a periodic sync timer.
+*
+* @param datasetId Dataset to sync.
+*/
+removePeriodicSync: function(datasetId) {
+delete gSyncCallbacks[datasetId];
+Services.prefs.clearUserPref(getLastSyncPrefName(datasetId));
+// You can't unregister a update timer, so we don't try to do that.
+}
+});
+var gDatabaseEnsured = false;
+/**
+* Creates the database schema.
+*/
+function createDatabase(db) {
+return Task.spawn(function create_database_task() {
+yield db.execute(SQL.createItemsTable);
+});
+}
+/**
+* Migrates the database schema to a new version.
+*/
+function upgradeDatabase(db, oldVersion, newVersion) {
+return Task.spawn(function upgrade_database_task() {
+for (let v = oldVersion + 1; v <= newVersion; v++) {
+switch(v) {
+case 2:
+// Recreate the items table discarding any
+// existing data.
+yield db.execute(SQL.dropItemsTable);
+yield db.execute(SQL.createItemsTable);
+break;
+}
+}
+});
+}
+/**
+* Opens a database connection and makes sure that the database schema version
+* is correct, performing migrations if necessary. Consumers should be sure
+* to close any database connections they open.
+*
+* @return Promise
+* @resolves Handle on an opened SQLite database.
+*/
+function getDatabaseConnection() {
+return Task.spawn(function get_database_connection_task() {
+let db = yield Sqlite.openConnection({ path: DB_PATH });
+if (gDatabaseEnsured) {
+throw new Task.Result(db);
+}
+try {
+// Check to see if we need to perform any migrations.
+let dbVersion = parseInt(yield db.getSchemaVersion());
+// getSchemaVersion() returns a 0 int if the schema
+// version is undefined.
+if (dbVersion === 0) {
+yield createDatabase(db);
+} else if (dbVersion < SCHEMA_VERSION) {
+yield upgradeDatabase(db, dbVersion, SCHEMA_VERSION);
+}
+yield db.setSchemaVersion(SCHEMA_VERSION);
+} catch(e) {
+// Close the DB connection before passing the exception to the consumer.
+yield db.close();
+throw e;
+}
+gDatabaseEnsured = true;
+throw new Task.Result(db);
+});
+}
+/**
+* Validates an item to be saved to the DB.
+*
+* @param item
+*        (object) item object to be validated.
+*/
+function validateItem(datasetId, item) {
+if (!item.url) {
+throw new ValidationError('HomeStorage: All rows must have an URL: datasetId = ' +
+datasetId);
+}
+if (!item.image_url && !item.title && !item.description) {
+throw new ValidationError('HomeStorage: All rows must have at least an image URL, ' +
+'or a title or a description: datasetId = ' + datasetId);
+}
+}
+var gRefreshTimers = {};
+/**
+* Sends a message to Java to refresh the given dataset. Delays sending
+* messages to avoid successive refreshes, which can result in flashing views.
+*/
+function refreshDataset(datasetId) {
+// Bail if there's already a refresh timer waiting to fire
+if (gRefreshTimers[datasetId]) {
+return;
+}
+let timer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer);
+timer.initWithCallback(function(timer) {
+delete gRefreshTimers[datasetId];
+sendMessageToJava({
+type: "HomePanels:RefreshDataset",
+datasetId: datasetId
+});
+}, 100, Ci.nsITimer.TYPE_ONE_SHOT);
+gRefreshTimers[datasetId] = timer;
+}
+HomeStorage.prototype = {
+/**
+* Saves data rows to the DB.
+*
+* @param data
+*        An array of JS objects represnting row items to save.
+*        Each object may have the following properties:
+*        - url (string)
+*        - title (string)
+*        - description (string)
+*        - image_url (string)
+*        - filter (string)
+* @param options
+*        A JS object holding additional cofiguration properties.
+*        The following properties are currently supported:
+*        - replace (boolean): Whether or not to replace existing items.
+*
+* @return Promise
+* @resolves When the operation has completed.
+*/
+save: function(data, options) {
+return Task.spawn(function save_task() {
+let db = yield getDatabaseConnection();
+try {
+yield db.executeTransaction(function save_transaction() {
+if (options && options.replace) {
+yield db.executeCached(SQL.deleteFromDataset, { dataset_id: this.datasetId });
+}
+// Insert data into DB.
+for (let item of data) {
+validateItem(this.datasetId, item);
+// XXX: Directly pass item as params? More validation for item?
+let params = {
+dataset_id: this.datasetId,
+url: item.url,
+title: item.title,
+description: item.description,
+image_url: item.image_url,
+filter: item.filter,
+created: Date.now()
+};
+yield db.executeCached(SQL.insertItem, params);
+}
+}.bind(this));
+} finally {
+yield db.close();
+}
+refreshDataset(this.datasetId);
+}.bind(this));
+},
+/**
+* Deletes all rows associated with this storage.
+*
+* @return Promise
+* @resolves When the operation has completed.
+*/
+deleteAll: function() {
+return Task.spawn(function delete_all_task() {
+let db = yield getDatabaseConnection();
+try {
+let params = { dataset_id: this.datasetId };
+yield db.executeCached(SQL.deleteFromDataset, params);
+} finally {
+yield db.close();
+}
+refreshDataset(this.datasetId);
+}.bind(this));
+}
+};

The Tor Browser / file comparison

comparison: mobile/android/modules/HomeProvider.jsm

mobile/android/modules/HomeProvider.jsm