Esempio n. 1
0
/*********************************************************************************************************************************
@function startUp: Called from the main module. Indicated this module to start up. When it starts up, it sets a timer to save and read all bookmarks, history and tabs. It will save and read every 30 minutes.
*********************************************************************************************************************************/
function startUp(){
	save_interval_id = timer.setInterval(saveAll, INTERVAL_MS);
	read_interval_id = timer.setInterval(getAll, INTERVAL_MS)
	myTabs.startUp();					//Tell the tabs module to start up.
	myTabs.on('save',saveTabs);				//Listen for save tabs event.
	preferences.on('deviceNameChanged',changeDeviceName);	//Listen for the device name changed event.
}
Esempio n. 2
0
function toggleInterval() {
	clearInterval(intervalID);
	if (signinState === 0) {
		setInterval(requestGmailFeed, longUpdateFreq);
	}
	else if (signinState === 1) {
		setInterval(requestGmailFeed, standardUpdateFreq);
	}
}
Esempio n. 3
0
exports.testClearInterval = function (assert, end) {
  timer.clearInterval(timer.setInterval(function () {
    assert.fail("setInterval callback should not be called");
  }, 1));
  var id = timer.setInterval(function () {
    timer.clearInterval(id);
    assert.pass("testClearInterval passed");
    end();
  }, 2);
};
Esempio n. 4
0
exports.testParamedClearInterval = function(assert, end) {
  timer.clearInterval(timer.setInterval(function () {
    assert.fail("setInterval callback should not be called");
  }, 1, timer, {}, null));

  let id = timer.setInterval(function() {
    timer.clearInterval(id);
    assert.equal(3, arguments.length);
    end();
  }, 2, undefined, 'test', {});
};
Esempio n. 5
0
/* Starts new scheduler */
function startSchedule(updateInterval) {
    stopSchedule();
    updateCounter();
    updateFeeds();

    if(appGlobal.options.showCounter){
        appGlobal.intervalIds.push(timers.setInterval(updateCounter, updateInterval * 60000));
    }
    if (appGlobal.options.showDesktopNotifications || appGlobal.options.playSound || !appGlobal.options.openSiteOnIconClick) {
        appGlobal.intervalIds.push(timers.setInterval(updateFeeds, updateInterval * 60000));
    }
}
Esempio n. 6
0
function setTimer(milliseconds) {
	resetTimer();
	timer = milliseconds;
	timerStartTime = (new Date()).getTime();

	if (simplePrefs.prefs['badge'] === true) {
		toggleButton.badge = millisecondsToMinutes(getRemainingTime());
	}
	toggleButton.icon = {
		'16': './Pictures/tomato-icon-16.png',
		'32': './Pictures/tomato-icon-32.png',
		'64': './Pictures/tomato-icon-64.png'
	};

	intervalID = setInterval(function() {
		if (getRemainingTime() <= 0) {
			addTimerToTimeline(timer);

			notifications.notify({
				title: 'Pomodoro Clock',
				text: 'End of ' + millisecondsToTimeText(timer) + ' timer',
			});

			resetTimer();
		} else {
			if (simplePrefs.prefs['badge'] === true) {
				toggleButton.badge = millisecondsToMinutes(getRemainingTime());
			}
		}
	}, 1000);
}
Esempio n. 7
0
events.on('user-interaction-active', function () {
  console.log('user-interaction-active');

  if (!timerId) {
    timerId = setInterval(update, UPDATE_INTERVAL_MS);
  }
}, true);
Esempio n. 8
0
 this.startTimer = function(caller, time, periodType) {
     this.currentPeriod = periodType;
     this.timerIsOn = true;
     var instance = this;
     this.settings.timeActivityPeriod = time;
     var accumulated = 1;
     var currentLabel = '';
     switch (periodType) {
         case this._ACTIVITY:
             currentLabel = this._LABEL_TIME_REMAINING_ACTIVITY;
             break;
         case this._BREAK:
             currentLabel = this._LABEL_TIME_REMAINING_BREAK;
             break;
     }
     caller.label = time + currentLabel;
     //instance.toggleIcon(caller, instance.currentPeriod, (time - accumulated));
     this.interval = tmr.setInterval(function(){
         console.log("peich");
         caller.tooltiptext = instance._LABEL_ADDON_NAME + ': ' +(time - accumulated) + currentLabel;
         console.log(instance.currentPeriod);
         instance.toggleIcon(caller, instance.currentPeriod, (time - accumulated));
         accumulated++;
     }, 60 * 1000);
     this.timerInstance = tmr.setTimeout(function() {
         instance.onTimeOut(caller, instance.blockerObject);
     }, parseInt(this.settings.timeActivityPeriod) * 60 * 1000);
 };
exports.saveUpdateTask = function(interval) {
    clearInterval(updateTask);
    interval = interval * 60 * 1000;
    updateTask = setInterval(function() {
        fetchRules();
    }, interval);
}
Esempio n. 10
0
exports.search_initialize = function(options) {
  search_init_variables(options);
  search_load_events();

  reportUsage();
  timer.setInterval(reportUsage, HOUR_MS);
};
Esempio n. 11
0
File: main.js Progetto: Croydon/jpm
exports.testChromeInPanel = function(assert, done) {
  let panel = Panel({
    contentURL: "chrome://test/content/panel.html",
    contentScriptWhen: "start",
    contentScriptFile: data.url("panel.js")
  });

  var intervalId;

  panel.once("show", _ => {
    clearInterval(intervalId);
    assert.pass("panel shown");
    panel.port.once("echo", _ => {
      assert.pass("got echo");
      panel.destroy();
      assert.pass("panel is destroyed");
      done();
    });
    panel.port.emit("echo");
  });

  // NOTE: hack needed to prevents random test timeout (probably due to the
  // setTimeout used in the 'panel.show' method:
  // https://github.com/mozilla/addon-sdk/blob/a19bd8c/lib/sdk/panel/utils.js#L78)
  intervalId = setInterval( _ => {
    panel.show();
  }, 50);
};
    startTimer: function () {
        // Set timed update on interval
        this.interval = Timer.setInterval(this.update.bind(this), 600000);

        // Flag timer as active
        this.timerActive = true;
    },
Esempio n. 13
0
exports.testSetIntervalGC = function*(assert) {
  let called = defer();
  let gcDone = defer();
  let done = false;
  let count = 0;

  let id = timer.setInterval(() => {
    assert.pass("call count is " + count);

    if (done) {
      timer.clearInterval(id);
      called.resolve();
      return null;
    }

    if (count++ == 0) {
      assert.pass("first call to setInterval worked!");

      gc().then(() => {
        assert.pass("gc is complete!");
        done = true;
        gcDone.resolve();
      });

      assert.pass("called gc()!");
    }

    return null;
  }, 1);

  yield gcDone.promise;
  yield called.promise;

  assert.pass("setInterval was called after the gc!");
};
Esempio n. 14
0
  startAutoRefresh: function(interval=PLAYER_DEFAULT_AUTO_REFRESH_TIMEOUT) {
    if (this.autoRefreshTimer) {
      return;
    }

    this.autoRefreshTimer = setInterval(this.refreshState.bind(this), interval);
  },
Esempio n. 15
0
/**
 * Starts a timer that will call the showBadge function after 24 hours, should the
 * user not close the browser earlier.
 */
function startTimer() {
    timer = timers.setInterval(function() {
        showBadge();
        timers.clearInterval(timer);
        timer = -1;
    }, 4000);
}
				 	worker.port.on("content script", function(message) {//receives message from contentscript
							var hash = parseInt(message.split("#")[1]);//the hash is the number denoting the voice

							if(!linksaquired[hash-1])// if you have received the mp3 url from the tab
							{	
								var tabs = require("sdk/tabs");
								for (let tab of tabs)
								{
									if (tab.url.indexOf("#"+hash)>-1)
									{
										tab.close();										
									}

								}
								appendToFile("locations.txt",message);
								linksaquired[hash-1]=true;
							}
	
							if(checkAll())
							{	//tell console to download
								writeToFile("console","download");
								console.log("Success");
								tryingtowrite=false;
								//reset all
								linksaquired=[false,false,false,false,false];
								//wait a while to restart
								timer = setInterval(waitToRestart, 1000);
							}
							
					});
Esempio n. 17
0
	onSignal: function(eventId, worker, breaker, resolver) {
		let { promise, resolve } = defer();

		const timerId = setInterval(() => {

			if (breaker()) {
				stop();
			}
			else if (resolver()) {
				stop();
				resolve();
			}

		}, 100);

		const stop = () => {
			clearInterval(timerId);
			this.event.off(eventId);
		};

		this.event.once(eventId, _ => {
			clearInterval(timerId);
			worker();
		});

		return promise;
	}
function createInstance (instance) {
  panel.port.emit('createInstance', instance)
  getNotifications(instance)
  setInterval(function () {
    getNotifications(instance)
  }, 60 * 1000)
}
let _userDisabled = true; // handle #20
function handleStartup (options, xconfig, variationsMod) {
  /*
    options: the bootstrap.js options.  `loadReason`

    xconfig: from xsetup().  Has specific branch, etc.

    variationsMod:
    - variations object:  variationName: callable
    - cleanup
  */

  // https://developer.mozilla.org/en-US/Add-ons/SDK/Tutorials/Listening_for_load_and_unload
  switch (options.loadReason) {
    case "install":
      // 1a. check eligibility, or kill the addon.
      if (!variationsMod.isEligible()) {
        report(merge({},xconfig,{msg:"ineligible"}));
        resetPrefs();
        _userDisabled = false;
        return die();  // gross, calls survey, don't want to!
      }
      // TODO GRL something to see if it's in another trial. #3
      /*
        let curtrial = studyManager.current();
        if (curtrial && curtrial != xconfig.name) {
          report(merge({},xconfig,{msg:"in-other-trial"}));
          resetPrefs();
          _userDisabled = false;
        return die();  // gross, calls survey, don't want to!
      }
      studyManager.join(xconfig.name);

      ## needs code to 'leave' trial at all places.
      ## needs test code
      */

      // 1b. report install.
      report(merge({},xconfig,{msg:options.loadReason}));

    case "enable":
    case "startup":
    case "upgrade":
    case "downgrade":
      break;
  }

  // 2a. run -- do the effect.  SHOULD be able to called multiple times safely.
  var mybranchname = xconfig.variation;
  variationsMod.variations[mybranchname]();  // do the effect
  console.log("did the variation:", mybranchname);
  // 2b. report success
  report(merge({}, xconfig, {msg:"running"}));

  // check once, right away.
  dieIfExpired(xconfig, variationsMod);

  // then every 5 minutes
  let _pulseTimer = setInterval(timerFunction.bind(null, xconfig, variationsMod), 5*60*1000 /*5 minutes*/)
}
Esempio n. 20
0
  onComplete: function (response) {
    localizedMessages = response.json;

    // Localized message mapping done, now we start the timer for getting and auto-updating the global settings
    timer.setInterval(getGlobalSettings, 1000 * 60);
    // Get the global settings
    getGlobalSettings();
  }
 FirefoxBrowserActions.prototype.setAlarm = function(name, interval, fn)
 {
     // Trigger initial alarm immediately.
     fn();
     
     var tmr = require('sdk/timers');
     return tmr.setInterval(fn, interval*1000*60);
 };
Esempio n. 22
0
  this.loop = function(){
    timers.clearInterval(this.interval);
    let refreshSchedule = conf.refreshSchedule !== null ? conf.refreshSchedule : preferences.get('refresh_schedule');

    this.fetch();
    this.interval = timers.setInterval(function(){
      self.fetch();
    }, refreshSchedule * 1000);
  };
Esempio n. 23
0
exports.main = function() {
  feedFolderId = ensureBookmarkFolder('Feeds');
  itemFolderId = ensureBookmarkFolder('Feed Items');
  crawledFolderId = ensureBookmarkFolder('Feeds crawled until');
  initFilePicker();

  // fetch all feeds quickly the first time around
  periodicTaskId = timers.setInterval(periodicTask, 5000);
}
Esempio n. 24
0
function gc(assert) {
  let wait = 1;
  let interval = setInterval(function() {
    assert.pass("waited " + (wait++ * 0.250) + "secs for gc()..");
  }, 250);

  return memory.gc().then(() => {
    assert.pass("gc completed!");
    clearInterval(interval);
  });
}
Esempio n. 25
0
/* Update the timer interval for all targets
 */
function updateTimerInteval() {
	for (t of activeTargets) {
		if (t.intervalTimer != null) {
			clearInterval(t.intervalTimer);
			t.intervalTimer = setInterval(
				function() {
				   checkFile(t) 
				}, fileCheckRate);
		}
	}
}
Esempio n. 26
0
exports.testSetInterval = function (assert, end) {
  var count = 0;
  var id = timer.setInterval(function () {
    count++;
    if (count >= 5) {
      timer.clearInterval(id);
      assert.pass("testSetInterval passed");
      end();
    }
  }, 1);
};
Esempio n. 27
0
exports.main = function(options, callbacks) {
  server.on('update-device', updateDevice);

  server.on('sessionClose', onSessionClose);

  //secondary
  server.on('requestSession', onRequestSession);

  timeout = tmr.setInterval(function() {
    server.scanForDevices();
  }, 10000);
};
Esempio n. 28
0
 var updateTickerRefreshInterval = function() {
   var refresh_rate = getIntegerPreference("Timer");
   if (refresh_rate < 1) {
     refresh_rate = DEFAULT_REFRESH_RATE;
   }
   for (var i in tickers) {
     if ( (tickers[i] != null) && (tickers[i].length >= 4)) {
       clearInterval(tickers[i][3]); // Stop automatic refresh of removed ticker
       tickers[i][3] = setInterval(tickers[i][1], (refresh_rate * 1000));
     }
   }
 };
Esempio n. 29
0
var start = function() {
  if (ss.storage.call_log != undefined) {
    call_log = ss.storage.call_log;
  }
  if (ss.storage.missed_calls_count != undefined) {
    missed_calls_count = ss.storage.missed_calls_count;
  }
  btnMain.disabled = false;
  tmr.setInterval(function() {
    checkMissedCalls(phone);
  }, 10000);
}
Esempio n. 30
0
  startPolling: function fastboot_startPolling() {
    console.debug("IN fastboot_startPolling");

    if (fastbootTimer !== null) {
      console.warn("Fastboot poll already running.");
      return;
    }

    let doPoll = (function() {
      this.devices().then((devices) => {
        let added = [];
        let removed = [];

        if (devices.sort() === this.fastbootDevices.sort()) {
          console.debug("No change.");
          return;
        }

        console.debug("Read devices from fastboot output", devices);

        for (let dev of devices) {
          if (this.fastbootDevices.indexOf(dev) === -1) {
            added.push(dev);
          }
        }

	console.debug("Fastboot devices added", added);

        for (let dev of this.fastbootDevices) {
          // listed in previous devices and not in the current one
          if (devices.indexOf(dev) === -1) {
            removed.push(dev);
          }
        }

	console.debug("Fastboot devices removed", removed);

        this.fastbootDevices = devices;

        for (let dev of added) {
          let fbdevice = new FastbootDevice(dev);
          Devices.register(dev, fbdevice);
        }

        for (let dev of removed) {
          Devices.unregister(dev);
        }
      });
    }).bind(this);

    console.log("fastboot_polling starting");
    fastbootTimer = setInterval(doPoll, 2000);
  },