@mentra/crust 0.1.0-dev.0 → 3.1.0-dev.1

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

@@ -14,12 +14,13 @@ import android.text.TextUtils
 import android.util.Base64
 import android.util.Log
 import com.mentra.crust.CrustModule
+import java.util.concurrent.ConcurrentHashMap
 
 class NotificationListener private constructor(private val context: Context) {
   companion object {
     private const val TAG = "CrustNotificationListener"
     private const val PREFS_NAME = "mentra_crust_notification_prefs"
-    private const val PREF_NOTIFICATIONS_ENABLED = "notifications_enabled"
+    private const val PREF_LISTENER_ENABLED = "notification_listener_enabled"
     private const val PREF_NOTIFICATIONS_BLOCKLIST = "notifications_blocklist"
 
     @Volatile private var instance: NotificationListener? = null
@@ -33,9 +34,207 @@ class NotificationListener private constructor(private val context: Context) {
             }
         }
     }
+
+    /**
+     * Persist desired notification state without constructing the listener.
+     * The component stays enabled so Android can show it in notification-access
+     * Settings, but its service process only starts after access is granted.
+     */
+    fun setNotificationConfig(
+      context: Context,
+      listenerEnabled: Boolean,
+      blocklist: List<String>,
+    ) {
+      val applicationContext = context.applicationContext
+      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
+      }
+    }
+
+    /**
+     * Reconcile the component after an OS notification-access check.
+     *
+     * The permission flow calls this when the app returns from Settings, so a
+     * newly granted listener starts immediately. Without permission the service
+     * is not rebound and the isolated process is never started.
+     */
+    fun refreshComponentForPermission(context: Context): Boolean {
+      val applicationContext = context.applicationContext
+      val permissionGranted = hasNotificationListenerPermission(applicationContext)
+      val preferences = applicationContext.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+      val listenerEnabled = preferences.getBoolean(PREF_LISTENER_ENABLED, false)
+      val blocklist =
+        preferences.getStringSet(PREF_NOTIFICATIONS_BLOCKLIST, emptySet())?.toSet() ?: emptySet()
+
+      val shouldRun = listenerEnabled && permissionGranted
+      updateComponentState(applicationContext, enabled = listenerEnabled)
+      if (permissionGranted) {
+        NotificationProcessBridge.sendConfig(
+          applicationContext,
+          listenerEnabled,
+          blocklist,
+          // This method is reserved for the confirmed permission-grant path.
+          // The :notif receiver persists the config before requesting rebind.
+          requestRebind = shouldRun,
+        )
+      }
+      return permissionGranted
+    }
+
+    fun openNotificationListenerSettings(context: Context) {
+      val intent = Intent(Settings.ACTION_NOTIFICATION_LISTENER_SETTINGS)
+      intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+      context.applicationContext.startActivity(intent)
+    }
+
+    fun hasNotificationListenerPermission(context: Context): Boolean {
+      val packageName = context.packageName
+      val flat = Settings.Secure.getString(context.contentResolver, "enabled_notification_listeners")
+      if (TextUtils.isEmpty(flat)) return false
+
+      return flat.split(":").any { name ->
+        ComponentName.unflattenFromString(name)?.packageName == packageName
+      }
+    }
+
+    private fun updateComponentState(
+      context: Context,
+      enabled: Boolean,
+    ): Boolean {
+      val component = ComponentName(context, NotificationListenerServiceImpl::class.java)
+      val newState =
+        if (enabled) {
+          PackageManager.COMPONENT_ENABLED_STATE_ENABLED
+        } else {
+          PackageManager.COMPONENT_ENABLED_STATE_DISABLED
+        }
+      val packageManager = context.packageManager
+      if (packageManager.getComponentEnabledSetting(component) != newState) {
+        packageManager.setComponentEnabledSetting(
+          component,
+          newState,
+          PackageManager.DONT_KILL_APP,
+        )
+        return true
+      }
+      return false
+    }
+
+    internal fun persistConfig(
+      context: Context,
+      listenerEnabled: Boolean,
+      blocklist: Set<String>,
+    ) {
+      val committed =
+        context
+          .getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+          .edit()
+          .putBoolean(PREF_LISTENER_ENABLED, listenerEnabled)
+          .putStringSet(PREF_NOTIFICATIONS_BLOCKLIST, blocklist)
+          .commit()
+      if (!committed) {
+        Log.w(TAG, "Could not persist notification-listener config")
+      }
+    }
+
+    internal fun requestListenerRebind(context: Context) {
+      val component = ComponentName(context, NotificationListenerServiceImpl::class.java)
+      runCatching { NotificationListenerService.requestRebind(component) }
+        .onFailure { Log.w(TAG, "Could not request notification-listener rebind", it) }
+    }
+
+    internal fun applyConfigToExisting(
+      listenerEnabled: Boolean,
+      blocklist: Set<String>,
+    ) {
+      synchronized(this) {
+        instance?.applyConfig(listenerEnabled, blocklist)
+      }
+    }
+
+    fun isListenerEnabled(context: Context): Boolean {
+      val preferences = context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+      return preferences.getBoolean(PREF_LISTENER_ENABLED, false) &&
+        hasNotificationListenerPermission(context)
+    }
+
+    /**
+     * Read installed-app metadata without constructing the service singleton.
+     *
+     * These APIs run in the React Native process. The notification singleton
+     * belongs exclusively to :notif; constructing it here would create an
+     * orphaned HandlerThread that no service lifecycle ever destroys.
+     */
+    fun getInstalledApps(context: Context): List<Map<String, Any?>> {
+      val applicationContext = context.applicationContext
+      val packageManager = applicationContext.packageManager
+      val packages = packageManager.getInstalledApplications(PackageManager.GET_META_DATA)
+      val blocklist =
+        applicationContext
+          .getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+          .getStringSet(PREF_NOTIFICATIONS_BLOCKLIST, emptySet())
+          ?.toSet() ?: emptySet()
+
+      return packages
+        .filter { it.flags and ApplicationInfo.FLAG_SYSTEM == 0 }
+        .map { appInfo ->
+          val icon =
+            try {
+              val drawable = packageManager.getApplicationIcon(appInfo.packageName)
+              val bitmap = (drawable as? android.graphics.drawable.BitmapDrawable)?.bitmap
+              if (bitmap != null) {
+                val outputStream = java.io.ByteArrayOutputStream()
+                bitmap.compress(android.graphics.Bitmap.CompressFormat.PNG, 100, outputStream)
+                val byteArray = outputStream.toByteArray()
+                "data:image/png;base64," + Base64.encodeToString(byteArray, Base64.NO_WRAP)
+              } else {
+                null
+              }
+            } catch (_: Exception) {
+              null
+            }
+
+          mapOf(
+            "packageName" to appInfo.packageName,
+            "appName" to packageManager.getApplicationLabel(appInfo).toString(),
+            "isBlocked" to blocklist.contains(appInfo.packageName),
+            "icon" to icon,
+          )
+        }
+        .sortedBy { it["appName"] as String }
+    }
+
+    /** Dispose the process singleton so a service rebind gets a live HandlerThread. */
+    fun destroyInstance() {
+      synchronized(this) {
+        instance?.cleanup()
+        instance = null
+      }
+    }
   }
 
   private val listeners = mutableListOf<OnNotificationReceivedListener>()
+  private val appNameCache = ConcurrentHashMap<String, String>()
 
   // Deduplication tracking with dedicated background thread. Using HandlerThread
   // keeps the service independent from the app lifecycle on newer Android versions.
@@ -46,45 +245,17 @@ class NotificationListener private constructor(private val context: Context) {
 
   private val preferences = context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
 
-  @Volatile private var notificationsEnabled = preferences.getBoolean(PREF_NOTIFICATIONS_ENABLED, false)
+  @Volatile private var listenerEnabled = preferences.getBoolean(PREF_LISTENER_ENABLED, false)
   @Volatile
   private var notificationsBlocklist =
     preferences.getStringSet(PREF_NOTIFICATIONS_BLOCKLIST, emptySet())?.toSet() ?: emptySet()
 
-  /** Keep MentraOS notification settings in Crust instead of Bluetooth SDK state. */
-  fun setNotificationConfig(enabled: Boolean, blocklist: List<String>) {
-    val blocklistSet = blocklist.toSet()
-    notificationsEnabled = enabled
-    notificationsBlocklist = blocklistSet
-    preferences
-      .edit()
-      .putBoolean(PREF_NOTIFICATIONS_ENABLED, enabled)
-      .putStringSet(PREF_NOTIFICATIONS_BLOCKLIST, blocklistSet)
-      .apply()
-  }
-
-  /** Check if notification listener permission is granted. */
-  fun hasNotificationListenerPermission(): Boolean {
-    val packageName = context.packageName
-    val flat = Settings.Secure.getString(context.contentResolver, "enabled_notification_listeners")
-
-    if (!TextUtils.isEmpty(flat)) {
-      val names = flat.split(":")
-      for (name in names) {
-        val componentName = ComponentName.unflattenFromString(name)
-        if (componentName != null && TextUtils.equals(packageName, componentName.packageName)) {
-          return true
-        }
-      }
-    }
-    return false
-  }
-
-  /** Open notification listener settings. */
-  fun openNotificationListenerSettings() {
-    val intent = Intent(Settings.ACTION_NOTIFICATION_LISTENER_SETTINGS)
-    intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
-    context.startActivity(intent)
+  private fun applyConfig(
+    listenerEnabled: Boolean,
+    blocklist: Set<String>,
+  ) {
+    this.listenerEnabled = listenerEnabled
+    notificationsBlocklist = blocklist
   }
 
   /** Add a listener for notifications. */
@@ -120,7 +291,17 @@ class NotificationListener private constructor(private val context: Context) {
   }
 
   /** Called internally by the service when a notification is posted. */
-  internal fun onNotificationPosted(sbn: StatusBarNotification) {
+  /**
+   * @param importance NotificationManager.IMPORTANCE_* from the ranking, or null
+   *   when unavailable. Preferred over the deprecated Notification.priority,
+   *   which reads 0 for channel-based notifications.
+   */
+  internal fun onNotificationPosted(sbn: StatusBarNotification, importance: Int? = null) {
+    if (!listenerEnabled) {
+      Log.d(TAG, "Notification listener disabled")
+      return
+    }
+
     val packageName = sbn.packageName
     Log.d(TAG, "Received notification from $packageName (key: ${sbn.key})")
 
@@ -134,11 +315,6 @@ class NotificationListener private constructor(private val context: Context) {
       return
     }
 
-    if (!notificationsEnabled) {
-      Log.d(TAG, "Notifications disabled globally")
-      return
-    }
-
     val notification = sbn.notification
     val extras = notification.extras
     val title = extras.getCharSequence("android.title")?.toString() ?: ""
@@ -154,15 +330,6 @@ class NotificationListener private constructor(private val context: Context) {
       return
     }
 
-    val packageManager = context.packageManager
-    val appName =
-      try {
-        val appInfo = packageManager.getApplicationInfo(packageName, 0)
-        packageManager.getApplicationLabel(appInfo).toString()
-      } catch (_: Exception) {
-        packageName
-      }
-
     val notificationKey = "$packageName|$title|$text"
 
     synchronized(notificationBuffer) {
@@ -174,14 +341,39 @@ class NotificationListener private constructor(private val context: Context) {
       val task =
         Runnable {
           try {
+            // Config can change during the debounce window. Recheck here so a
+            // kill-switch or blocklist update cannot leak an already-buffered
+            // notification after it takes effect.
+            if (!listenerEnabled || notificationsBlocklist.contains(packageName)) {
+              return@Runnable
+            }
+
+            // PackageManager label resolution can take tens of milliseconds on
+            // low-end devices. It belongs on this handler thread, not the
+            // NotificationListenerService main callback, and only once per app.
+            val appName =
+              appNameCache.getOrPut(packageName) {
+                try {
+                  val packageManager = context.packageManager
+                  val appInfo = packageManager.getApplicationInfo(packageName, 0)
+                  packageManager.getApplicationLabel(appInfo).toString()
+                } catch (_: Exception) {
+                  packageName
+                }
+              }
             Log.d(TAG, "Processing buffered notification from $appName")
             CrustModule.emitPhoneNotification(
+              context = context,
               notificationKey = sbn.key,
               packageName = packageName,
               appName = appName,
               title = title,
               text = text,
               timestamp = sbn.postTime,
+              // Map channel importance onto the priority scale consumers
+              // already understand (LOW/MIN are negative). Fall back to the
+              // deprecated field only when no ranking was available.
+              priority = importance?.let { it - 3 } ?: notification.priority,
             )
 
             val notificationData =
@@ -213,12 +405,17 @@ class NotificationListener private constructor(private val context: Context) {
 
   /** Called internally by the service when a notification is removed. */
   internal fun onNotificationRemoved(sbn: StatusBarNotification) {
+    if (!listenerEnabled) {
+      return
+    }
+
     val packageName = sbn.packageName
     val notificationKey = sbn.key
 
     Log.d(TAG, "Notification removed - package: $packageName, key: $notificationKey")
 
     CrustModule.emitPhoneNotificationDismissed(
+      context = context,
       notificationKey = notificationKey,
       packageName = packageName,
     )
@@ -242,41 +439,6 @@ class NotificationListener private constructor(private val context: Context) {
     val tag: String?,
   )
 
-  /** Get all installed apps with details. */
-  fun getInstalledApps(): List<Map<String, Any?>> {
-    val packageManager = context.packageManager
-    val packages = packageManager.getInstalledApplications(PackageManager.GET_META_DATA)
-    val blocklist = notificationsBlocklist
-
-    return packages
-      .filter { it.flags and ApplicationInfo.FLAG_SYSTEM == 0 }
-      .map { appInfo ->
-        val icon =
-          try {
-            val drawable = packageManager.getApplicationIcon(appInfo.packageName)
-            val bitmap = (drawable as? android.graphics.drawable.BitmapDrawable)?.bitmap
-            if (bitmap != null) {
-              val outputStream = java.io.ByteArrayOutputStream()
-              bitmap.compress(android.graphics.Bitmap.CompressFormat.PNG, 100, outputStream)
-              val byteArray = outputStream.toByteArray()
-              "data:image/png;base64," + Base64.encodeToString(byteArray, Base64.NO_WRAP)
-            } else {
-              null
-            }
-          } catch (_: Exception) {
-            null
-          }
-
-        mapOf(
-          "packageName" to appInfo.packageName,
-          "appName" to packageManager.getApplicationLabel(appInfo).toString(),
-          "isBlocked" to blocklist.contains(appInfo.packageName),
-          "icon" to icon,
-        )
-      }
-      .sortedBy { it["appName"] as String }
-  }
-
   /** Clean up resources when the service is destroyed. */
   fun cleanup() {
     Log.d(TAG, "Cleaning up notification handler thread")
@@ -292,7 +454,22 @@ class NotificationListener private constructor(private val context: Context) {
 class NotificationListenerServiceImpl : NotificationListenerService() {
   override fun onNotificationPosted(sbn: StatusBarNotification) {
     super.onNotificationPosted(sbn)
-    NotificationListener.getInstance(applicationContext).onNotificationPosted(sbn)
+    // Channel importance, not Notification.priority: the latter was deprecated
+    // at API 26 and reads 0 for apps that express intent through a channel
+    // instead, which would make every consumer treat them as ordinary. Only the
+    // service can see the ranking, so it is resolved here and passed down.
+    NotificationListener.getInstance(applicationContext).onNotificationPosted(sbn, importanceOf(sbn))
+  }
+
+  /** IMPORTANCE_* for this notification, or null when the ranking is unavailable. */
+  private fun importanceOf(sbn: StatusBarNotification): Int? {
+    return try {
+      val ranking = NotificationListenerService.Ranking()
+      if (currentRanking?.getRanking(sbn.key, ranking) == true) ranking.importance else null
+    } catch (e: Exception) {
+      Log.w("CrustNotificationListener", "could not read ranking importance", e)
+      null
+    }
   }
 
   override fun onNotificationRemoved(sbn: StatusBarNotification) {
@@ -307,13 +484,19 @@ class NotificationListenerServiceImpl : NotificationListenerService() {
 
   override fun onListenerDisconnected() {
     super.onListenerDisconnected()
-    Log.d("CrustNotificationListener", "NotificationListenerService disconnected, requesting rebind")
-    requestRebind(ComponentName(this, NotificationListenerServiceImpl::class.java))
+    Log.d("CrustNotificationListener", "NotificationListenerService disconnected")
+    if (NotificationListener.isListenerEnabled(applicationContext)) {
+      runCatching {
+        requestRebind(ComponentName(this, NotificationListenerServiceImpl::class.java))
+      }.onFailure {
+        Log.w("CrustNotificationListener", "Could not request notification-listener rebind", it)
+      }
+    }
   }
 
   override fun onDestroy() {
     super.onDestroy()
     Log.d("CrustNotificationListener", "NotificationListenerService being destroyed")
-    NotificationListener.getInstance(applicationContext).cleanup()
+    NotificationListener.destroyInstance()
   }
 }

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

@@ -0,0 +1,222 @@
+package com.mentra.crust.services
+
+import android.app.ActivityManager
+import android.app.Application
+import android.content.BroadcastReceiver
+import android.content.ComponentName
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.os.Build
+import android.os.Process
+import android.util.Log
+import java.io.File
+
+/**
+ * Identifies the lightweight process used by NotificationListenerService.
+ *
+ * The host app's generated MainApplication calls this before initializing
+ * React Native. Keep this object free of Expo/React dependencies so loading it
+ * cannot recreate the cold-start work that the process split avoids.
+ */
+object NotificationProcess {
+  const val SUFFIX = ":notif"
+
+  @JvmStatic
+  fun isCurrent(context: Context): Boolean = currentName(context).endsWith(SUFFIX)
+
+  private fun currentName(context: Context): String {
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+      return Application.getProcessName()
+    }
+
+    val activityManager = context.getSystemService(Context.ACTIVITY_SERVICE) as? ActivityManager
+    activityManager
+      ?.runningAppProcesses
+      ?.firstOrNull { it.pid == Process.myPid() }
+      ?.processName
+      ?.let { return it }
+
+    return runCatching {
+      File("/proc/self/cmdline").inputStream().bufferedReader().use { it.readText().trimEnd('\u0000') }
+    }.getOrDefault(context.packageName)
+  }
+}
+
+/**
+ * Signature-protected, process-safe handoff from the notification process to
+ * the React Native process. The receiver is dynamic, so sending while the app
+ * runtime is dead does not start the expensive main process.
+ */
+object NotificationProcessBridge {
+  private const val TAG = "CrustNotificationBridge"
+  private const val POSTED_SUFFIX = ".crust.PHONE_NOTIFICATION"
+  private const val DISMISSED_SUFFIX = ".crust.PHONE_NOTIFICATION_DISMISSED"
+  private const val CONFIG_SUFFIX = ".crust.NOTIFICATION_CONFIG"
+  private const val PERMISSION_SUFFIX = ".permission.CRUST_NOTIFICATION_BRIDGE"
+
+  private const val EXTRA_NOTIFICATION_ID = "notificationId"
+  private const val EXTRA_NOTIFICATION_KEY = "notificationKey"
+  private const val EXTRA_PACKAGE_NAME = "packageName"
+  private const val EXTRA_APP = "app"
+  private const val EXTRA_TITLE = "title"
+  private const val EXTRA_CONTENT = "content"
+  private const val EXTRA_PRIORITY = "priority"
+  private const val EXTRA_TIMESTAMP = "timestamp"
+  private const val EXTRA_LISTENER_ENABLED = "listenerEnabled"
+  private const val EXTRA_BLOCKLIST = "blocklist"
+  private const val EXTRA_REQUEST_REBIND = "requestRebind"
+
+  fun register(
+    context: Context,
+    onEvent: (String, Map<String, Any>) -> Unit,
+  ): BroadcastReceiver {
+    val applicationContext = context.applicationContext
+    val receiver =
+      object : BroadcastReceiver() {
+        override fun onReceive(receiveContext: Context, intent: Intent) {
+          when (intent.action) {
+            postedAction(receiveContext) -> {
+              onEvent(
+                "phone_notification",
+                mapOf(
+                  EXTRA_NOTIFICATION_ID to intent.getStringExtra(EXTRA_NOTIFICATION_ID).orEmpty(),
+                  EXTRA_APP to intent.getStringExtra(EXTRA_APP).orEmpty(),
+                  EXTRA_TITLE to intent.getStringExtra(EXTRA_TITLE).orEmpty(),
+                  EXTRA_CONTENT to intent.getStringExtra(EXTRA_CONTENT).orEmpty(),
+                  EXTRA_PRIORITY to intent.getIntExtra(EXTRA_PRIORITY, 0),
+                  EXTRA_TIMESTAMP to intent.getLongExtra(EXTRA_TIMESTAMP, 0L),
+                  EXTRA_PACKAGE_NAME to intent.getStringExtra(EXTRA_PACKAGE_NAME).orEmpty(),
+                ),
+              )
+            }
+            dismissedAction(receiveContext) -> {
+              onEvent(
+                "phone_notification_dismissed",
+                mapOf(
+                  EXTRA_NOTIFICATION_ID to intent.getStringExtra(EXTRA_NOTIFICATION_ID).orEmpty(),
+                  EXTRA_NOTIFICATION_KEY to intent.getStringExtra(EXTRA_NOTIFICATION_KEY).orEmpty(),
+                  EXTRA_PACKAGE_NAME to intent.getStringExtra(EXTRA_PACKAGE_NAME).orEmpty(),
+                ),
+              )
+            }
+          }
+        }
+      }
+
+    val filter =
+      IntentFilter().apply {
+        addAction(postedAction(applicationContext))
+        addAction(dismissedAction(applicationContext))
+      }
+    val permission = bridgePermission(applicationContext)
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+      applicationContext.registerReceiver(
+        receiver,
+        filter,
+        permission,
+        null,
+        Context.RECEIVER_NOT_EXPORTED,
+      )
+    } else {
+      @Suppress("UnspecifiedRegisterReceiverFlag")
+      applicationContext.registerReceiver(receiver, filter, permission, null)
+    }
+    return receiver
+  }
+
+  fun unregister(context: Context, receiver: BroadcastReceiver) {
+    runCatching { context.applicationContext.unregisterReceiver(receiver) }
+      .onFailure { Log.w(TAG, "Could not unregister notification bridge", it) }
+  }
+
+  fun emitPosted(
+    context: Context,
+    notificationKey: String,
+    packageName: String,
+    appName: String,
+    title: String,
+    text: String,
+    timestamp: Long,
+    priority: Int,
+  ) {
+    val intent =
+      Intent(postedAction(context))
+        .setPackage(context.packageName)
+        .putExtra(EXTRA_NOTIFICATION_ID, "$packageName-$notificationKey")
+        .putExtra(EXTRA_APP, appName)
+        .putExtra(EXTRA_TITLE, title.ifEmpty { appName })
+        .putExtra(EXTRA_CONTENT, text)
+        .putExtra(EXTRA_PRIORITY, priority)
+        .putExtra(EXTRA_TIMESTAMP, timestamp)
+        .putExtra(EXTRA_PACKAGE_NAME, packageName)
+    context.sendBroadcast(intent, bridgePermission(context))
+  }
+
+  fun emitDismissed(context: Context, notificationKey: String, packageName: String) {
+    val intent =
+      Intent(dismissedAction(context))
+        .setPackage(context.packageName)
+        .putExtra(EXTRA_NOTIFICATION_ID, "$packageName-$notificationKey")
+        .putExtra(EXTRA_NOTIFICATION_KEY, notificationKey)
+        .putExtra(EXTRA_PACKAGE_NAME, packageName)
+    context.sendBroadcast(intent, bridgePermission(context))
+  }
+
+  fun sendConfig(
+    context: Context,
+    listenerEnabled: Boolean,
+    blocklist: Set<String>,
+    requestRebind: Boolean,
+  ) {
+    val intent =
+      Intent(configAction(context))
+        .setComponent(ComponentName(context, NotificationConfigReceiver::class.java))
+        .putExtra(EXTRA_LISTENER_ENABLED, listenerEnabled)
+        .putStringArrayListExtra(EXTRA_BLOCKLIST, ArrayList(blocklist))
+        .putExtra(EXTRA_REQUEST_REBIND, requestRebind)
+    context.sendBroadcast(intent, bridgePermission(context))
+  }
+
+  internal fun readConfig(intent: Intent): NotificationConfigUpdate {
+    return NotificationConfigUpdate(
+      listenerEnabled = intent.getBooleanExtra(EXTRA_LISTENER_ENABLED, false),
+      blocklist = intent.getStringArrayListExtra(EXTRA_BLOCKLIST)?.toSet() ?: emptySet(),
+      requestRebind = intent.getBooleanExtra(EXTRA_REQUEST_REBIND, false),
+    )
+  }
+
+  internal fun isConfigAction(context: Context, intent: Intent): Boolean = intent.action == configAction(context)
+
+  private fun postedAction(context: Context) = context.packageName + POSTED_SUFFIX
+
+  private fun dismissedAction(context: Context) = context.packageName + DISMISSED_SUFFIX
+
+  private fun configAction(context: Context) = context.packageName + CONFIG_SUFFIX
+
+  private fun bridgePermission(context: Context) = context.packageName + PERMISSION_SUFFIX
+}
+
+internal data class NotificationConfigUpdate(
+  val listenerEnabled: Boolean,
+  val blocklist: Set<String>,
+  val requestRebind: Boolean,
+)
+
+/** Persists and applies config inside the isolated notification process. */
+class NotificationConfigReceiver : BroadcastReceiver() {
+  override fun onReceive(context: Context, intent: Intent) {
+    if (!NotificationProcessBridge.isConfigAction(context, intent)) return
+    val config = NotificationProcessBridge.readConfig(intent)
+
+    // SharedPreferences caches are per-process. Persist the payload here before
+    // touching the live instance so a listener recreated by requestRebind reads
+    // the same config rather than this process's stale cache.
+    NotificationListener.persistConfig(context, config.listenerEnabled, config.blocklist)
+    NotificationListener.applyConfigToExisting(config.listenerEnabled, config.blocklist)
+
+    if (config.listenerEnabled && config.requestRebind) {
+      NotificationListener.requestListenerRebind(context)
+    }
+  }
+}