Merge branch 'espruino:master' into master

apps/activityreminder/ChangeLog

@@ -2,3 +2,4 @@
 0.02: Fix the settings bug and some tweaking
 0.03: Do not alarm while charging
 0.04: Obey system quiet mode
+0.05: Battery optimisation, add the pause option, bug fixes

apps/activityreminder/README.md

@@ -7,8 +7,8 @@ Different settings can be personalized:
 - Enable : Enable/Disable the app
 - Start hour: Hour to start the reminder
 - End hour: Hour to end the reminder
-- Max inactivity: Maximum inactivity time to allow before the alert. From 15 to 60 min
+- Max inactivity: Maximum inactivity time to allow before the alert. From 15 to 120 min
 - Dismiss delay: Delay added before the next alert if the alert is dismissed. From 5 to 60 min
-    Notice: If Dissmiss delay > Max inactivity then it will be equal Max inactivity
+- Pause delay: Same as Dismiss delay but longer (usefull for meetings and such). From 30 to 240 min
 - Min steps: Minimal amount of steps to count as an activity
 

apps/activityreminder/app.js

@@ -1,40 +1,42 @@
-function drawAlert(){
+function drawAlert() {
-  E.showPrompt("Inactivity detected",{
+  E.showPrompt("Inactivity detected", {
-    title:"Activity reminder",
+    title: "Activity reminder",
-    buttons : {"Ok": true,"Dismiss": false}
+    buttons: { "Ok": 1, "Dismiss": 2, "Pause": 3 }
-    }).then(function(v) {
+  }).then(function (v) {
-      if(v == true){
+    if (v == 1) {
-        stepsArray = stepsArray.slice(0, activityreminder.maxInnactivityMin - 3);
+      activityreminder_data.okDate = new Date();
-        require("activityreminder").saveStepsArray(stepsArray);
+    }
-      }
+    if (v == 2) {
-      if(v == false){
+      activityreminder_data.dismissDate = new Date();
-        stepsArray = stepsArray.slice(0, activityreminder.maxInnactivityMin - activityreminder.dismissDelayMin);
+    }
-        require("activityreminder").saveStepsArray(stepsArray);
+    if (v == 3) {
-      }
+      activityreminder_data.pauseDate = new Date();
+    }
+    activityreminder.saveData(activityreminder_data);
     load();
   });
 
   // Obey system quiet mode:
-  if (!(require('Storage').readJSON('setting.json',1)||{}).quiet) {
+  if (!(storage.readJSON('setting.json', 1) || {}).quiet) {
     Bangle.buzz(400);
   }
   setTimeout(load, 20000);
 }
 
-function run(){
+function run() {
-    if(stepsArray.length == activityreminder.maxInnactivityMin){
+  if (activityreminder.mustAlert(activityreminder_data, activityreminder_settings)) {
-        if (stepsArray[0] - stepsArray[stepsArray.length-1] < activityreminder.minSteps){
+    drawAlert();
-            drawAlert();
+  } else {
-        }
+    eval(storage.read("activityreminder.settings.js"))(() => load());
-    }else{
+  }
-        eval(require("Storage").read("activityreminder.settings.js"))(()=>load());
-    }
 }
 
 
+const activityreminder = require("activityreminder");
+const storage = require("Storage");
 g.clear();
 Bangle.loadWidgets();
 Bangle.drawWidgets();
-activityreminder = require("activityreminder").loadSettings();
+const activityreminder_settings = activityreminder.loadSettings();
-stepsArray = require("activityreminder").loadStepsArray();
+const activityreminder_data = activityreminder.loadData();
 run();

apps/activityreminder/boot.js

@@ -1,30 +1,45 @@
-function run(){
+function run() {
-    if (Bangle.isCharging()) return;
+    if (isNotWorn()) return;
-    var now = new Date();
+    let now = new Date();
-    var h = now.getHours();
+    let h = now.getHours();
-    if(h >= activityreminder.startHour && h < activityreminder.endHour){
+    let health = Bangle.getHealthStatus("day");
-        var health = Bangle.getHealthStatus("day");
+
-        stepsArray.unshift(health.steps);
+    if (h >= activityreminder_settings.startHour && h < activityreminder_settings.endHour) {
-        stepsArray = stepsArray.slice(0, activityreminder.maxInnactivityMin);
+        if (health.steps - activityreminder_data.stepsOnDate >= activityreminder_settings.minSteps // more steps made than needed
-        require("activityreminder").saveStepsArray(stepsArray);
+            || health.steps < activityreminder_data.stepsOnDate) { // new day or reboot of the watch
-    }
+            activityreminder_data.stepsOnDate = health.steps;
-    else{
+            activityreminder_data.stepsDate = now;
-        if(stepsArray != []){
+            activityreminder.saveData(activityreminder_data);
-            stepsArray = [];
+            /* todo in a futur release 
-            require("activityreminder").saveStepsArray(stepsArray);
+            add settimer to trigger like 10 secs after the stepsDate + minSteps
+            cancel all other timers of this app
+            */
         }
-    }
+        
-    if(stepsArray.length >= activityreminder.maxInnactivityMin){
+        if(activityreminder.mustAlert(activityreminder_data, activityreminder_settings)){
-        if (stepsArray[0] - stepsArray[stepsArray.length-1] < activityreminder.minSteps){
             load('activityreminder.app.js');
         }
     }
+
 }
 
+function isNotWorn() {
+    // todo in a futur release check temperature and mouvement in a futur release 
+    return Bangle.isCharging();
+}
 
-activityreminder = require("activityreminder").loadSettings();
+const activityreminder = require("activityreminder");
-if(activityreminder.enabled) {
+const activityreminder_settings = activityreminder.loadSettings();
-    stepsArray = require("activityreminder").loadStepsArray();
+if (activityreminder_settings.enabled) {
+    const activityreminder_data = activityreminder.loadData();
+    if(activityreminder_data.firstLoad){
+        activityreminder_data.firstLoad =false;
+        activityreminder.saveData(activityreminder_data);
+    }
     setInterval(run, 60000);
+    /* todo in a futur release 
+    increase setInterval time to something that is still sensible (5 mins ?)
+    add settimer to trigger like 10 secs after the stepsDate + minSteps
+    cancel all other timers of this app
+    */
 }
-

apps/activityreminder/lib.js

@@ -1,22 +1,57 @@
-exports.loadSettings = function() {
+const storage = require("Storage");
+
+exports.loadSettings = function () {
     return Object.assign({
         enabled: true,
         startHour: 9,
         endHour: 20,
         maxInnactivityMin: 30,
         dismissDelayMin: 15,
+        pauseDelayMin: 120,
         minSteps: 50
-    }, require("Storage").readJSON("activityreminder.s.json", true) || {});
+    }, storage.readJSON("activityreminder.s.json", true) || {});
 };
 
-exports.writeSettings = function(settings){
+exports.writeSettings = function (settings) {
-    require("Storage").writeJSON("activityreminder.s.json", settings);
+    storage.writeJSON("activityreminder.s.json", settings);
 };
 
-exports.saveStepsArray = function(stepsArray) {
+exports.saveData = function (data) {
-    require("Storage").writeJSON("activityreminder.sa.json", stepsArray);
+    storage.writeJSON("activityreminder.data.json", data);
 };
 
-exports.loadStepsArray = function(){
+exports.loadData = function () {
-    return require("Storage").readJSON("activityreminder.sa.json") || [];
+    let health = Bangle.getHealthStatus("day");
-};
+    const data = Object.assign({
+        firstLoad: true,
+        stepsDate: new Date(),
+        stepsOnDate: health.steps,
+        okDate: new Date(1970),
+        dismissDate: new Date(1970),
+        pauseDate: new Date(1970),
+    },
+    storage.readJSON("activityreminder.data.json") || {});
+
+    if(typeof(data.stepsDate) == "string")
+        data.stepsDate = new Date(data.stepsDate);
+    if(typeof(data.okDate) == "string")
+        data.okDate = new Date(data.okDate);
+    if(typeof(data.dismissDate) == "string")
+        data.dismissDate = new Date(data.dismissDate);
+    if(typeof(data.pauseDate) == "string")
+        data.pauseDate = new Date(data.pauseDate);
+
+    return data;
+};
+
+exports.mustAlert = function(activityreminder_data, activityreminder_settings) {
+    let now = new Date();
+    if ((now - activityreminder_data.stepsDate) / 60000 > activityreminder_settings.maxInnactivityMin) { // inactivity detected
+        if ((now - activityreminder_data.okDate) / 60000 > 3 && // last alert anwsered with ok was more than 3 min ago
+            (now - activityreminder_data.dismissDate) / 60000 > activityreminder_settings.dismissDelayMin && // last alert was more than dismissDelayMin ago
+            (now - activityreminder_data.pauseDate) / 60000 > activityreminder_settings.pauseDelayMin) { // last alert was more than pauseDelayMin ago
+            return true;
+        }
+    }
+    return false;
+}

apps/activityreminder/metadata.json

@@ -3,7 +3,7 @@
   "name": "Activity Reminder",
   "shortName":"Activity Reminder",
   "description": "A reminder to take short walks for the ones with a sedentary lifestyle",
-  "version":"0.04",
+  "version":"0.05",
   "icon": "app.png",
   "type": "app",
   "tags": "tool,activity",
@@ -18,6 +18,6 @@
   ],
   "data": [
     {"name": "activityreminder.s.json"},
-    {"name":  "activityreminder.sa.json"}
+    {"name": "activityreminder.data.json"}
   ]
 }

apps/activityreminder/settings.js

@@ -1,64 +1,76 @@
-(function(back) {
+(function (back) {
   // Load settings
-  var settings = require("activityreminder").loadSettings();
+  const activityreminder = require("activityreminder");
+  const settings = activityreminder.loadSettings();
 
   // Show the menu
   E.showMenu({
-      "" : { "title" : "Activity Reminder" },
+    "": { "title": "Activity Reminder" },
-      "< Back" : () => back(),
+    "< Back": () => back(),
-      'Enable': {
+    'Enable': {
-        value: settings.enabled,
+      value: settings.enabled,
-        format: v => v?"Yes":"No",
+      format: v => v ? "Yes" : "No",
-        onchange: v => {
+      onchange: v => {
-          settings.enabled = v;
+        settings.enabled = v;
-          require("activityreminder").writeSettings(settings);
+        activityreminder.writeSettings(settings);
-        }
+      }
+    },
+    'Start hour': {
+      value: settings.startHour,
+      min: 0, max: 24,
+      onchange: v => {
+        settings.startHour = v;
+        activityreminder.writeSettings(settings);
+      }
+    },
+    'End hour': {
+      value: settings.endHour,
+      min: 0, max: 24,
+      onchange: v => {
+        settings.endHour = v;
+        activityreminder.writeSettings(settings);
+      }
+    },
+    'Max inactivity': {
+      value: settings.maxInnactivityMin,
+      min: 15, max: 120,
+      onchange: v => {
+        settings.maxInnactivityMin = v;
+        activityreminder.writeSettings(settings);
       },
-      'Start hour': {
+      format: x => {
-        value: settings.startHour,
+        return x + " min";
-        min: 0, max: 24,
+      }
-        onchange: v => {
+    },
-          settings.startHour = v;
+    'Dismiss delay': {
-          require("activityreminder").writeSettings(settings);
+      value: settings.dismissDelayMin,
-        }
+      min: 5, max: 60,
-     },
+      onchange: v => {
-     'End hour': {
+        settings.dismissDelayMin = v;
-        value: settings.endHour,
+        activityreminder.writeSettings(settings);
-        min: 0, max: 24,
+      },
-        onchange: v => {
+      format: x => {
-          settings.endHour = v;
+        return x + " min";
-          require("activityreminder").writeSettings(settings);
+      }
-        }
+    },
-     },
+    'Pause delay': {
-     'Max inactivity': {
+      value: settings.pauseDelayMin,
-        value: settings.maxInnactivityMin,
+      min: 30, max: 240,
-        min: 15, max: 120,
+      onchange: v => {
-        onchange: v => {
+        settings.pauseDelayMin = v;
-          settings.maxInnactivityMin = v;
+        activityreminder.writeSettings(settings);
-          require("activityreminder").writeSettings(settings);
+      },
-        },
+      format: x => {
-        format: x => {
+        return x + " min";
-          return x + " min";
+      }
-        }
+    },
-     },
+    'Min steps': {
-     'Dismiss delay': {
+      value: settings.minSteps,
-        value: settings.dismissDelayMin,
+      min: 10, max: 500,
-        min: 5, max: 60,
+      onchange: v => {
-        onchange: v => {
+        settings.minSteps = v;
-          settings.dismissDelayMin = v;
+        activityreminder.writeSettings(settings);
-          require("activityreminder").writeSettings(settings);
+      }
-        },
+    }
-        format: x => {
-          return x + " min";
-        }
-     },
-     'Min steps': {
-        value: settings.minSteps,
-        min: 10, max: 500,
-        onchange: v => {
-          settings.minSteps = v;
-          require("activityreminder").writeSettings(settings);
-        }
-     }
   });
 })