@mentra/engine 3.2.0-dev.180 → 3.2.0-dev.187

package/src/generated/releaseMetadata.ts

@@ -12,9 +12,9 @@ export interface EngineReleaseMetadata {
 export const ENGINE_RELEASE_METADATA: Readonly<EngineReleaseMetadata> = Object.freeze({
   "schemaVersion": 1,
   "familyBaseVersion": "3.2.0",
-  "releaseIdentity": "3.2.0-dev.180",
-  "releaseSetId": "mentra-3.2.0-dev.180",
-  "sourceCommit": "1f24e462561fef37b7082204847a541db4a87c41",
-  "otaManifestUrl": "https://github.com/Mentra-Community/MentraOS/releases/download/mentra-builds-v3.2.0/mentra-live-ota-3.2.0-dev.180.json",
-  "otaManifestSha256": "cbf2a1b81430bd34942e2a1764138f6d79197767b4434a2d8c44311768f8b873"
+  "releaseIdentity": "3.2.0-dev.187",
+  "releaseSetId": "mentra-3.2.0-dev.187",
+  "sourceCommit": "d8b34892f11593baa3c075b94380253b06eb874d",
+  "otaManifestUrl": "https://github.com/Mentra-Community/MentraOS/releases/download/mentra-builds-v3.2.0/mentra-live-ota-3.2.0-dev.187.json",
+  "otaManifestSha256": "cf21f4ab6347acb12eefa38d2f0a3b433bc0e05428c527bcda57a8693d7a72f9"
 })

package/src/services/NativeNotificationPolicy.ts

@@ -0,0 +1,24 @@
+import type {NativeNotificationConfig} from "@mentra/bluetooth-sdk"
+
+export interface NotificationPolicyInput {
+  supported: boolean
+  selected: boolean
+  presentationActive: boolean
+  sourceEnabled: boolean
+  autoDisplay: boolean
+  durationSeconds: number
+  doNotDisturb: boolean
+  blockedApps: string[]
+}
+
+export function nativeNotificationConfig(input: NotificationPolicyInput): NativeNotificationConfig {
+  return {
+    enabled: input.supported && input.selected && input.presentationActive && input.sourceEnabled,
+    autoDisplay: input.autoDisplay,
+    durationSeconds: Number.isFinite(input.durationSeconds)
+      ? Math.min(30, Math.max(1, Math.round(input.durationSeconds)))
+      : 5,
+    doNotDisturb: input.doNotDisturb,
+    blockedApps: input.blockedApps,
+  }
+}

package/src/services/PhoneNotificationsSync.ts

@@ -1,46 +1,130 @@
-/**
- * Phone-notifications sync — engine-owned. Pushes the notification-forwarding
- * operational kill switch + config (`android_notification_listener_enabled`
- * and `notifications_blocklist`) to the native
- * NotificationListener via `CrustModule.setNotificationConfig`, so
- * the blocklist reaches the listener for ANY host — not just the Mentra App,
- * where this used to live in MantleManager. The Android service is desired by
- * default now that its cold start is isolated from React Native. Native code
- * keeps the component discoverable in Android's notification-access Settings,
- * but only binds the service after access is granted. The debug setting remains
- * a hidden emergency kill switch; Notify's running state gates presentation,
- * not capture. Android-only; a no-op elsewhere. Started by `engine.start()`.
- */
+/** One engine-owned notification policy: capture remains independent of presentation. */
+import {Platform} from "react-native"
 import {shallow} from "zustand/shallow"
 import CrustModule from "@mentra/crust"
+import BluetoothSdk from "@mentra/bluetooth-sdk/internal"
+import type {PhoneNotificationEvent} from "@mentra/crust"
 
 import {useSettingsStore, SETTINGS} from "../stores/settings"
+import {useGlassesStore, isGlassesReady} from "../stores/glasses"
+import {DeviceTypes} from "../types/enums"
+import {getModelCapabilities} from "../types/hardware"
+import {nativeNotificationConfig} from "./NativeNotificationPolicy"
 
-let unsubscribe: (() => void) | null = null
+let unsubscribers: Array<() => void> = []
+let presentationActive = false
 
-function pushConfig(): void {
-  const s = useSettingsStore.getState()
-  const listenerEnabled = Boolean(s.getSetting(SETTINGS.android_notification_listener_enabled.key))
-  const blocklist = s.getSetting(SETTINGS.notifications_blocklist.key)
-  CrustModule.setNotificationConfig(listenerEnabled, Array.isArray(blocklist) ? blocklist : []).catch((err: unknown) =>
-    console.warn(`PhoneNotificationsSync: setNotificationConfig failed: ${(err as Error)?.message ?? err}`),
+export function nativeNotificationCapabilities() {
+  const supported = Boolean(
+    getModelCapabilities(useGlassesStore.getState().deviceModel as DeviceTypes)?.hasNativeNotifications,
+  )
+  return {
+    supported,
+    source: Platform.OS === "ios" ? ("ancs" as const) : ("phone" as const),
+    contentAccess:
+      Platform.OS === "android" ? ("full" as const) : supported ? ("app_identity" as const) : ("unsupported" as const),
+    perAppFiltering: Platform.OS === "android",
+    removal: false, // The verified G2 protocol does not yet include a removal command.
+  }
+}
+
+function desiredConfig() {
+  const settings = useSettingsStore.getState()
+  return nativeNotificationConfig({
+    supported: nativeNotificationCapabilities().supported,
+    selected: Boolean(settings.getSetting(SETTINGS.native_notifications_enabled.key)),
+    presentationActive,
+    sourceEnabled:
+      Platform.OS !== "android" || Boolean(settings.getSetting(SETTINGS.android_notification_listener_enabled.key)),
+    autoDisplay: Boolean(settings.getSetting(SETTINGS.native_notifications_auto_display.key)),
+    durationSeconds: Number(settings.getSetting(SETTINGS.native_notifications_duration.key)),
+    doNotDisturb: Boolean(settings.getSetting(SETTINGS.native_notifications_do_not_disturb.key)),
+    blockedApps: Platform.OS === "android" ? settings.getSetting(SETTINGS.notifications_blocklist.key) : [],
+  })
+}
+
+function pushNativeConfig(): void {
+  if (!nativeNotificationCapabilities().supported) return
+  void BluetoothSdk.configureNativeNotifications(desiredConfig()).catch((error: unknown) => {
+    if (isGlassesReady(useGlassesStore.getState().connection)) {
+      console.warn("PhoneNotificationsSync: native notification configuration failed", error)
+    }
+  })
+}
+
+/** Hosts activate their presentation owner (Notify in the Mentra App) through this seam. */
+export function setPhoneNotificationPresentationActive(active: boolean): void {
+  if (active === presentationActive) return
+  presentationActive = active
+  pushNativeConfig()
+}
+
+export function usesNativeNotificationPresentation(): boolean {
+  return (
+    nativeNotificationCapabilities().supported &&
+    presentationActive &&
+    Boolean(useSettingsStore.getState().getSetting(SETTINGS.native_notifications_enabled.key))
   )
 }
 
+/** Return true when the selected firmware presentation owns this event, including quiet/history mode. */
+export async function presentNativePhoneNotification(event: PhoneNotificationEvent): Promise<boolean> {
+  if (!usesNativeNotificationPresentation()) return false
+  if (!desiredConfig().enabled) return true
+  if (Platform.OS !== "android") return true // G2 receives ANCS directly; never upload metadata back.
+  const blocked = useSettingsStore.getState().getSetting(SETTINGS.notifications_blocklist.key)
+  if (Array.isArray(blocked) && blocked.includes(event.packageName)) return true
+  if (!isGlassesReady(useGlassesStore.getState().connection)) return true
+  await BluetoothSdk.sendPhoneNotification({
+    notificationId: String(event.notificationId ?? ""),
+    packageName: String(event.packageName ?? ""),
+    appName: String(event.app ?? ""),
+    title: String(event.title ?? ""),
+    subtitle: "",
+    body: String(event.content ?? ""),
+    timestampMs: Number(event.timestamp ?? Date.now()),
+    action: 0,
+  })
+  return true
+}
+
+function pushConfig(): void {
+  const settings = useSettingsStore.getState()
+  if (Platform.OS === "android") {
+    const enabled = Boolean(settings.getSetting(SETTINGS.android_notification_listener_enabled.key))
+    const blocklist = settings.getSetting(SETTINGS.notifications_blocklist.key)
+    void CrustModule.setNotificationConfig(enabled, Array.isArray(blocklist) ? blocklist : []).catch((error: unknown) =>
+      console.warn("PhoneNotificationsSync: listener configuration failed", error),
+    )
+  }
+  pushNativeConfig()
+}
+
 export function startPhoneNotificationsSync(): void {
-  if (unsubscribe) return
-  pushConfig() // initial sync so the listener has the current config
-  unsubscribe = useSettingsStore.subscribe(
-    (state) => ({
-      listenerEnabled: state.getSetting(SETTINGS.android_notification_listener_enabled.key),
-      blocklist: state.getSetting(SETTINGS.notifications_blocklist.key),
+  if (unsubscribers.length) return
+  pushConfig()
+  unsubscribers = [
+    useSettingsStore.subscribe(
+      (state) =>
+        [
+          SETTINGS.android_notification_listener_enabled,
+          SETTINGS.notifications_blocklist,
+          SETTINGS.native_notifications_enabled,
+          SETTINGS.native_notifications_auto_display,
+          SETTINGS.native_notifications_duration,
+          SETTINGS.native_notifications_do_not_disturb,
+        ].map((setting) => state.getSetting(setting.key)),
+      pushConfig,
+      {equalityFn: shallow},
+    ),
+    useGlassesStore.subscribe((state) => ({model: state.deviceModel, connection: state.connection}), pushNativeConfig, {
+      equalityFn: shallow,
     }),
-    () => pushConfig(),
-    {equalityFn: shallow},
-  )
+  ]
 }
 
 export function stopPhoneNotificationsSync(): void {
-  unsubscribe?.()
-  unsubscribe = null
+  setPhoneNotificationPresentationActive(false)
+  unsubscribers.forEach((unsubscribe) => unsubscribe())
+  unsubscribers = []
 }

package/src/stores/settings.ts

@@ -166,6 +166,36 @@ export const SETTINGS: Record<string, Setting> = {
     saveOnServer: false,
     persist: true,
   },
+  // Select firmware-owned presentation instead of the Mentra card. Notify still
+  // controls whether presentation is running on either phone platform.
+  native_notifications_enabled: {
+    key: "native_notifications_enabled",
+    defaultValue: () => false,
+    writable: true,
+    saveOnServer: false,
+    persist: true,
+  },
+  native_notifications_auto_display: {
+    key: "native_notifications_auto_display",
+    defaultValue: () => true,
+    writable: true,
+    saveOnServer: false,
+    persist: true,
+  },
+  native_notifications_duration: {
+    key: "native_notifications_duration",
+    defaultValue: () => 5,
+    writable: true,
+    saveOnServer: false,
+    persist: true,
+  },
+  native_notifications_do_not_disturb: {
+    key: "native_notifications_do_not_disturb",
+    defaultValue: () => false,
+    writable: true,
+    saveOnServer: false,
+    persist: true,
+  },
   china_deployment: {
     key: "china_deployment",
     defaultValue: () => (process.env.EXPO_PUBLIC_DEPLOYMENT_REGION === "china" ? true : false),
@@ -793,13 +823,10 @@ export interface SettingsState {
 }
 
 const getDefaultSettings = () =>
-  Object.keys(SETTINGS).reduce(
-    (acc, key) => {
-      acc[key] = SETTINGS[key].defaultValue()
-      return acc
-    },
-    {} as Record<string, any>,
-  )
+  Object.keys(SETTINGS).reduce((acc, key) => {
+    acc[key] = SETTINGS[key].defaultValue()
+    return acc
+  }, {} as Record<string, any>)
 
 // Single-flight for loadAllSettings: the host fires it at module load and
 // engine.start()'s device-store hydration awaits it — without the memo the

package/src/types/capabilities/even-realities-g2.ts

@@ -88,4 +88,5 @@ export const evenRealitiesG2: Capabilities = {
   // Dashboard - G2 renders Even Realities' native dashboard in firmware, so
   // MentraOS does not manage the dashboard or expose dashboard settings for it
   hasNativeDashboard: true,
+  hasNativeNotifications: true,
 };

package/src/types/hardware.ts

@@ -122,6 +122,8 @@ export interface PowerCapabilities {
  * Complete information about what hardware a device has
  */
 export interface Capabilities {
+  /** Firmware-owned notification history and popups; content relay is separate. */
+  hasNativeNotifications?: boolean;
   modelName: string;
 
   // Camera capabilities