feat: Android notifications, lock-screen signal, keyguard detection (partial)

Agent-Logs-Url: https://github.com/gfauredev/LogOut/sessions/21f3bfed-afee-4983-99b1-e3faf77febd1

Co-authored-by: gfauredev <19304085+gfauredev@users.noreply.github.com>

Author: Copilot

src/components/session_timers.rs

@@ -1,6 +1,5 @@
 use crate::models::{format_time, format_time_i64, get_current_timestamp, Force};
 use dioxus::prelude::*;
-#[cfg(target_arch = "wasm32")]
 use dioxus_i18n::t;
 /// Timer tick interval in milliseconds
 #[cfg(target_arch = "wasm32")]
@@ -234,6 +233,25 @@ pub(super) fn RestTimerDisplay(
                 schedule_notification_at(title, body, "logout-rest", target_unix_ms);
             }
         }
+        // On native (Android), schedule a precise one-shot notification via tokio.
+        #[cfg(not(target_arch = "wasm32"))]
+        if let Some(start) = start_time {
+            if rest_duration > 0 {
+                let title = t!("notif-rest-title").to_string();
+                let body = t!("notif-rest-body").to_string();
+                let fire_at_secs = start + rest_duration;
+                tokio::spawn(async move {
+                    let now = crate::models::get_current_timestamp();
+                    if fire_at_secs > now {
+                        let delay = std::time::Duration::from_secs(fire_at_secs - now);
+                        tokio::time::sleep(delay).await;
+                    }
+                    crate::services::android_notifications::send_notification(
+                        &title, &body, "logout-rest",
+                    );
+                });
+            }
+        }
     }
     let Some(start) = start_time else {
         return rsx! {
@@ -255,6 +273,12 @@ pub(super) fn RestTimerDisplay(
                 &t!("notif-rest-body"),
                 "logout-rest",
             );
+            #[cfg(not(target_arch = "wasm32"))]
+            crate::services::android_notifications::send_notification(
+                &t!("notif-rest-title"),
+                &t!("notif-rest-body"),
+                "logout-rest",
+            );
         }
     }
     let remaining = rd.cast_signed() - elapsed.cast_signed();
@@ -295,6 +319,27 @@ pub(super) fn ExerciseElapsedTimer(
                 }
             }
         }
+        // On native (Android), schedule a precise one-shot notification via tokio.
+        #[cfg(not(target_arch = "wasm32"))]
+        if !*duration_bell_rung.read() {
+            if let (Some(start), Some(dur)) = (exercise_start, last_duration) {
+                if dur > 0 {
+                    let title = t!("notif-duration-title").to_string();
+                    let body = t!("notif-duration-body").to_string();
+                    let fire_at_secs = start + dur;
+                    tokio::spawn(async move {
+                        let now = crate::models::get_current_timestamp();
+                        if fire_at_secs > now {
+                            let delay = std::time::Duration::from_secs(fire_at_secs - now);
+                            tokio::time::sleep(delay).await;
+                        }
+                        crate::services::android_notifications::send_notification(
+                            &title, &body, "logout-duration",
+                        );
+                    });
+                }
+            }
+        }
     });
     let mut now_tick = use_signal(get_current_timestamp);
     use_coroutine(move |_: UnboundedReceiver<()>| async move {
@@ -323,6 +368,12 @@ pub(super) fn ExerciseElapsedTimer(
                     &t!("notif-duration-body"),
                     "logout-duration",
                 );
+                #[cfg(not(target_arch = "wasm32"))]
+                crate::services::android_notifications::send_notification(
+                    &t!("notif-duration-title"),
+                    &t!("notif-duration-body"),
+                    "logout-duration",
+                );
             }
         }
     }
@@ -362,6 +413,27 @@ pub(super) fn InlineExerciseTimer(
                 }
             }
         }
+        // On native (Android), schedule a precise one-shot notification via tokio.
+        #[cfg(not(target_arch = "wasm32"))]
+        if !*duration_bell_rung.read() {
+            if let (Some(start), Some(dur)) = (exercise_start, last_duration) {
+                if dur > 0 {
+                    let title = t!("notif-duration-title").to_string();
+                    let body = t!("notif-duration-body").to_string();
+                    let fire_at_secs = start + dur;
+                    tokio::spawn(async move {
+                        let now = crate::models::get_current_timestamp();
+                        if fire_at_secs > now {
+                            let delay = std::time::Duration::from_secs(fire_at_secs - now);
+                            tokio::time::sleep(delay).await;
+                        }
+                        crate::services::android_notifications::send_notification(
+                            &title, &body, "logout-duration",
+                        );
+                    });
+                }
+            }
+        }
     });
     let mut now_tick = use_signal(get_current_timestamp);
     use_coroutine(move |_: UnboundedReceiver<()>| async move {
@@ -390,6 +462,12 @@ pub(super) fn InlineExerciseTimer(
                     &t!("notif-duration-body"),
                     "logout-duration",
                 );
+                #[cfg(not(target_arch = "wasm32"))]
+                crate::services::android_notifications::send_notification(
+                    &t!("notif-duration-title"),
+                    &t!("notif-duration-body"),
+                    "logout-duration",
+                );
             }
         }
     }

src/main.rs

@@ -66,6 +66,12 @@ pub struct DbEmptyToastSignal(pub Signal<bool>);
 /// `None` when idle; `Some((downloaded, total))` while downloading images.
 #[derive(Clone, Copy)]
 pub struct ImageDownloadProgressSignal(pub Signal<Option<(usize, usize)>>);
+/// Global context signal that is `true` while the Android keyguard (lock screen)
+/// is active **and** the app is being shown over it (i.e. there is or was an
+/// active session).  While this is `true`, all writes except those targeting the
+/// currently active session are refused.
+#[derive(Clone, Copy)]
+pub struct ScreenLockedSignal(pub Signal<bool>);
 #[derive(Clone, Routable, Debug, PartialEq)]
 #[rustfmt::skip]
 enum Route {
@@ -173,6 +179,7 @@ fn App() -> Element {
     use_context_provider(|| PendingDeepLinkSignal(Signal::new(None)));
     use_context_provider(|| ShowRestInputSignal(Signal::new(false)));
     use_context_provider(|| RestDurationSignal(Signal::new(DEFAULT_REST_SECONDS)));
+    use_context_provider(|| ScreenLockedSignal(Signal::new(false)));
 
     // Services that consume contexts (must run after context providers above).
     services::storage::provide_app_state();
@@ -190,6 +197,25 @@ fn App() -> Element {
         });
     }
 
+    // On Android: poll the keyguard (lock screen) state every second and update
+    // `ScreenLockedSignal` so that write guards throughout the app can react.
+    // The poll only runs while the app is shown over the lock screen (i.e. a
+    // screen-wake-lock is held); otherwise the check is a no-op.
+    #[cfg(target_os = "android")]
+    {
+        let mut screen_locked = consume_context::<ScreenLockedSignal>().0;
+        use_coroutine(move |_: futures_channel::mpsc::UnboundedReceiver<()>| async move {
+            loop {
+                tokio::time::sleep(std::time::Duration::from_secs(1)).await;
+                let locked = services::wake_lock::is_shown_over_lock_screen()
+                    && services::wake_lock::is_keyguard_locked();
+                if *screen_locked.peek() != locked {
+                    screen_locked.set(locked);
+                }
+            }
+        });
+    }
+
     #[cfg(not(target_arch = "wasm32"))]
     services::storage::native_queue::use_native_results();
     #[cfg(target_arch = "wasm32")]