android: drop health warnings in Stopped and NeedsLogin state

fixes tailscale/corp#36233

We should be dropping health warnings when we're not in the Running
state.  This also adds some functionality to inject fake health warnings
to make it possible to trigger these without triggering a real health
condition.

Signed-off-by: Jonathan Nobels <jonathan@tailscale.com>

Author: barnstar

android/src/main/java/com/tailscale/ipn/ui/notifier/HealthNotifier.kt

@@ -34,7 +34,7 @@ class HealthNotifier(
     const val HEALTH_CHANNEL_ID = "tailscale-health"
   }
 
-  private val TAG = "Health"
+  private val TAG = "health"
   private val ignoredWarnableCodes: Set<String> =
       setOf(
           // Ignored on Android because installing unstable takes quite some effort
@@ -45,26 +45,27 @@ class HealthNotifier(
           "wantrunning-false")
 
   init {
+    // This roughly matches the iOS/macOS implementation in terms of debouncing, and ingoring
+    // health warnings in various states.
     scope.launch {
       healthStateFlow
           .distinctUntilChanged { old, new -> old?.Warnings?.count() == new?.Warnings?.count() }
           .combine(ipnStateFlow, ::Pair)
-          .debounce(5000)
+          .debounce(3000)
           .collect { pair ->
             val health = pair.first
-            val ipnState = pair.second
-            // When the client is Stopped, no warnings should get added, and any warnings added
-            // previously should be removed.
-            if (ipnState == Ipn.State.Stopped) {
-              TSLog.d(
-                  TAG,
-                  "Ignoring and dropping all pre-existing health messages in the Stopped state")
-              dropAllWarnings()
-              return@collect
-            } else {
-              TSLog.d(TAG, "Health updated: ${health?.Warnings?.keys?.sorted()}")
-              health?.Warnings?.let {
-                notifyHealthUpdated(it.values.mapNotNull { it }.toTypedArray())
+            // Only deliver health notifications when the client is Running
+            when (val ipnState = pair.second) {
+              Ipn.State.Running -> {
+                TSLog.d(TAG, "Health updated: ${health?.Warnings?.keys?.sorted()}")
+                health?.Warnings?.let {
+                  notifyHealthUpdated(it.values.mapNotNull { it }.toTypedArray())
+                }
+              }
+              else -> {
+                TSLog.d(TAG, "Ignoring and dropping all health messages in state ${ipnState}")
+                dropAllWarnings()
+                return@collect
               }
             }
           }

android/src/main/java/com/tailscale/ipn/ui/notifier/HealthNotifierUtil.kt

@@ -0,0 +1,46 @@
+// Copyright (c) Tailscale Inc & AUTHORS
+// SPDX-License-Identifier: BSD-3-Clause
+
+package com.tailscale.ipn.ui.notifier
+
+import com.tailscale.ipn.ui.model.Health
+import com.tailscale.ipn.ui.util.set
+import kotlinx.coroutines.flow.MutableStateFlow
+
+/**
+ * Injects a fake Health.State for testing purposes.
+ * This bypasses the normal IPN bus notification flow.
+ */
+fun Notifier.injectFakeHealthState(
+    includeHighSeverity: Boolean = true,
+    includeConnectivityImpact: Boolean = false,
+    customWarnings: List<Health.UnhealthyState> = emptyList()
+) { 
+  val warnings = mutableMapOf<String, Health.UnhealthyState?>()
+  
+  if (includeHighSeverity) {
+    warnings["test-high-severity"] = Health.UnhealthyState(
+        WarnableCode = "test-high-severity",
+        Severity = Health.Severity.high,
+        Title = "Test High Severity Warning",
+        Text = "This is a test warning with high severity",
+        ImpactsConnectivity = includeConnectivityImpact,
+        DependsOn = null
+    )
+  }
+  
+  warnings["test-low-severity"] = Health.UnhealthyState(
+      WarnableCode = "test-low-severity",
+      Severity = Health.Severity.low,
+      Title = "Test Low Severity Warning",
+      Text = "This is a test warning with low severity",
+      ImpactsConnectivity = false,
+      DependsOn = null
+  )
+  
+  customWarnings.forEach { warning ->
+    warnings[warning.WarnableCode] = warning
+  }
+  
+  (health as MutableStateFlow).set(Health.State(Warnings = warnings))
+}

android/src/main/java/com/tailscale/ipn/ui/notifier/Notifier.kt

@@ -20,6 +20,9 @@ import kotlinx.serialization.ExperimentalSerializationApi
 import kotlinx.serialization.json.Json
 import kotlinx.serialization.json.decodeFromStream
 
+// When set to true, the Notifier will inject fake health warnings for testing purposes
+val INJECT_FAKE_HEALTH_WARNINGS = false
+
 // Notifier is a wrapper around the IPN Bus notifier.  It provides a way to watch
 // for changes in various parts of the Tailscale engine.  You will typically only use
 // a single Notifier per instance of your application which lasts for the lifetime of
@@ -86,7 +89,13 @@ object Notifier {
             notify.OutgoingFiles?.let(outgoingFiles::set)
             notify.FilesWaiting?.let(filesWaiting::set)
             notify.IncomingFiles?.let(incomingFiles::set)
-            notify.Health?.let(health::set)
+            notify.Health?.let {
+              if (INJECT_FAKE_HEALTH_WARNINGS) {
+                injectFakeHealthState()
+              } else {
+                health.set(it)
+              }
+            }
           }
     }
   }