refactor watch faces to use new advisory API

diff --git a/movement/watch_faces/clock/decimal_time_face.c b/movement/watch_faces/clock/decimal_time_face.c
index 238be9868d388837a8a7e65b74bf6dc9d174b1ff..95e6a51a59411620bacfe24bc28d0d21b7b3e04e 100644 (file)
--- a/movement/watch_faces/clock/decimal_time_face.c
+++ b/movement/watch_faces/clock/decimal_time_face.c
@@ -160,7 +160,7 @@ void decimal_time_face_resign(void *context) {
 }
 
 
-// void decimal_time_face_wants_background_task() {
+// void decimal_time_face_advise() {
 // 
 // }
 

diff --git a/movement/watch_faces/clock/decimal_time_face.h b/movement/watch_faces/clock/decimal_time_face.h
index e08c3da6df246bec99db7a50fca641858441fef7..eb1a41e4c9891ed1844b7378f0560b524837e4a0 100644 (file)
--- a/movement/watch_faces/clock/decimal_time_face.h
+++ b/movement/watch_faces/clock/decimal_time_face.h
@@ -57,7 +57,7 @@ void decimal_time_face_setup(uint8_t watch_face_index, void ** context_ptr);
 void decimal_time_face_activate(void *context);
 bool decimal_time_face_loop(movement_event_t event, void *context);
 void decimal_time_face_resign(void *context);
-// void decimal_time_face_wants_background_task();
+// void decimal_time_face_advise();
 
 
 #define decimal_time_face ((const watch_face_t){ \

diff --git a/movement/watch_faces/clock/minute_repeater_decimal_face.c b/movement/watch_faces/clock/minute_repeater_decimal_face.c
index 1ce02def9149b64f364a3800c86910459965b37c..7582a7a4372071d36a8e268dfc82f624086f0130 100644 (file)
--- a/movement/watch_faces/clock/minute_repeater_decimal_face.c
+++ b/movement/watch_faces/clock/minute_repeater_decimal_face.c
@@ -225,11 +225,14 @@ void minute_repeater_decimal_face_resign(void *context) {
     (void) context;
 }
 
-bool minute_repeater_decimal_face_wants_background_task(void *context) {
+movement_watch_face_advisory_t minute_repeater_decimal_face_advise(void *context) {
     minute_repeater_decimal_state_t *state = (minute_repeater_decimal_state_t *)context;
-    if (!state->signal_enabled) return false;
+    movement_watch_face_advisory_t retval = { 0 };
 
-    watch_date_time date_time = watch_rtc_get_date_time();
+    if (state->signal_enabled) {
+        watch_date_time date_time = watch_rtc_get_date_time();
+        retval.wants_background_task = date_time.unit.minute == 0;
+    }
 
-    return date_time.unit.minute == 0;
+    return retval;
 }

diff --git a/movement/watch_faces/clock/minute_repeater_decimal_face.h b/movement/watch_faces/clock/minute_repeater_decimal_face.h
index b50905302647832972ce6fc0eb035f43b89dac1a..738b34d7e387072c721cf79a284a8b4aaf9c6107 100644 (file)
--- a/movement/watch_faces/clock/minute_repeater_decimal_face.h
+++ b/movement/watch_faces/clock/minute_repeater_decimal_face.h
@@ -71,14 +71,14 @@ void minute_repeater_decimal_face_setup(uint8_t watch_face_index, void ** contex
 void minute_repeater_decimal_face_activate(void *context);
 bool minute_repeater_decimal_face_loop(movement_event_t event, void *context);
 void minute_repeater_decimal_face_resign(void *context);
-bool minute_repeater_decimal_face_wants_background_task(void *context);
+movement_watch_face_advisory_t minute_repeater_decimal_face_advise(void *context);
 
 #define minute_repeater_decimal_face ((const watch_face_t){ \
     minute_repeater_decimal_face_setup, \
     minute_repeater_decimal_face_activate, \
     minute_repeater_decimal_face_loop, \
     minute_repeater_decimal_face_resign, \
-    minute_repeater_decimal_face_wants_background_task, \
+    minute_repeater_decimal_face_advise, \
 })
 
 #endif // MINUTE_REPEATER_DECIMAL_FACE_H_

diff --git a/movement/watch_faces/clock/repetition_minute_face.c b/movement/watch_faces/clock/repetition_minute_face.c
index 04fa85947d04326aae6d547b615d999c255639f7..0d792a3f6a365ad7a0d1b6cd936a120faf3f81fc 100644 (file)
--- a/movement/watch_faces/clock/repetition_minute_face.c
+++ b/movement/watch_faces/clock/repetition_minute_face.c
@@ -208,11 +208,14 @@ void repetition_minute_face_resign(void *context) {
     (void) context;
 }
 
-bool repetition_minute_face_wants_background_task(void *context) {
+movement_watch_face_advisory_t repetition_minute_face_advise(void *context) {
     repetition_minute_state_t *state = (repetition_minute_state_t *)context;
-    if (!state->signal_enabled) return false;
+    movement_watch_face_advisory_t retval = { 0 };
 
-    watch_date_time date_time = watch_rtc_get_date_time();
+    if (state->signal_enabled) {
+        watch_date_time date_time = watch_rtc_get_date_time();
+        retval.wants_background_task = date_time.unit.minute == 0;
+    }
 
-    return date_time.unit.minute == 0;
+    return retval;
 }

diff --git a/movement/watch_faces/clock/repetition_minute_face.h b/movement/watch_faces/clock/repetition_minute_face.h
index 3c631d6eb183b86f75a066d30c05213c2e71d106..1e5d10acdbb1f41db48c11c98fd8ed9d48b7e1b7 100644 (file)
--- a/movement/watch_faces/clock/repetition_minute_face.h
+++ b/movement/watch_faces/clock/repetition_minute_face.h
@@ -70,14 +70,14 @@ void repetition_minute_face_setup(uint8_t watch_face_index, void ** context_ptr)
 void repetition_minute_face_activate(void *context);
 bool repetition_minute_face_loop(movement_event_t event, void *context);
 void repetition_minute_face_resign(void *context);
-bool repetition_minute_face_wants_background_task(void *context);
+movement_watch_face_advisory_t repetition_minute_face_advise(void *context);
 
 #define repetition_minute_face ((const watch_face_t){ \
     repetition_minute_face_setup, \
     repetition_minute_face_activate, \
     repetition_minute_face_loop, \
     repetition_minute_face_resign, \
-    repetition_minute_face_wants_background_task, \
+    repetition_minute_face_advise, \
 })
 
 #endif // REPETITION_MINUTE_FACE_H_

diff --git a/movement/watch_faces/clock/simple_clock_bin_led_face.c b/movement/watch_faces/clock/simple_clock_bin_led_face.c
index 5ac93dd70d30ec2b38e80d3f87d77830ff20daf7..cbe1593548fd160e407a0058e84ed97f5b62c3cb 100644 (file)
--- a/movement/watch_faces/clock/simple_clock_bin_led_face.c
+++ b/movement/watch_faces/clock/simple_clock_bin_led_face.c
@@ -209,11 +209,14 @@ void simple_clock_bin_led_face_resign(void *context) {
     (void) context;
 }
 
-bool simple_clock_bin_led_face_wants_background_task(void *context) {
+movement_watch_face_advisory_t simple_clock_bin_led_face_advise(void *context) {
     simple_clock_bin_led_state_t *state = (simple_clock_bin_led_state_t *)context;
-    if (!state->signal_enabled) return false;
+    movement_watch_face_advisory_t retval = { 0 };
 
-    watch_date_time date_time = watch_rtc_get_date_time();
+    if (state->signal_enabled) {
+        watch_date_time date_time = watch_rtc_get_date_time();
+        retval.wants_background_task = date_time.unit.minute == 0;
+    }
 
-    return date_time.unit.minute == 0;
+    return retval;
 }

diff --git a/movement/watch_faces/clock/simple_clock_bin_led_face.h b/movement/watch_faces/clock/simple_clock_bin_led_face.h
index bff07589f1c285ccdedc84fea323fe326875a60f..ed9d3aeeff37cc60618ccdaf6ec39de2ea07ee89 100644 (file)
--- a/movement/watch_faces/clock/simple_clock_bin_led_face.h
+++ b/movement/watch_faces/clock/simple_clock_bin_led_face.h
@@ -68,14 +68,14 @@ void simple_clock_bin_led_face_setup(uint8_t watch_face_index, void ** context_p
 void simple_clock_bin_led_face_activate(void *context);
 bool simple_clock_bin_led_face_loop(movement_event_t event, void *context);
 void simple_clock_bin_led_face_resign(void *context);
-bool simple_clock_bin_led_face_wants_background_task(void *context);
+movement_watch_face_advisory_t simple_clock_bin_led_face_advise(void *context);
 
 #define simple_clock_bin_led_face ((const watch_face_t){ \
     simple_clock_bin_led_face_setup, \
     simple_clock_bin_led_face_activate, \
     simple_clock_bin_led_face_loop, \
     simple_clock_bin_led_face_resign, \
-    simple_clock_bin_led_face_wants_background_task, \
+    simple_clock_bin_led_face_advise, \
 })
 
 #endif // SIIMPLE_CLOCK_BIN_LED_FACE_H_

diff --git a/movement/watch_faces/clock/weeknumber_clock_face.c b/movement/watch_faces/clock/weeknumber_clock_face.c
index 060191dd6556d756f213fe313ec3a47ccf03bd8b..2a270a2e3020d9fa94487e9d7ad3ede8677a24b1 100644 (file)
--- a/movement/watch_faces/clock/weeknumber_clock_face.c
+++ b/movement/watch_faces/clock/weeknumber_clock_face.c
@@ -143,11 +143,14 @@ void weeknumber_clock_face_resign(void *context) {
     (void) context;
 }
 
-bool weeknumber_clock_face_wants_background_task(void *context) {
+movement_watch_face_advisory_t weeknumber_clock_face_advise(void *context) {
     weeknumber_clock_state_t *state = (weeknumber_clock_state_t *)context;
-    if (!state->signal_enabled) return false;
+    movement_watch_face_advisory_t retval = { 0 };
 
-    watch_date_time date_time = watch_rtc_get_date_time();
+    if (state->signal_enabled) {
+        watch_date_time date_time = watch_rtc_get_date_time();
+        retval.wants_background_task = date_time.unit.minute == 0;
+    }
 
-    return date_time.unit.minute == 0;
+    return retval;
 }

diff --git a/movement/watch_faces/clock/weeknumber_clock_face.h b/movement/watch_faces/clock/weeknumber_clock_face.h
index d74da487f4ce27481e35e41dab050f56e4d7d7f3..9ba127076a245a58a0b0d039b477079379567a15 100644 (file)
--- a/movement/watch_faces/clock/weeknumber_clock_face.h
+++ b/movement/watch_faces/clock/weeknumber_clock_face.h
@@ -48,14 +48,14 @@ void weeknumber_clock_face_setup(uint8_t watch_face_index, void ** context_ptr);
 void weeknumber_clock_face_activate(void *context);
 bool weeknumber_clock_face_loop(movement_event_t event, void *context);
 void weeknumber_clock_face_resign(void *context);
-bool weeknumber_clock_face_wants_background_task(void *context);
+movement_watch_face_advisory_t weeknumber_clock_face_advise(void *context);
 
 #define weeknumber_clock_face ((const watch_face_t){ \
     weeknumber_clock_face_setup, \
     weeknumber_clock_face_activate, \
     weeknumber_clock_face_loop, \
     weeknumber_clock_face_resign, \
-    weeknumber_clock_face_wants_background_task, \
+    weeknumber_clock_face_advise, \
 })
 
 #endif // SIMPLE_CLOCK_FACE_H_

diff --git a/movement/watch_faces/clock/wyoscan_face.h b/movement/watch_faces/clock/wyoscan_face.h
index 2816e4d36d285a1f025e99d6b3a08c00ed8b6fae..ee4120027a3e4274fddd5941c083527c12762743 100644 (file)
--- a/movement/watch_faces/clock/wyoscan_face.h
+++ b/movement/watch_faces/clock/wyoscan_face.h
@@ -77,7 +77,7 @@ void wyoscan_face_setup(uint8_t watch_face_index, void ** context_ptr);
 void wyoscan_face_activate(void *context);
 bool wyoscan_face_loop(movement_event_t event, void *context);
 void wyoscan_face_resign(void *context);
-bool wyoscan_face_wants_background_task(void *context);
+movement_watch_face_advisory_t wyoscan_face_advise(void *context);
 
 #define wyoscan_face ((const watch_face_t){ \
     wyoscan_face_setup, \

diff --git a/movement/watch_faces/complication/alarm_face.c b/movement/watch_faces/complication/alarm_face.c
index b84a6523e5afbdf3b38e67bbca5467e88700d6e5..417dbd2a6ee109513ae92c9ba95c3b4a6c75b01e 100644 (file)
--- a/movement/watch_faces/complication/alarm_face.c
+++ b/movement/watch_faces/complication/alarm_face.c
@@ -232,11 +232,13 @@ void alarm_face_resign(void *context) {
     movement_request_tick_frequency(1);
 }
 
-bool alarm_face_wants_background_task(void *context) {
+movement_watch_face_advisory_t alarm_face_advise(void *context) {
     alarm_state_t *state = (alarm_state_t *)context;
+    movement_watch_face_advisory_t retval = { 0 };
+
     watch_date_time now = watch_rtc_get_date_time();
     // just a failsafe: never fire more than one alarm within a minute
-    if (state->alarm_handled_minute == now.unit.minute) return false;
+    if (state->alarm_handled_minute == now.unit.minute) return retval;
     state->alarm_handled_minute = now.unit.minute;
     // check the rest
     for (uint8_t i = 0; i < ALARM_ALARMS; i++) {
@@ -246,17 +248,24 @@ bool alarm_face_wants_background_task(void *context) {
                     state->alarm_playing_idx = i;
                     if (state->alarm[i].day == ALARM_DAY_EACH_DAY || state->alarm[i].day == ALARM_DAY_ONE_TIME) return true;
                     uint8_t weekday_idx = _get_weekday_idx(now);
-                    if (state->alarm[i].day == weekday_idx) return true;
-                    if (state->alarm[i].day == ALARM_DAY_WORKDAY && weekday_idx < 5) return true;
-                    if (state->alarm[i].day == ALARM_DAY_WEEKEND && weekday_idx >= 5) return true;
+                    if (state->alarm[i].day == weekday_idx) retval.wants_background_task = true;
+                    if (state->alarm[i].day == ALARM_DAY_WORKDAY && weekday_idx < 5) retval.wants_background_task = true;
+                    if (state->alarm[i].day == ALARM_DAY_WEEKEND && weekday_idx >= 5) retval.wants_background_task = true;
                 }
             }
         }
     }
+
+    if (retval.wants_background_task) {
+        // FIXME for #SecondMovement: I think that this replicates the previous behavior of returning true in the conditionals above,
+        // but would like to do more testing
+        return retval;
+    }
+
     state->alarm_handled_minute = -1;
     // update the movement's alarm indicator five times an hour
     if (now.unit.minute % 12 == 0) _alarm_update_alarm_enabled(state);
-    return false;
+    return retval;
 }
 
 bool alarm_face_loop(movement_event_t event, void *context) {

diff --git a/movement/watch_faces/complication/alarm_face.h b/movement/watch_faces/complication/alarm_face.h
index f46da395db888ea77dbb32a2b9a49ca32713b99e..288ea2d9a4b0d6da5c71ea46ba2c6e72ddf0d95d 100644 (file)
--- a/movement/watch_faces/complication/alarm_face.h
+++ b/movement/watch_faces/complication/alarm_face.h
@@ -89,14 +89,14 @@ void alarm_face_setup(uint8_t watch_face_index, void ** context_ptr);
 void alarm_face_activate(void *context);
 bool alarm_face_loop(movement_event_t event, void *context);
 void alarm_face_resign(void *context);
-bool alarm_face_wants_background_task(void *context);
+movement_watch_face_advisory_t alarm_face_advise(void *context);
 
 #define alarm_face ((const watch_face_t){ \
     alarm_face_setup, \
     alarm_face_activate, \
     alarm_face_loop, \
     alarm_face_resign, \
-    alarm_face_wants_background_task, \
+    alarm_face_advise, \
 })
 
 #endif // ALARM_FACE_H_

diff --git a/movement/watch_faces/complication/deadline_face.c b/movement/watch_faces/complication/deadline_face.c
index 6243fc07d1243dc2251aa99c2a140358d677157b..7fbea72e93688b082f875e3dcb54bd75eb141905 100644 (file)
--- a/movement/watch_faces/complication/deadline_face.c
+++ b/movement/watch_faces/complication/deadline_face.c
@@ -229,7 +229,7 @@ static void _background_alarm_play(deadline_state_t *state)
 static void _background_alarm_schedule(deadline_state_t *state)
 {
     /* We simply re-use the scheduling in the background task */
-    deadline_face_wants_background_task(state);
+    deadline_face_advise(state);
 }
 
 /* Cancel background alarm */
@@ -606,7 +606,7 @@ void deadline_face_resign(void *context)
 }
 
 /* Want background task */
-bool deadline_face_wants_background_task(void *context)
+movement_watch_face_advisory_t deadline_face_advise(void *context)
 {
     deadline_state_t *state = (deadline_state_t *) context;
 

diff --git a/movement/watch_faces/complication/deadline_face.h b/movement/watch_faces/complication/deadline_face.h
index f89f3ef23c002ff0cf86c1a9db778c606f56a1ef..3cfca55f7b7eb560229b2663356a883c4e611aa8 100644 (file)
--- a/movement/watch_faces/complication/deadline_face.h
+++ b/movement/watch_faces/complication/deadline_face.h
@@ -52,14 +52,14 @@ void deadline_face_setup(uint8_t watch_face_index, void **context_ptr);
 void deadline_face_activate(void *context);
 bool deadline_face_loop(movement_event_t event, void *context);
 void deadline_face_resign(void *context);
-bool deadline_face_wants_background_task(void *context);
+movement_watch_face_advisory_t deadline_face_advise(void *context);
 
 #define deadline_face ((const watch_face_t){ \
     deadline_face_setup, \
     deadline_face_activate, \
     deadline_face_loop, \
     deadline_face_resign, \
-    deadline_face_wants_background_task \
+    deadline_face_advise \
 })
 
 #endif                          // DEADLINE_FACE_H_

diff --git a/movement/watch_faces/complication/ships_bell_face.c b/movement/watch_faces/complication/ships_bell_face.c
index 6efbc52a90f8b0a5ea4c32d15731b6d4d5a33ce9..fe364fed8bdc6a6a4bdf9841616c03381c7d9815 100644 (file)
--- a/movement/watch_faces/complication/ships_bell_face.c
+++ b/movement/watch_faces/complication/ships_bell_face.c
@@ -124,26 +124,36 @@ void ships_bell_face_resign(void *context) {
     (void) context;
 }
 
-bool ships_bell_face_wants_background_task(void *context) {
-
+movement_watch_face_advisory_t ships_bell_face_advise(void *context) {
     ships_bell_state_t *state = (ships_bell_state_t *) context;
-    if (!state->bell_enabled) return false;
+    movement_watch_face_advisory_t retval = { 0 };
+
+    if (!state->bell_enabled) return retval;
 
     watch_date_time date_time = watch_rtc_get_date_time();
-    if (!(date_time.unit.minute == 0 || date_time.unit.minute == 30)) return false;
+    if (!(date_time.unit.minute == 0 || date_time.unit.minute == 30)) return retval;
 
     date_time.unit.hour %= 12;
+    // #SecondMovement: This was migrated to the new advisory API but not tested. Needs more testing!
     switch (state->on_watch) {
         case 1:
-            return (date_time.unit.hour >= 4 && date_time.unit.hour < 8) ||
-                   (date_time.unit.hour == 8 && date_time.unit.minute == 0);
+            if ((date_time.unit.hour >= 4 && date_time.unit.hour < 8) ||
+                (date_time.unit.hour == 8 && date_time.unit.minute == 0))
+                retval.wants_background_task = true;
+                break;
         case 2:
-            return (date_time.unit.hour >= 8 && date_time.unit.hour < 12) ||
-                   (date_time.unit.hour == 0 && date_time.unit.minute == 0);
+            if ((date_time.unit.hour >= 8 && date_time.unit.hour < 12) ||
+                (date_time.unit.hour == 0 && date_time.unit.minute == 0))
+                retval.wants_background_task = true;
+                break;
         case 3:
-            return (date_time.unit.hour >= 0 && date_time.unit.hour < 4) ||
-                   (date_time.unit.hour == 4 && date_time.unit.minute == 0);
+            if ((date_time.unit.hour >= 0 && date_time.unit.hour < 4) ||
+                (date_time.unit.hour == 4 && date_time.unit.minute == 0))
+                retval.wants_background_task = true;
+                break;
         default:
-            return true;
+            retval.wants_background_task = true;
     }
+
+    return retval;
 }

diff --git a/movement/watch_faces/complication/ships_bell_face.h b/movement/watch_faces/complication/ships_bell_face.h
index 7a17bd4d33373981a69b4647e18f6f19d82d0563..bda16970df289cab9abf339c9a1bfe329762586c 100644 (file)
--- a/movement/watch_faces/complication/ships_bell_face.h
+++ b/movement/watch_faces/complication/ships_bell_face.h
@@ -55,14 +55,14 @@ void ships_bell_face_setup(uint8_t watch_face_index, void ** context_ptr);
 void ships_bell_face_activate(void *context);
 bool ships_bell_face_loop(movement_event_t event, void *context);
 void ships_bell_face_resign(void *context);
-bool ships_bell_face_wants_background_task(void *context);
+movement_watch_face_advisory_t ships_bell_face_advise(void *context);
 
 #define ships_bell_face ((const watch_face_t){ \
     ships_bell_face_setup, \
     ships_bell_face_activate, \
     ships_bell_face_loop, \
     ships_bell_face_resign, \
-    ships_bell_face_wants_background_task, \
+    ships_bell_face_advise, \
 })
 
 #endif // SHIPS_BELL_FACE_H_

diff --git a/movement/watch_faces/complication/tempchart_face.c b/movement/watch_faces/complication/tempchart_face.c
index 6825c78ed7201ce9d6fa11490719aa1d61e0d803..07ade30ab53de26c087ac42b35412588229c1312 100644 (file)
--- a/movement/watch_faces/complication/tempchart_face.c
+++ b/movement/watch_faces/complication/tempchart_face.c
@@ -133,10 +133,13 @@ void tempchart_face_resign(void *context) {
 }
 
 //background freq correction
-bool tempchart_face_wants_background_task(void *context) {
+movement_watch_face_advisory_t tempchart_face_advise(void *context) {
     (void) context;
+    movement_watch_face_advisory_t retval = { 0 };
+
     watch_date_time date_time = watch_rtc_get_date_time();
+    // Updating data every 5 minutes
+    retval.wants_background_task = date_time.unit.minute % 5 == 0;
 
-    //Updating data every 5 minutes
-    return date_time.unit.minute % 5 == 0;
+    return retval;
 }

diff --git a/movement/watch_faces/complication/tempchart_face.h b/movement/watch_faces/complication/tempchart_face.h
index db89d204896d20fa58dd38acf48722c4798e47fa..3c462cd0621326a69f30cd42d3daf907a9786992 100644 (file)
--- a/movement/watch_faces/complication/tempchart_face.h
+++ b/movement/watch_faces/complication/tempchart_face.h
@@ -44,7 +44,7 @@ void tempchart_face_setup(uint8_t watch_face_index, void ** context_ptr);
 void tempchart_face_activate(void *context);
 bool tempchart_face_loop(movement_event_t event, void *context);
 void tempchart_face_resign(void *context);
-bool tempchart_face_wants_background_task(void *context);
+movement_watch_face_advisory_t tempchart_face_advise(void *context);
 
 
 #define tempchart_face ((const watch_face_t){ \
@@ -52,7 +52,7 @@ bool tempchart_face_wants_background_task(void *context);
     tempchart_face_activate, \
     tempchart_face_loop, \
     tempchart_face_resign, \
-    tempchart_face_wants_background_task, \
+    tempchart_face_advise, \
 })
 
 #endif // TEMPCHART_FACE_H_

diff --git a/movement/watch_faces/complication/wake_face.c b/movement/watch_faces/complication/wake_face.c
index 1829aee43e124a56502e064175de0a088469b28a..ca3a96ceef45745a6a057d3060f277d182239ee5 100644 (file)
--- a/movement/watch_faces/complication/wake_face.c
+++ b/movement/watch_faces/complication/wake_face.c
@@ -80,14 +80,14 @@ void wake_face_resign(void *context) {
     (void) context;
 }
 
-bool wake_face_wants_background_task(void *context) {
+movement_watch_face_advisory_t wake_face_advise(void *context) {
     wake_face_state_t *state = (wake_face_state_t *)context;
+    movement_watch_face_advisory_t retval = { 0 };
 
-    bool rc = false;
     if ( state->mode ) {
         watch_date_time now = watch_rtc_get_date_time();
-        rc = state->hour==now.unit.hour && state->minute==now.unit.minute;
-        // We’re at the mercy of the wants_background_task handler
+        retval.wants_background_task = state->hour==now.unit.hour && state->minute==now.unit.minute;
+        // We’re at the mercy of the advise handler
         // In Safari, the emulator triggers at the ›end‹ of the minute
         // Converting to Unix timestamps and taking a difference between now and wake
         // is not an easy win — because the timestamp for wake has to rely on now
@@ -95,7 +95,8 @@ bool wake_face_wants_background_task(void *context) {
         // of now. If it is, take tomorrow’s date, calculating month and year rollover
         // if need be.
     }
-    return rc;
+
+    return retval;
 }
 
 bool wake_face_loop(movement_event_t event, void *context) {

diff --git a/movement/watch_faces/complication/wake_face.h b/movement/watch_faces/complication/wake_face.h
index 72606afd64a752de8b884e8969e387d0d6f860d8..008a5403b8c786f11e2b3b83bef1560a890c15ef 100644 (file)
--- a/movement/watch_faces/complication/wake_face.h
+++ b/movement/watch_faces/complication/wake_face.h
@@ -52,14 +52,14 @@ void wake_face_setup(uint8_t watch_face_index, void **context_ptr);
 void wake_face_activate(void *context);
 bool wake_face_loop(movement_event_t event, void *context);
 void wake_face_resign(void *context);
-bool wake_face_wants_background_task(void *context);
+movement_watch_face_advisory_t wake_face_advise(void *context);
 
 #define wake_face ((const watch_face_t){ \
     wake_face_setup, \
     wake_face_activate, \
     wake_face_loop, \
     wake_face_resign, \
-    wake_face_wants_background_task \
+    wake_face_advise \
 })
 
 #endif // WAKE_FACE_H_

diff --git a/movement/watch_faces/demo/lis2dw_logging_face.c b/movement/watch_faces/demo/lis2dw_logging_face.c
index 9792a7452c9648cd17315f92f2fc17dc528566b5..969ad0ef31bfb3c5ec7c3be52c290e4d1b4fa8a1 100644 (file)
--- a/movement/watch_faces/demo/lis2dw_logging_face.c
+++ b/movement/watch_faces/demo/lis2dw_logging_face.c
@@ -187,9 +187,10 @@ void lis2dw_logging_face_resign(void *context) {
     watch_disable_digital_input(A4);
 }
 
-bool lis2dw_logging_face_wants_background_task(void *context) {
+movement_watch_face_advisory_t lis2dw_logging_face_advise(void *context) {
     lis2dw_logger_state_t *logger_state = (lis2dw_logger_state_t *)context;
     watch_date_time date_time = watch_rtc_get_date_time();
+    movement_watch_face_advisory_t retval = { 0 };
 
     // this is kind of an abuse of the API, but, let's use the 1 minute tick to shift all our data over.
     logger_state->interrupts[2] = logger_state->interrupts[1];
@@ -197,5 +198,7 @@ bool lis2dw_logging_face_wants_background_task(void *context) {
     logger_state->interrupts[0] = 0;
 
     // and do our logging task every 15 minutes
-    return (date_time.unit.minute % 15) == 0;
+    retval.wants_background_task = date_time.unit.minute % 15 == 0;
+
+    return retval;
 }

diff --git a/movement/watch_faces/demo/lis2dw_logging_face.h b/movement/watch_faces/demo/lis2dw_logging_face.h
index 0272cd8f6e5fb4beaafe5b2aaa107727e7fc2851..cfae1a716b47091f91463952e3616e8abd4f5640 100644 (file)
--- a/movement/watch_faces/demo/lis2dw_logging_face.h
+++ b/movement/watch_faces/demo/lis2dw_logging_face.h
@@ -61,14 +61,14 @@ void lis2dw_logging_face_setup(uint8_t watch_face_index, void ** context_ptr);
 void lis2dw_logging_face_activate(void *context);
 bool lis2dw_logging_face_loop(movement_event_t event, void *context);
 void lis2dw_logging_face_resign(void *context);
-bool lis2dw_logging_face_wants_background_task(void *context);
+movement_watch_face_advisory_t lis2dw_logging_face_advise(void *context);
 
 #define lis2dw_logging_face ((const watch_face_t){ \
     lis2dw_logging_face_setup, \
     lis2dw_logging_face_activate, \
     lis2dw_logging_face_loop, \
     lis2dw_logging_face_resign, \
-    lis2dw_logging_face_wants_background_task, \
+    lis2dw_logging_face_advise, \
 })
 
 #endif // LIS2DW_LOGGING_FACE_H_

diff --git a/movement/watch_faces/sensor/accel_interrupt_count_face.c b/movement/watch_faces/sensor/accel_interrupt_count_face.c
index 82679c54a92c727d7986269cce6f27701acb013d..8d436aea11c62a89bcc0172535b3b7f9cf10c09b 100644 (file)
--- a/movement/watch_faces/sensor/accel_interrupt_count_face.c
+++ b/movement/watch_faces/sensor/accel_interrupt_count_face.c
@@ -153,7 +153,9 @@ void accel_interrupt_count_face_resign(void *context) {
     (void) context;
 }
 
-bool accel_interrupt_count_face_wants_background_task(void *context) {
+movement_watch_face_advisory_t accel_interrupt_count_face_advise(void *context) {
     (void) context;
-    return false;
+    movement_watch_face_advisory_t retval = { 0 };
+
+    return retval;
 }

diff --git a/movement/watch_faces/sensor/accel_interrupt_count_face.h b/movement/watch_faces/sensor/accel_interrupt_count_face.h
index 0f91363dd98262412bbc0f2d63659a2e12fb4a46..29d5df13dd2499b58974c492dacc234530f2641d 100644 (file)
--- a/movement/watch_faces/sensor/accel_interrupt_count_face.h
+++ b/movement/watch_faces/sensor/accel_interrupt_count_face.h
@@ -47,12 +47,12 @@ void accel_interrupt_count_face_setup(uint8_t watch_face_index, void ** context_
 void accel_interrupt_count_face_activate(void *context);
 bool accel_interrupt_count_face_loop(movement_event_t event, void *context);
 void accel_interrupt_count_face_resign(void *context);
-bool accel_interrupt_count_face_wants_background_task(void *context);
+movement_watch_face_advisory_t accel_interrupt_count_face_advise(void *context);
 
 #define accel_interrupt_count_face ((const watch_face_t){ \
     accel_interrupt_count_face_setup, \
     accel_interrupt_count_face_activate, \
     accel_interrupt_count_face_loop, \
     accel_interrupt_count_face_resign, \
-    accel_interrupt_count_face_wants_background_task, \
+    accel_interrupt_count_face_advise, \
 })

diff --git a/movement/watch_faces/sensor/minmax_face.c b/movement/watch_faces/sensor/minmax_face.c
index 10e2a9ed2fea8a6c2a8157d53e84f5b90a696b4a..7f52006331e1b263841da281f5a1fa18da2df989 100644 (file)
--- a/movement/watch_faces/sensor/minmax_face.c
+++ b/movement/watch_faces/sensor/minmax_face.c
@@ -143,8 +143,13 @@ void minmax_face_resign(void *context) {
 }
 
 
-bool minmax_face_wants_background_task(void *context) {
+movement_watch_face_advisory_t minmax_face_advise(void *context) {
     (void) context;
+
     // this will get called at the top of each minute; always request bg task
-    return true;
+    movement_watch_face_advisory_t retval = {
+        .wants_background_task = 1,
+    };
+
+    return retval;
 }

diff --git a/movement/watch_faces/sensor/minmax_face.h b/movement/watch_faces/sensor/minmax_face.h
index 4faf6794c71c566643ac9d2898ad94fdafe9df14..330f532ba593249d4660926295e56cc9adebc695 100644 (file)
--- a/movement/watch_faces/sensor/minmax_face.h
+++ b/movement/watch_faces/sensor/minmax_face.h
@@ -55,14 +55,14 @@ void minmax_face_setup(uint8_t watch_face_index, void ** context_ptr);
 void minmax_face_activate(void *context);
 bool minmax_face_loop(movement_event_t event, void *context);
 void minmax_face_resign(void *context);
-bool minmax_face_wants_background_task(void *context);
+movement_watch_face_advisory_t minmax_face_advise(void *context);
 
 #define minmax_face ((const watch_face_t){ \
     minmax_face_setup, \
     minmax_face_activate, \
     minmax_face_loop, \
     minmax_face_resign, \
-    minmax_face_wants_background_task, \
+    minmax_face_advise, \
 })
 
 #endif // MINMAX_FACE_H_

diff --git a/movement/watch_faces/sensor/thermistor_logging_face.c b/movement/watch_faces/sensor/thermistor_logging_face.c
index fe34e2ccf329dee08d7e815cc6ba8344cb82b33f..171daf271945725973f3c178a29cefb84a856005 100644 (file)
--- a/movement/watch_faces/sensor/thermistor_logging_face.c
+++ b/movement/watch_faces/sensor/thermistor_logging_face.c
@@ -127,9 +127,13 @@ void thermistor_logging_face_resign(void *context) {
     (void) context;
 }
 
-bool thermistor_logging_face_wants_background_task(void *context) {
+movement_watch_face_advisory_t thermistor_logging_face_advise(void *context) {
     (void) context;
+    movement_watch_face_advisory_t retval = { 0 };
+
     // this will get called at the top of each minute, so all we check is if we're at the top of the hour as well.
     // if we are, we ask for a background task.
-    return watch_rtc_get_date_time().unit.minute == 0;
+    retval.wants_background_task = watch_rtc_get_date_time().unit.minute == 0;
+
+    return retval;
 }

diff --git a/movement/watch_faces/sensor/thermistor_logging_face.h b/movement/watch_faces/sensor/thermistor_logging_face.h
index 346f23f774549d9234778f354b45d3b46f749067..a32a274b44340a17d8ec8300c9baf823bd19c475 100644 (file)
--- a/movement/watch_faces/sensor/thermistor_logging_face.h
+++ b/movement/watch_faces/sensor/thermistor_logging_face.h
@@ -74,14 +74,14 @@ void thermistor_logging_face_setup(uint8_t watch_face_index, void ** context_ptr
 void thermistor_logging_face_activate(void *context);
 bool thermistor_logging_face_loop(movement_event_t event, void *context);
 void thermistor_logging_face_resign(void *context);
-bool thermistor_logging_face_wants_background_task(void *context);
+movement_watch_face_advisory_t thermistor_logging_face_advise(void *context);
 
 #define thermistor_logging_face ((const watch_face_t){ \
     thermistor_logging_face_setup, \
     thermistor_logging_face_activate, \
     thermistor_logging_face_loop, \
     thermistor_logging_face_resign, \
-    thermistor_logging_face_wants_background_task, \
+    thermistor_logging_face_advise, \
 })
 
 #endif // THERMISTOR_LOGGING_FACE_H_

diff --git a/movement/watch_faces/settings/nanosec_face.c b/movement/watch_faces/settings/nanosec_face.c
index 23ff104061f52ee26cec2ba168c47f3128cb5467..ed5d73296d6ea9ab09341bc35f85fd6f931eeb7d 100644 (file)
--- a/movement/watch_faces/settings/nanosec_face.c
+++ b/movement/watch_faces/settings/nanosec_face.c
@@ -361,11 +361,15 @@ void nanosec_face_resign(void *context) {
 }
 
 // Background freq correction
-bool nanosec_face_wants_background_task(void *context) {
+movement_watch_face_advisory_t nanosec_face_advise(void *context) {
     (void) context;
-    if (nanosec_state.correction_profile == 0)
-        return 0; // No need for background correction if we are on profile 0 - static hardware correction.
-    watch_date_time date_time = watch_rtc_get_date_time();
+    movement_watch_face_advisory_t retval = { 0 };
+
+    // No need for background correction if we are on profile 0 - static hardware correction.
+    if (nanosec_state.correction_profile != 0) {
+        watch_date_time date_time = watch_rtc_get_date_time();
+        retval.wants_background_task = date_time.unit.minute % nanosec_state.correction_cadence == 0;
+    }
 
-    return date_time.unit.minute % nanosec_state.correction_cadence == 0;
+    return retval;
 }

diff --git a/movement/watch_faces/settings/nanosec_face.h b/movement/watch_faces/settings/nanosec_face.h
index 58167ee79432ec3abaa13cb2ad5d7cb72e1afeec..105773aea78414ecd18ebefaed234affe192ebf7 100644 (file)
--- a/movement/watch_faces/settings/nanosec_face.h
+++ b/movement/watch_faces/settings/nanosec_face.h
@@ -90,7 +90,7 @@ void nanosec_face_setup(uint8_t watch_face_index, void ** context_ptr);
 void nanosec_face_activate(void *context);
 bool nanosec_face_loop(movement_event_t event, void *context);
 void nanosec_face_resign(void *context);
-bool nanosec_face_wants_background_task(void *context);
+movement_watch_face_advisory_t nanosec_face_advise(void *context);
 void nanosec_ui_save(void);
 void nanosec_save(void);
 float nanosec_get_aging(void);
@@ -101,7 +101,7 @@ float nanosec_get_aging(void);
     nanosec_face_activate, \
     nanosec_face_loop, \
     nanosec_face_resign, \
-    nanosec_face_wants_background_task, \
+    nanosec_face_advise, \
 })
 
 #endif // NANOSEC_FACE_H_