Merge pull request #26 from SableClient/fix/embedded-push-diagnostics

fix: record built-in push connection diagnostics

Author: eleboucher

android/src/main/java/app/tauri/notification/EmbeddedPushService.kt

@@ -52,6 +52,7 @@ class EmbeddedPushService : Service() {
         }
 
         if (endpoint != nextEndpoint) {
+            PushDiagnostics.record(this, PushOutcome.EMBEDDED_STARTED)
             handler.removeCallbacksAndMessages(null)
             socket?.cancel()
             socket = null
@@ -110,14 +111,18 @@ class EmbeddedPushService : Service() {
                 }
                 if (event == "open") {
                     Log.i(TAG, "Push gateway subscription ready")
+                    PushDiagnostics.record(this@EmbeddedPushService, PushOutcome.EMBEDDED_READY)
                     ready = true
                     retryDelay = BASE_BACKOFF_MS
                     endpoint?.let { NotificationPlugin.instance?.onEmbeddedPushReady(it) }
                     return@post
                 }
+                if (event != "message") return@post
+                PushDiagnostics.record(this@EmbeddedPushService, PushOutcome.EMBEDDED_MESSAGE_RECEIVED)
                 val sealed = EmbeddedPushEndpoint.pushBody(text) ?: return@post
                 pushExecutor.execute {
                     val body = decrypt(sealed) ?: return@execute
+                    PushDiagnostics.record(this@EmbeddedPushService, PushOutcome.EMBEDDED_DECRYPTED)
                     runCatching { UnifiedPushNotifier.showFromPush(this@EmbeddedPushService, body) }
                         .onFailure { Log.w(TAG, "Could not display the push notification") }
                     handler.post {
@@ -130,20 +135,21 @@ class EmbeddedPushService : Service() {
         }
 
         override fun onFailure(webSocket: WebSocket, t: Throwable, response: Response?) {
-            disconnected(webSocket)
+            disconnected(webSocket, if (response != null) PushOutcome.EMBEDDED_HTTP_REJECTED else PushOutcome.EMBEDDED_SOCKET_FAILED)
         }
 
         override fun onClosing(webSocket: WebSocket, code: Int, reason: String) {
             webSocket.close(code, null)
         }
 
         override fun onClosed(webSocket: WebSocket, code: Int, reason: String) {
-            disconnected(webSocket)
+            disconnected(webSocket, PushOutcome.EMBEDDED_CLOSED)
         }
 
-        private fun disconnected(webSocket: WebSocket) {
+        private fun disconnected(webSocket: WebSocket, outcome: PushOutcome) {
             handler.post {
                 if (closing || socket !== webSocket) return@post
+                PushDiagnostics.record(this@EmbeddedPushService, outcome)
                 socket = null
                 ready = false
                 scheduleReconnect(url)
@@ -158,6 +164,7 @@ class EmbeddedPushService : Service() {
         // A plaintext relay is used for testing; not a failure worth logging.
         if (sealed.isNotEmpty() && sealed[0] == '{'.code.toByte()) return String(sealed)
 
+        PushDiagnostics.record(this, PushOutcome.EMBEDDED_DECRYPT_FAILED)
         Log.w(TAG, "Could not decrypt the push body")
         return null
     }

android/src/main/java/app/tauri/notification/NotificationPlugin.kt

@@ -946,6 +946,9 @@ class NotificationPlugin(private val activity: Activity): Plugin(activity) {
         if (registration.phase == PushRegistrationPhase.UNIFIED_PUSH || registration.phase == PushRegistrationPhase.DISTRIBUTOR) {
           retireUnifiedPush(registration.instance)
         }
+        if (registration.phase == PushRegistrationPhase.EMBEDDED) {
+          PushDiagnostics.record(activity, PushOutcome.EMBEDDED_REGISTRATION_TIMEOUT)
+        }
         finishPushRegistrationError("Timed out registering for push notifications")
       }
     }

android/src/main/java/app/tauri/notification/PushDiagnostics.kt

@@ -11,6 +11,15 @@ internal enum class PushOutcome {
     NO_NATIVE_LIB,
     DECRYPT_FAILED,
     EMPTY_BODY,
+    EMBEDDED_STARTED,
+    EMBEDDED_READY,
+    EMBEDDED_SOCKET_FAILED,
+    EMBEDDED_HTTP_REJECTED,
+    EMBEDDED_CLOSED,
+    EMBEDDED_MESSAGE_RECEIVED,
+    EMBEDDED_DECRYPTED,
+    EMBEDDED_DECRYPT_FAILED,
+    EMBEDDED_REGISTRATION_TIMEOUT,
 }
 
 internal data class PushDiagnosticsSnapshot(
@@ -25,6 +34,7 @@ internal object PushDiagnostics {
     private const val KEY_LAST = "push-outcome-last"
     private const val KEY_LAST_AT = "push-outcome-last-at"
 
+    @Synchronized
     fun record(context: Context, outcome: PushOutcome) {
         val prefs = context.getSharedPreferences(PREFS, Context.MODE_PRIVATE)
         val key = KEY_PREFIX + outcome.name
@@ -35,6 +45,7 @@ internal object PushDiagnostics {
             .apply()
     }
 
+    @Synchronized
     fun drain(context: Context): PushDiagnosticsSnapshot {
         val prefs = context.getSharedPreferences(PREFS, Context.MODE_PRIVATE)
         val counts = PushOutcome.entries.associate { outcome ->

android/src/test/java/app/tauri/notification/EmbeddedPushRegistrationTest.kt

@@ -1,16 +1,21 @@
 package app.tauri.notification
 
 import android.app.Activity
+import android.content.ComponentName
+import android.content.IntentFilter
 import android.os.Looper
 import app.tauri.plugin.Invoke
 import app.tauri.plugin.JSObject
 import io.mockk.every
 import io.mockk.just
 import io.mockk.mockk
+import io.mockk.mockkObject
+import io.mockk.unmockkObject
 import io.mockk.Runs
 import io.mockk.spyk
 import io.mockk.verify
 import java.time.Duration
+import kotlin.test.assertFalse
 import kotlin.test.assertEquals
 import kotlin.test.assertNotEquals
 import kotlin.test.assertTrue
@@ -34,9 +39,14 @@ class EmbeddedPushRegistrationTest {
     @Before
     fun setup() {
         assumeTrue(BuildConfig.ENABLE_PUSH_NOTIFICATIONS)
+        mockkObject(CachedKeyManager.Companion)
+        every { CachedKeyManager.getInstance(any()) } returns mockk(relaxed = true) {
+            every { getPublicKeySet(any()) } returns null
+        }
         val activity = Robolectric.buildActivity(Activity::class.java).setup().get()
         state = UnifiedPushStateStore(activity)
         state.useEmbeddedDistributor = true
+        PushDiagnostics.drain(activity)
         plugin = spyk(NotificationPlugin(activity))
         every { plugin.trigger(any(), any<JSObject>()) } just Runs
         val manager = mockk<TauriNotificationManager>()
@@ -55,6 +65,7 @@ class EmbeddedPushRegistrationTest {
     @After
     fun teardown() {
         if (::plugin.isInitialized) plugin.onDestroy()
+        unmockkObject(CachedKeyManager.Companion)
     }
 
     @Test
@@ -94,10 +105,40 @@ class EmbeddedPushRegistrationTest {
         shadowOf(Looper.getMainLooper()).idleFor(Duration.ofSeconds(30))
         plugin.onEmbeddedPushReady(state.endpoint!!)
 
+        assertEquals(1, PushDiagnostics.drain(org.robolectric.RuntimeEnvironment.getApplication()).counts["EMBEDDED_REGISTRATION_TIMEOUT"])
         verify(exactly = 1) { invoke.reject("Timed out registering for push notifications") }
         verify(exactly = 0) { invoke.resolve(any<JSObject>()) }
     }
 
+    @Test
+    fun switchesFromBuiltInToExternalDistributor() {
+        val application = org.robolectric.RuntimeEnvironment.getApplication()
+        val component = ComponentName("io.heckel.ntfy", "PushReceiver")
+        val packages = shadowOf(application.packageManager)
+        packages.addReceiverIfNotPresent(component).exported = true
+        packages.addIntentFilterForReceiver(
+            component, IntentFilter("org.unifiedpush.android.distributor.REGISTER"),
+        )
+        assertEquals(listOf("io.heckel.ntfy"), org.unifiedpush.android.connector.UnifiedPush.getDistributors(application))
+        plugin.registerForPushNotifications(invoke)
+        plugin.onEmbeddedPushReady(state.endpoint!!)
+        val selection = mockk<Invoke>(relaxed = true)
+        every { selection.parseArgs(DistributorArgs::class.java) } returns DistributorArgs().apply {
+            distributor = "io.heckel.ntfy"
+        }
+        plugin.setDistributor(selection)
+        assertFalse(state.useEmbeddedDistributor)
+        plugin.registerForPushNotifications(invoke)
+        verify(exactly = 0) { invoke.reject(any<String>()) }
+        val externalEndpoint = "https://ntfy.sh/up0123456789ab?up=1"
+        plugin.onUnifiedPushNewEndpoint(externalEndpoint, "external-key", "external-auth", UnifiedPushStateStore.INSTANCE)
+
+        assertEquals("unifiedpush", state.activeProvider)
+        assertEquals("io.heckel.ntfy", state.distributor)
+        assertEquals(externalEndpoint, state.endpoint)
+        verify { invoke.resolve(match<JSObject> { it.optString("deviceToken") == externalEndpoint }) }
+    }
+
     @Test
     fun reusesCompatibleTopic() {
         state.embeddedTopic = "up0123456789ab"

android/src/test/java/app/tauri/notification/EmbeddedPushServiceTest.kt

@@ -42,6 +42,7 @@ class EmbeddedPushServiceTest {
         state.endpoint = endpoint
         plugin = mockk(relaxed = true)
         NotificationPlugin.instance = plugin
+        PushDiagnostics.drain(service)
         val client = mockk<OkHttpClient>(relaxed = true)
         every { client.newWebSocket(any(), any()) } answers {
             val socket = mockk<WebSocket>(relaxed = true)
@@ -78,11 +79,13 @@ class EmbeddedPushServiceTest {
         listener.onOpen(socket, mockk())
         shadowOf(Looper.getMainLooper()).idle()
         verify(exactly = 0) { plugin.onEmbeddedPushReady(any()) }
+        assertEquals(mapOf("EMBEDDED_STARTED" to 1), PushDiagnostics.drain(service).counts)
 
         frame(0, """{"event":"open"}""")
 
         verify(exactly = 1) { plugin.onEmbeddedPushReady(endpoint) }
         assertEquals(listOf("https://ntfy.sh/up0123456789ab/ws"), urls)
+        assertEquals(mapOf("EMBEDDED_READY" to 1), PushDiagnostics.drain(service).counts)
     }
 
     @Test
@@ -107,6 +110,9 @@ class EmbeddedPushServiceTest {
         executor.submit {}.get(5, TimeUnit.SECONDS)
         shadowOf(Looper.getMainLooper()).idle()
         verify(exactly = 1) { plugin.onUnifiedPushMessage(body, UnifiedPushStateStore.INSTANCE) }
+        val counts = PushDiagnostics.drain(service).counts
+        assertEquals(1, counts["EMBEDDED_MESSAGE_RECEIVED"])
+        assertEquals(1, counts["EMBEDDED_DECRYPTED"])
     }
 
     @Test
@@ -145,6 +151,8 @@ class EmbeddedPushServiceTest {
         shadowOf(Looper.getMainLooper()).idleFor(Duration.ofSeconds(1))
 
         assertEquals(2, connections.size)
+        assertEquals(1, PushDiagnostics.drain(service).counts["EMBEDDED_SOCKET_FAILED"])
+        assertEquals(emptyMap(), PushDiagnostics.drain(service).counts)
     }
 
     @Test