@mentra/crust 3.2.0-dev.168 → 3.2.0-dev.177

package/android/build.gradle

@@ -144,3 +144,9 @@ dependencies {
   implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.8.1'
   implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.8.1'
 }
+
+// Notification lifecycle tests run against Android APIs without a device.
+dependencies {
+  testImplementation 'junit:junit:4.13.2'
+  testImplementation 'org.robolectric:robolectric:4.11.1'
+}

package/android/src/main/AndroidManifest.xml

@@ -15,6 +15,9 @@
       <intent-filter>
         <action android:name="android.service.notification.NotificationListenerService" />
       </intent-filter>
+      <!-- Use on-demand binding (Android 14+) so startup and permission-grant
+           recovery can explicitly request a bind after applying listener config. -->
+      <meta-data android:name="android.service.notification.default_autobind_listenerservice" android:value="false" />
       <meta-data android:name="android.service.notification.default_filter_types" android:value="conversations|alerting" />
       <meta-data android:name="android.service.notification.disabled_filter_types" android:value="ongoing|silent" />
     </service>

package/android/src/main/java/com/mentra/crust/services/NotificationListener.kt

@@ -40,6 +40,7 @@ class NotificationListener private constructor(private val context: Context) {
      * The component stays enabled so Android can show it in notification-access
      * Settings, but its service process only starts after access is granted.
      */
+    @Synchronized
     fun setNotificationConfig(
       context: Context,
       listenerEnabled: Boolean,
@@ -49,26 +50,12 @@ class NotificationListener private constructor(private val context: Context) {
       val blocklistSet = blocklist.toSet()
       persistConfig(applicationContext, listenerEnabled, blocklistSet)
 
-      val permissionGranted = hasNotificationListenerPermission(applicationContext)
-      val shouldRun = listenerEnabled && permissionGranted
-      val componentChanged = updateComponentState(applicationContext, enabled = listenerEnabled)
-
-      // Keep the isolated process's own SharedPreferences cache and live
-      // singleton in sync. A rebind is only needed when enabling the component;
-      // ordinary blocklist updates must not restart a healthy listener.
-      if (permissionGranted) {
-        NotificationProcessBridge.sendConfig(
-          applicationContext,
-          listenerEnabled,
-          blocklistSet,
-          requestRebind = shouldRun && componentChanged,
-        )
-      }
-
-      if (!shouldRun) {
-        Log.d(TAG, "Notification listener prerequisites not met; service will not start")
-        return
-      }
+      reconcileNotificationConfig(
+        applicationContext,
+        listenerEnabled,
+        blocklistSet,
+        hasNotificationListenerPermission(applicationContext),
+      )
     }
 
     /**
@@ -78,6 +65,7 @@ class NotificationListener private constructor(private val context: Context) {
      * newly granted listener starts immediately. Without permission the service
      * is not rebound and the isolated process is never started.
      */
+    @Synchronized
     fun refreshComponentForPermission(context: Context): Boolean {
       val applicationContext = context.applicationContext
       val permissionGranted = hasNotificationListenerPermission(applicationContext)
@@ -86,19 +74,38 @@ class NotificationListener private constructor(private val context: Context) {
       val blocklist =
         preferences.getStringSet(PREF_NOTIFICATIONS_BLOCKLIST, emptySet())?.toSet() ?: emptySet()
 
+      reconcileNotificationConfig(
+        applicationContext,
+        listenerEnabled,
+        blocklist,
+        permissionGranted,
+        forceRebind = true,
+      )
+      return permissionGranted
+    }
+
+    /** Both app entrypoints use one rebind decision; the receiver owns the request. */
+    private fun reconcileNotificationConfig(
+      context: Context,
+      listenerEnabled: Boolean,
+      blocklist: Set<String>,
+      permissionGranted: Boolean,
+      forceRebind: Boolean = false,
+    ) {
       val shouldRun = listenerEnabled && permissionGranted
-      updateComponentState(applicationContext, enabled = listenerEnabled)
+      val componentChanged = updateComponentState(context, enabled = listenerEnabled)
+      val shouldRebind = shouldRun && (forceRebind || componentChanged)
       if (permissionGranted) {
+        // The explicit broadcast starts :notif if needed. Its receiver applies
+        // the config before requesting the bind, avoiding duplicate requests
+        // and a listener that starts with a stale per-process preferences cache.
         NotificationProcessBridge.sendConfig(
-          applicationContext,
+          context,
           listenerEnabled,
           blocklist,
-          // This method is reserved for the confirmed permission-grant path.
-          // The :notif receiver persists the config before requesting rebind.
-          requestRebind = shouldRun,
+          requestRebind = shouldRebind,
         )
       }
-      return permissionGranted
     }
 
     fun openNotificationListenerSettings(context: Context) {
@@ -157,10 +164,11 @@ class NotificationListener private constructor(private val context: Context) {
       }
     }
 
-    internal fun requestListenerRebind(context: Context) {
+    internal fun requestListenerRebind(context: Context): Boolean {
       val component = ComponentName(context, NotificationListenerServiceImpl::class.java)
-      runCatching { NotificationListenerService.requestRebind(component) }
+      return runCatching { NotificationListenerService.requestRebind(component) }
         .onFailure { Log.w(TAG, "Could not request notification-listener rebind", it) }
+        .isSuccess
     }
 
     internal fun applyConfigToExisting(

package/android/src/main/java/com/mentra/crust/services/NotificationProcessBridge.kt

@@ -205,6 +205,12 @@ internal data class NotificationConfigUpdate(
 
 /** Persists and applies config inside the isolated notification process. */
 class NotificationConfigReceiver : BroadcastReceiver() {
+  companion object {
+    // Owned by :notif, so process death resets recovery independently of the
+    // main app. BroadcastReceiver instances themselves are short-lived.
+    private var rebindRequestedThisProcess = false
+  }
+
   override fun onReceive(context: Context, intent: Intent) {
     if (!NotificationProcessBridge.isConfigAction(context, intent)) return
     val config = NotificationProcessBridge.readConfig(intent)
@@ -215,8 +221,12 @@ class NotificationConfigReceiver : BroadcastReceiver() {
     NotificationListener.persistConfig(context, config.listenerEnabled, config.blocklist)
     NotificationListener.applyConfigToExisting(config.listenerEnabled, config.blocklist)
 
-    if (config.listenerEnabled && config.requestRebind) {
-      NotificationListener.requestListenerRebind(context)
+    if (!config.listenerEnabled || !NotificationListener.hasNotificationListenerPermission(context)) {
+      rebindRequestedThisProcess = false
+      return
+    }
+    if (config.requestRebind || !rebindRequestedThisProcess) {
+      rebindRequestedThisProcess = NotificationListener.requestListenerRebind(context)
     }
   }
 }

package/android/src/test/java/com/mentra/crust/services/NotificationListenerConfigTest.kt

@@ -0,0 +1,179 @@
+package com.mentra.crust.services
+
+import android.app.Application
+import android.content.ComponentName
+import android.content.Intent
+import android.provider.Settings
+import android.service.notification.NotificationListenerService
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.RuntimeEnvironment
+import org.robolectric.Shadows.shadowOf
+import org.robolectric.annotation.Config
+import org.robolectric.annotation.Implementation
+import org.robolectric.annotation.Implements
+
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [28], manifest = Config.NONE, shadows = [RebindRecorder::class])
+class NotificationListenerConfigTest {
+  private lateinit var context: Application
+
+  @Before
+  fun reset() {
+    context = RuntimeEnvironment.getApplication()
+    grantPermission(false)
+    NotificationListener.setNotificationConfig(context, false, emptyList())
+    NotificationConfigReceiver().onReceive(
+      context,
+      Intent(context.packageName + ".crust.NOTIFICATION_CONFIG"),
+    )
+    RebindRecorder.requests.clear()
+    RebindRecorder.failRequest = false
+  }
+
+  @Test
+  fun startupRebindsOnlyThroughReceiverAndConfigUpdatesDoNotRebind() {
+    grantPermission(true)
+    context.packageManager.setComponentEnabledSetting(
+      component(),
+      android.content.pm.PackageManager.COMPONENT_ENABLED_STATE_ENABLED,
+      android.content.pm.PackageManager.DONT_KILL_APP,
+    )
+    NotificationListener.setNotificationConfig(context, true, emptyList())
+    assertTrue(RebindRecorder.requests.isEmpty())
+    deliverLatestConfig(expectedRebind = false)
+    assertEquals(1, RebindRecorder.requests.size)
+
+    NotificationListener.setNotificationConfig(context, true, listOf("blocked.app"))
+    deliverLatestConfig(expectedRebind = false)
+    assertEquals(1, RebindRecorder.requests.size)
+    assertEquals(setOf("blocked.app"), preferences().getStringSet("notifications_blocklist", emptySet()))
+  }
+
+  @Test
+  fun freshNotificationProcessRecoversOnConfigOnlyBroadcast() {
+    grantPermission(true)
+    NotificationListener.setNotificationConfig(context, true, emptyList())
+    // The app has already requested startup recovery, but the receiver starts
+    // fresh in :notif. This is also the state after only :notif was killed.
+    NotificationListener.setNotificationConfig(context, true, listOf("blocked.app"))
+    deliverLatestConfig(expectedRebind = false)
+    assertEquals(1, RebindRecorder.requests.size)
+
+    NotificationListener.setNotificationConfig(context, true, emptyList())
+    deliverLatestConfig(expectedRebind = false)
+    assertEquals(1, RebindRecorder.requests.size)
+  }
+
+  @Test
+  fun failedRequestCanRetryOnNextConfigWithoutRestartingProcess() {
+    grantPermission(true)
+    NotificationListener.setNotificationConfig(context, true, emptyList())
+    RebindRecorder.failRequest = true
+    deliverLatestConfig(expectedRebind = true)
+    assertTrue(RebindRecorder.requests.isEmpty())
+
+    RebindRecorder.failRequest = false
+    NotificationListener.setNotificationConfig(context, true, emptyList())
+    deliverLatestConfig(expectedRebind = false)
+    assertEquals(1, RebindRecorder.requests.size)
+  }
+
+  @Test
+  fun permissionGrantCountsAsStartupRecovery() {
+    NotificationListener.setNotificationConfig(context, true, emptyList())
+    assertTrue(shadowOf(context).broadcastIntents.isEmpty())
+    grantPermission(true)
+    assertTrue(NotificationListener.refreshComponentForPermission(context))
+    assertTrue(RebindRecorder.requests.isEmpty())
+    deliverLatestConfig(expectedRebind = true)
+
+    NotificationListener.setNotificationConfig(context, true, listOf("blocked.app"))
+    deliverLatestConfig(expectedRebind = false)
+    assertEquals(1, RebindRecorder.requests.size)
+  }
+
+  @Test
+  fun deniedPermissionNeverStartsNotificationProcess() {
+    NotificationListener.setNotificationConfig(context, true, emptyList())
+    assertFalse(NotificationListener.refreshComponentForPermission(context))
+    assertTrue(shadowOf(context).broadcastIntents.isEmpty())
+    assertTrue(RebindRecorder.requests.isEmpty())
+    assertEquals(
+      android.content.pm.PackageManager.COMPONENT_ENABLED_STATE_ENABLED,
+      context.packageManager.getComponentEnabledSetting(component()),
+    )
+  }
+
+  @Test
+  fun disablingAndReenablingAllowsAnotherBind() {
+    grantPermission(true)
+    NotificationListener.setNotificationConfig(context, true, emptyList())
+    deliverLatestConfig(expectedRebind = true)
+    NotificationListener.setNotificationConfig(context, false, emptyList())
+    deliverLatestConfig(expectedRebind = false)
+    NotificationListener.setNotificationConfig(context, true, emptyList())
+    deliverLatestConfig(expectedRebind = true)
+    assertEquals(2, RebindRecorder.requests.size)
+  }
+
+  @Test
+  fun confirmedRegrantCanRecoverAgainInSameProcess() {
+    grantPermission(true)
+    NotificationListener.setNotificationConfig(context, true, emptyList())
+    deliverLatestConfig(expectedRebind = true)
+    // Access can be revoked and granted in Settings without a config update.
+    NotificationListener.refreshComponentForPermission(context)
+    deliverLatestConfig(expectedRebind = true)
+    NotificationListener.setNotificationConfig(context, true, emptyList())
+    deliverLatestConfig(expectedRebind = false)
+    assertEquals(2, RebindRecorder.requests.size)
+  }
+
+  private fun grantPermission(granted: Boolean) {
+    Settings.Secure.putString(
+      context.contentResolver,
+      "enabled_notification_listeners",
+      if (granted) component().flattenToString() else "",
+    )
+  }
+
+  private fun component() = ComponentName(context, NotificationListenerServiceImpl::class.java)
+
+  private fun preferences() = context.getSharedPreferences("mentra_crust_notification_prefs", 0)
+
+  private fun deliverLatestConfig(expectedRebind: Boolean) {
+    val intent = shadowOf(context).broadcastIntents.last()
+    val config = NotificationProcessBridge.readConfig(intent)
+    assertEquals(expectedRebind, config.requestRebind)
+    // Model :notif's independent preference cache rather than relying on the
+    // value just written by the app process.
+    preferences().edit().clear().commit()
+    NotificationConfigReceiver().onReceive(context, intent)
+    assertEquals(config.listenerEnabled, preferences().getBoolean("notification_listener_enabled", false))
+  }
+}
+
+@Implements(NotificationListenerService::class)
+class RebindRecorder {
+  companion object {
+    val requests = mutableListOf<ComponentName>()
+    var failRequest = false
+
+    @JvmStatic
+    @Implementation
+    fun requestRebind(component: ComponentName) {
+      if (failRequest) throw IllegalStateException("Binder unavailable")
+      // Receiver must have applied config before binding the service.
+      val context = RuntimeEnvironment.getApplication() as Application
+      val prefs = context.getSharedPreferences("mentra_crust_notification_prefs", 0)
+      assertTrue(prefs.getBoolean("notification_listener_enabled", false))
+      requests.add(component)
+    }
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mentra/crust",
-  "version": "3.2.0-dev.168",
+  "version": "3.2.0-dev.177",
   "description": "Mentra Native Module",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -35,7 +35,7 @@
   "license": "Apache-2.0",
   "homepage": "https://github.com/Mentra-Community/MentraOS/tree/dev/mobile/modules/crust#readme",
   "dependencies": {
-    "@mentra/jspolyfill": "3.2.0-dev.168"
+    "@mentra/jspolyfill": "3.2.0-dev.177"
   },
   "devDependencies": {
     "@expo/config-plugins": ">=8.0.0",