@glassly/bluetooth-sdk 0.1.0-dev.99 → 0.2.8-dev.445

package/android/src/main/java/com/glassly/bluetoothsdk/GlassesNotifications.kt

@@ -0,0 +1,155 @@
+package com.glassly.bluetoothsdk
+
+/** One app the wearer allows, for firmware whose filter is an allowlist. */
+data class AllowedApp(val id: String, val name: String) {
+    fun toMap(): Map<String, Any> = mapOf("id" to id, "name" to name)
+
+    companion object {
+        fun fromMap(map: Map<String, Any?>): AllowedApp? {
+            val id = map["id"] as? String ?: return null
+            if (id.isEmpty()) return null
+            return AllowedApp(id, map["name"] as? String ?: id)
+        }
+    }
+}
+
+/**
+ * Desired on-glass notification behaviour in driver-neutral terms. Drivers map
+ * it onto their protocol and snap values their firmware cannot take.
+ */
+data class GlassesNotificationConfig(
+    val enabled: Boolean,
+    val popups: Boolean,
+    /** 0 lets the firmware choose. */
+    val popupSeconds: Int,
+    val holdDuringApps: Boolean,
+    /** Android package names or iOS bundle ids the wearer blocked. */
+    val blockedApps: List<String>,
+    val allowedApps: List<AllowedApp>
+) {
+    init {
+        require(popupSeconds in 0..60) { "popupSeconds must be 0..60, got $popupSeconds" }
+    }
+
+    fun toMap(): Map<String, Any> =
+        mapOf(
+            "enabled" to enabled,
+            "popups" to popups,
+            "popupSeconds" to popupSeconds,
+            "holdDuringApps" to holdDuringApps,
+            "blockedApps" to blockedApps,
+            "allowedApps" to allowedApps.map { it.toMap() }
+        )
+
+    companion object {
+        fun fromMap(map: Map<String, Any?>): GlassesNotificationConfig {
+            // JS numbers arrive as Double across the bridge.
+            val seconds = (map["popupSeconds"] as? Number)?.toInt() ?: 0
+            val blocked =
+                (map["blockedApps"] as? List<*>)?.mapNotNull { it as? String }?.filter { it.isNotEmpty() }
+                    ?: emptyList()
+            val allowed =
+                (map["allowedApps"] as? List<*>)?.mapNotNull { entry ->
+                    @Suppress("UNCHECKED_CAST")
+                    (entry as? Map<String, Any?>)?.let { AllowedApp.fromMap(it) }
+                }
+                    ?: emptyList()
+            return GlassesNotificationConfig(
+                enabled = map["enabled"] as? Boolean ?: false,
+                popups = map["popups"] as? Boolean ?: true,
+                popupSeconds = seconds.coerceIn(0, 60),
+                holdDuringApps = map["holdDuringApps"] as? Boolean ?: true,
+                blockedApps = blocked,
+                allowedApps = allowed
+            )
+        }
+    }
+}
+
+/** How the connected glasses obtain the phone's notifications. */
+object GlassesNotificationFeeds {
+    const val PHONE_UPLOAD = "phone_upload"
+    const val ANCS = "ancs"
+    const val NONE = "none"
+}
+
+object GlassesNotificationAccess {
+    const val GRANTED = "granted"
+    const val DENIED = "denied"
+    const val UNKNOWN = "unknown"
+    const val NOT_NEEDED = "not_needed"
+}
+
+object GlassesNotificationPhases {
+    const val IDLE = "idle"
+    const val APPLYING = "applying"
+    const val APPLIED = "applied"
+    const val STALE = "stale"
+    const val ERROR = "error"
+}
+
+data class GlassesNotificationStatus(
+    val supported: Boolean,
+    val feed: String,
+    val access: String,
+    /** `applied` means written to the link, not acknowledged. */
+    val phase: String,
+    val config: GlassesNotificationConfig?,
+    val error: String?
+) {
+    fun toMap(): Map<String, Any?> =
+        mapOf(
+            "supported" to supported,
+            "feed" to feed,
+            "access" to access,
+            "phase" to phase,
+            "config" to config?.toMap(),
+            "error" to error
+        )
+
+    companion object {
+        fun unsupported(): GlassesNotificationStatus =
+            GlassesNotificationStatus(
+                supported = false,
+                feed = GlassesNotificationFeeds.NONE,
+                access = GlassesNotificationAccess.NOT_NEEDED,
+                phase = GlassesNotificationPhases.IDLE,
+                config = null,
+                error = null
+            )
+    }
+}
+
+/** One phone notification handed to glasses that present content themselves. */
+data class PhoneNotificationUpload(
+    val notificationId: String,
+    val packageName: String,
+    val appName: String,
+    val title: String,
+    val subtitle: String,
+    val body: String,
+    val timestampMs: Long
+) {
+    companion object {
+        fun fromMap(map: Map<String, Any?>): PhoneNotificationUpload {
+            val packageName = map["packageName"] as? String ?: ""
+            return PhoneNotificationUpload(
+                notificationId = map["notificationId"] as? String ?: "",
+                packageName = packageName,
+                appName = (map["appName"] as? String)?.takeIf { it.isNotEmpty() } ?: packageName,
+                title = map["title"] as? String ?: "",
+                subtitle = map["subtitle"] as? String ?: "",
+                body = map["body"] as? String ?: "",
+                timestampMs = (map["timestampMs"] as? Number)?.toLong() ?: 0L
+            )
+        }
+    }
+}
+
+/** Upload outcomes reported back by id only; content never crosses back. */
+object NotificationUploadOutcomes {
+    const val SENT = "sent"
+    const val FAILED = "failed"
+    const val CANCELLED = "cancelled"
+    const val DROPPED = "dropped"
+}