fw/services/touch: let system subscriptions opt out of backlight override

touch_has_app_subscribers() derived its answer from the total subscriber
count minus the backlight subscription, which was written when the
backlight was the only kernel-side subscriber. The watchface long-press
hook added a second permanent subscription, making the function always
return true: the event loop then lit the backlight on every touchdown
and skipped the wake-gesture preference, so a single touch woke the
screen even with touch-to-wake set to double tap.

Add touch_set_system_subscribed() so system-internal subscriptions can
explicitly exclude themselves, and mark the watchface long-press hook
with it. Third-party app subscriptions keep the touchdown-driven
backlight behavior unchanged.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Signed-off-by: Eric Migicovsky <ericmigi@gmail.com>

Author: ericmigi

include/pbl/services/touch/touch.h

@@ -24,7 +24,14 @@ void touch_init(void);
 //! When disabled, the touch sensor is only active if apps have subscribed to touch events.
 void touch_set_backlight_enabled(bool enabled);
 
-//! @return true if at least one subscriber is currently registered for touch events.
+//! Mark (or unmark) one subscription as a system-internal consumer that must
+//! not count towards touch_has_app_subscribers(). Call with true after
+//! subscribing and with false before unsubscribing.
+void touch_set_system_subscribed(bool subscribed);
+
+//! @return true if at least one subscriber other than the system-internal
+//! ones (backlight, subscriptions marked via touch_set_system_subscribed())
+//! is currently registered for touch events.
 bool touch_has_app_subscribers(void);
 
 //! Globally enable or disable touch. When disabled:

src/fw/services/touch/touch.c

@@ -25,6 +25,11 @@ static int16_t s_last_y;
 static PebbleMutex *s_touch_mutex;
 
 static uint8_t s_subscriber_count = 0;
+//! Subscriptions explicitly marked as system-internal (e.g. the watchface
+//! long-press hook): they keep the sensor powered but must not count as
+//! "an app is using touch". The backlight subscription is tracked separately
+//! via s_backlight_subscribed and excluded the same way.
+static uint8_t s_system_subscriber_count = 0;
 static bool s_backlight_subscribed = false;
 static bool s_globally_enabled = true;
 static bool s_rotated = false;
@@ -55,6 +60,17 @@ static void prv_remove_subscriber_cb(PebbleTask task) {
   mutex_unlock(s_touch_mutex);
 }
 
+void touch_set_system_subscribed(bool subscribed) {
+  mutex_lock(s_touch_mutex);
+  if (subscribed) {
+    s_system_subscriber_count++;
+  } else {
+    PBL_ASSERTN(s_system_subscriber_count > 0);
+    s_system_subscriber_count--;
+  }
+  mutex_unlock(s_touch_mutex);
+}
+
 void touch_init(void) {
   s_touch_mutex = mutex_create();
 
@@ -66,10 +82,10 @@ void touch_init(void) {
 
 bool touch_has_app_subscribers(void) {
   mutex_lock(s_touch_mutex);
-  // The backlight gesture subscription is tracked in s_subscriber_count as
-  // well; exclude it so this only reflects real app subscribers.
-  const uint8_t backlight_count = s_backlight_subscribed ? 1 : 0;
-  const bool has_apps = s_subscriber_count > backlight_count;
+  // Exclude the system-internal subscriptions (backlight, marked system
+  // subscribers) so this only reflects real app subscribers.
+  const uint8_t excluded = (s_backlight_subscribed ? 1 : 0) + s_system_subscriber_count;
+  const bool has_apps = s_subscriber_count > excluded;
   mutex_unlock(s_touch_mutex);
   return has_apps;
 }

src/fw/shell/normal/watchface.c

@@ -24,6 +24,7 @@
 #ifdef CONFIG_TOUCH
 #include "applib/touch_service.h"
 #include "apps/system/watchfaces.h"
+#include "pbl/services/touch/touch.h"
 #include <pbl/util/math.h>
 #endif
 #include "pbl/services/notifications/do_not_disturb.h"
@@ -385,8 +386,10 @@ void watchface_init(void) {
 #ifdef CONFIG_TOUCH
   // Kernel-side subscription: keeps the touch sensor powered so a long press
   // on the watchface can open the selector. Foreground gating happens in the
-  // handler itself.
+  // handler itself. Marked as a system subscription so it doesn't trigger the
+  // touch-backlight override meant for third-party touch apps.
   touch_service_subscribe(prv_watchface_touch_handler, NULL);
+  touch_set_system_subscribed(true);
 #endif
 }
 

tests/fw/services/test_touch.c

@@ -211,6 +211,29 @@ void test_touch__has_app_subscribers_backlight(void) {
   cl_assert(!touch_has_app_subscribers());
 }
 
+void test_touch__has_app_subscribers_system(void) {
+  // Subscriptions marked as system-internal (e.g. the watchface long-press
+  // hook) keep the sensor powered but must not count as app subscribers, or
+  // the event loop would light the backlight on every touchdown and bypass
+  // the wake-gesture preference. Unmarked subscribers keep counting so the
+  // touch-backlight behavior for third-party touch apps is unaffected.
+  cl_assert(!touch_has_app_subscribers());
+
+  s_add_subscriber_cb(PebbleTask_KernelMain);
+  touch_set_system_subscribed(true);
+  cl_assert(!touch_has_app_subscribers());
+
+  s_add_subscriber_cb(PebbleTask_App);
+  cl_assert(touch_has_app_subscribers());
+
+  s_remove_subscriber_cb(PebbleTask_App);
+  cl_assert(!touch_has_app_subscribers());
+
+  touch_set_system_subscribed(false);
+  s_remove_subscriber_cb(PebbleTask_KernelMain);
+  cl_assert(!touch_has_app_subscribers());
+}
+
 void test_touch__globally_enabled_default_true(void) {
   // Default state after init is enabled; no setter call required.
   cl_assert(touch_service_is_globally_enabled());