@idealyst/live-activity 1.2.114

package/android/build.gradle

@@ -0,0 +1,39 @@
+buildscript {
+  ext.safeExtGet = { prop, fallback ->
+    rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+  }
+}
+
+apply plugin: 'com.android.library'
+apply plugin: 'kotlin-android'
+
+android {
+  namespace "io.idealyst.liveactivity"
+  compileSdkVersion safeExtGet('compileSdkVersion', 36)
+
+  defaultConfig {
+    minSdkVersion safeExtGet('minSdkVersion', 24)
+    targetSdkVersion safeExtGet('targetSdkVersion', 36)
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_17
+    targetCompatibility JavaVersion.VERSION_17
+  }
+
+  kotlinOptions {
+    jvmTarget = '17'
+  }
+
+  sourceSets {
+    main {
+      java.srcDirs = ['src/main/java']
+    }
+  }
+}
+
+dependencies {
+  implementation "com.facebook.react:react-android:+"
+  implementation "org.jetbrains.kotlin:kotlin-stdlib:${safeExtGet('kotlinVersion', '1.9.22')}"
+  implementation "androidx.core:core-ktx:1.13.1"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,7 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+  package="io.idealyst.liveactivity">
+
+  <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
+  <uses-permission android:name="android.permission.POST_PROMOTED_NOTIFICATIONS" />
+
+</manifest>

package/android/src/main/java/io/idealyst/liveactivity/IdealystLiveActivityModule.kt

@@ -0,0 +1,299 @@
+package io.idealyst.liveactivity
+
+import com.facebook.react.bridge.*
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import org.json.JSONArray
+import org.json.JSONObject
+import java.util.concurrent.ConcurrentHashMap
+
+class IdealystLiveActivityModule(private val reactContext: ReactApplicationContext) :
+  ReactContextBaseJavaModule(reactContext) {
+
+  override fun getName(): String = "IdealystLiveActivity"
+
+  private val liveUpdateNotification by lazy { LiveUpdateNotification(reactContext) }
+
+  // Track active activities: activityId -> { notificationId, templateType, attributes, contentState, options, startedAt }
+  private val activeActivities = ConcurrentHashMap<String, ActivityRecord>()
+
+  private data class ActivityRecord(
+    val notificationId: Int,
+    val templateType: String,
+    val attributes: JSONObject,
+    val contentState: JSONObject,
+    val options: JSONObject,
+    val startedAt: Long
+  )
+
+  // ---- Availability ----
+
+  @ReactMethod(isBlockingSynchronousMethod = true)
+  fun isSupported(): Boolean {
+    return liveUpdateNotification.isProgressStyleSupported()
+  }
+
+  @ReactMethod
+  fun isEnabled(promise: Promise) {
+    promise.resolve(liveUpdateNotification.canPostPromotedNotifications())
+  }
+
+  // ---- Lifecycle ----
+
+  @ReactMethod
+  fun startActivity(
+    templateType: String,
+    attributesJson: String,
+    contentStateJson: String,
+    optionsJson: String,
+    promise: Promise
+  ) {
+    try {
+      val attributes = JSONObject(attributesJson)
+      val contentState = JSONObject(contentStateJson)
+      val options = JSONObject(optionsJson)
+      val androidOptions = options.optJSONObject("android") ?: JSONObject()
+
+      val notificationId = androidOptions.optInt(
+        "notificationId",
+        LiveUpdateNotification.nextNotificationId()
+      )
+
+      liveUpdateNotification.show(
+        notificationId, templateType, attributes, contentState, androidOptions
+      )
+
+      val activityId = "android_la_$notificationId"
+      val now = System.currentTimeMillis()
+
+      activeActivities[activityId] = ActivityRecord(
+        notificationId = notificationId,
+        templateType = templateType,
+        attributes = attributes,
+        contentState = contentState,
+        options = androidOptions,
+        startedAt = now
+      )
+
+      // Emit started event
+      emitEvent(JSONObject().apply {
+        put("type", "started")
+        put("activityId", activityId)
+        put("timestamp", now)
+        put("payload", JSONObject().put("state", "active"))
+      })
+
+      // Return activity info
+      val info = JSONObject().apply {
+        put("id", activityId)
+        put("state", "active")
+        put("startedAt", now)
+        put("templateType", templateType)
+        put("attributes", attributes)
+        put("contentState", contentState)
+      }
+
+      promise.resolve(info.toString())
+    } catch (e: Exception) {
+      promise.reject("start_failed", e.message, e)
+    }
+  }
+
+  @ReactMethod
+  fun updateActivity(
+    activityId: String,
+    contentStateJson: String,
+    alertConfigJson: String?,
+    promise: Promise
+  ) {
+    try {
+      val record = activeActivities[activityId]
+      if (record == null) {
+        promise.reject("activity_not_found", "No activity found with id: $activityId")
+        return
+      }
+
+      val newContentState = JSONObject(contentStateJson)
+
+      // Merge with existing content state
+      val mergedState = JSONObject(record.contentState.toString())
+      val keys = newContentState.keys()
+      while (keys.hasNext()) {
+        val key = keys.next()
+        mergedState.put(key, newContentState.get(key))
+      }
+
+      liveUpdateNotification.update(
+        record.notificationId, record.templateType, mergedState, record.attributes, record.options
+      )
+
+      // Update stored record
+      activeActivities[activityId] = record.copy(contentState = mergedState)
+
+      emitEvent(JSONObject().apply {
+        put("type", "updated")
+        put("activityId", activityId)
+        put("timestamp", System.currentTimeMillis())
+        put("payload", JSONObject().put("state", "active"))
+      })
+
+      promise.resolve(null)
+    } catch (e: Exception) {
+      promise.reject("update_failed", e.message, e)
+    }
+  }
+
+  @ReactMethod
+  fun endActivity(
+    activityId: String,
+    finalContentStateJson: String?,
+    dismissalPolicy: String,
+    dismissAfter: Double,
+    promise: Promise
+  ) {
+    try {
+      val record = activeActivities[activityId]
+      if (record == null) {
+        promise.reject("activity_not_found", "No activity found with id: $activityId")
+        return
+      }
+
+      // If there's a final state, show it briefly before dismissing
+      if (finalContentStateJson != null) {
+        val finalState = JSONObject(finalContentStateJson)
+        val mergedState = JSONObject(record.contentState.toString())
+        val keys = finalState.keys()
+        while (keys.hasNext()) {
+          val key = keys.next()
+          mergedState.put(key, finalState.get(key))
+        }
+        liveUpdateNotification.update(
+          record.notificationId, record.templateType, mergedState, record.attributes, record.options
+        )
+      }
+
+      // Dismiss based on policy
+      when (dismissalPolicy) {
+        "immediate" -> {
+          liveUpdateNotification.dismiss(record.notificationId)
+        }
+        "afterDate" -> {
+          val delayMs = if (dismissAfter > 0) {
+            (dismissAfter - System.currentTimeMillis()).toLong().coerceAtLeast(0)
+          } else {
+            5000L // Default 5 second delay
+          }
+          android.os.Handler(android.os.Looper.getMainLooper()).postDelayed({
+            liveUpdateNotification.dismiss(record.notificationId)
+          }, delayMs)
+        }
+        else -> {
+          // "default" — dismiss after a short delay (similar to iOS default)
+          android.os.Handler(android.os.Looper.getMainLooper()).postDelayed({
+            liveUpdateNotification.dismiss(record.notificationId)
+          }, 5000L)
+        }
+      }
+
+      activeActivities.remove(activityId)
+
+      emitEvent(JSONObject().apply {
+        put("type", "ended")
+        put("activityId", activityId)
+        put("timestamp", System.currentTimeMillis())
+        put("payload", JSONObject().put("state", "ended"))
+      })
+
+      promise.resolve(null)
+    } catch (e: Exception) {
+      promise.reject("end_failed", e.message, e)
+    }
+  }
+
+  @ReactMethod
+  fun endAllActivities(
+    dismissalPolicy: String,
+    dismissAfter: Double,
+    promise: Promise
+  ) {
+    try {
+      for ((activityId, record) in activeActivities) {
+        liveUpdateNotification.dismiss(record.notificationId)
+
+        emitEvent(JSONObject().apply {
+          put("type", "ended")
+          put("activityId", activityId)
+          put("timestamp", System.currentTimeMillis())
+          put("payload", JSONObject().put("state", "ended"))
+        })
+      }
+      activeActivities.clear()
+      promise.resolve(null)
+    } catch (e: Exception) {
+      promise.reject("end_failed", e.message, e)
+    }
+  }
+
+  // ---- Queries ----
+
+  @ReactMethod
+  fun getActivity(activityId: String, promise: Promise) {
+    val record = activeActivities[activityId]
+    if (record == null) {
+      promise.resolve(null)
+      return
+    }
+
+    promise.resolve(recordToJson(activityId, record).toString())
+  }
+
+  @ReactMethod
+  fun listActivities(promise: Promise) {
+    val array = JSONArray()
+    for ((activityId, record) in activeActivities) {
+      array.put(recordToJson(activityId, record))
+    }
+    promise.resolve(array.toString())
+  }
+
+  @ReactMethod
+  fun getPushToken(activityId: String, promise: Promise) {
+    // Android Live Updates don't have per-activity push tokens.
+    // FCM tokens are managed at the app level via @idealyst/notifications.
+    promise.resolve(null)
+  }
+
+  // ---- Events ----
+
+  @ReactMethod
+  fun addListener(eventName: String) {
+    // Required for NativeEventEmitter
+  }
+
+  @ReactMethod
+  fun removeListeners(count: Int) {
+    // Required for NativeEventEmitter
+  }
+
+  private fun emitEvent(event: JSONObject) {
+    try {
+      reactContext
+        .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+        .emit("IdealystLiveActivityEvent", event.toString())
+    } catch (e: Exception) {
+      // JS not ready yet — ignore
+    }
+  }
+
+  // ---- Helpers ----
+
+  private fun recordToJson(activityId: String, record: ActivityRecord): JSONObject {
+    return JSONObject().apply {
+      put("id", activityId)
+      put("state", "active")
+      put("startedAt", record.startedAt)
+      put("templateType", record.templateType)
+      put("attributes", record.attributes)
+      put("contentState", record.contentState)
+    }
+  }
+}

package/android/src/main/java/io/idealyst/liveactivity/IdealystLiveActivityPackage.kt

@@ -0,0 +1,16 @@
+package io.idealyst.liveactivity
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+class IdealystLiveActivityPackage : ReactPackage {
+  override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+    return listOf(IdealystLiveActivityModule(reactContext))
+  }
+
+  override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+    return emptyList()
+  }
+}

package/android/src/main/java/io/idealyst/liveactivity/LiveUpdateNotification.kt

@@ -0,0 +1,265 @@
+package io.idealyst.liveactivity
+
+import android.app.Notification
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.app.PendingIntent
+import android.content.Context
+import android.content.Intent
+import android.os.Build
+import androidx.core.app.NotificationCompat
+import org.json.JSONObject
+
+/**
+ * Wraps Android notification creation for Live Updates.
+ * Uses Notification.ProgressStyle on API 36+ (Android 16),
+ * falls back to standard progress notification on older versions.
+ */
+class LiveUpdateNotification(private val context: Context) {
+
+  companion object {
+    const val DEFAULT_CHANNEL_ID = "idealyst_live_activity"
+    const val DEFAULT_CHANNEL_NAME = "Live Activities"
+    const val DEFAULT_CHANNEL_DESCRIPTION = "Real-time activity updates"
+
+    private var notificationIdCounter = 9000
+    fun nextNotificationId(): Int = notificationIdCounter++
+  }
+
+  private val notificationManager =
+    context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+
+  init {
+    ensureChannel()
+  }
+
+  private fun ensureChannel() {
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+      val existing = notificationManager.getNotificationChannel(DEFAULT_CHANNEL_ID)
+      if (existing == null) {
+        val channel = NotificationChannel(
+          DEFAULT_CHANNEL_ID,
+          DEFAULT_CHANNEL_NAME,
+          NotificationManager.IMPORTANCE_HIGH
+        ).apply {
+          description = DEFAULT_CHANNEL_DESCRIPTION
+        }
+        notificationManager.createNotificationChannel(channel)
+      }
+    }
+  }
+
+  /**
+   * Check if the device supports Live Updates (ProgressStyle).
+   */
+  fun isProgressStyleSupported(): Boolean {
+    return Build.VERSION.SDK_INT >= 36
+  }
+
+  /**
+   * Check if the app can post promoted notifications (Live Updates).
+   */
+  fun canPostPromotedNotifications(): Boolean {
+    if (Build.VERSION.SDK_INT < 36) return false
+    return try {
+      notificationManager.canPostPromotedNotifications()
+    } catch (e: Exception) {
+      false
+    }
+  }
+
+  /**
+   * Create and show a Live Update notification.
+   * Returns the notification ID used.
+   */
+  fun show(
+    notificationId: Int,
+    templateType: String,
+    attributes: JSONObject,
+    contentState: JSONObject,
+    options: JSONObject
+  ): Int {
+    val channelId = options.optString("channelId", DEFAULT_CHANNEL_ID)
+    val smallIconName = options.optString("smallIcon", "ic_notification")
+    val deepLinkUrl = options.optString("deepLinkUrl", "")
+
+    val smallIconRes = getIconResource(smallIconName)
+
+    if (Build.VERSION.SDK_INT >= 36 && canPostPromotedNotifications()) {
+      showProgressStyleNotification(
+        notificationId, templateType, attributes, contentState,
+        channelId, smallIconRes, deepLinkUrl
+      )
+    } else {
+      showFallbackNotification(
+        notificationId, templateType, attributes, contentState,
+        channelId, smallIconRes, deepLinkUrl
+      )
+    }
+
+    return notificationId
+  }
+
+  /**
+   * Update an existing Live Update notification.
+   */
+  fun update(
+    notificationId: Int,
+    templateType: String,
+    contentState: JSONObject,
+    attributes: JSONObject,
+    options: JSONObject
+  ) {
+    show(notificationId, templateType, attributes, contentState, options)
+  }
+
+  /**
+   * Dismiss a Live Update notification.
+   */
+  fun dismiss(notificationId: Int) {
+    notificationManager.cancel(notificationId)
+  }
+
+  /**
+   * Dismiss all Live Update notifications.
+   */
+  fun dismissAll() {
+    notificationManager.cancelAll()
+  }
+
+  // ---- ProgressStyle (API 36+) ----
+
+  private fun showProgressStyleNotification(
+    notificationId: Int,
+    templateType: String,
+    attributes: JSONObject,
+    contentState: JSONObject,
+    channelId: String,
+    smallIconRes: Int,
+    deepLinkUrl: String
+  ) {
+    if (Build.VERSION.SDK_INT < 36) return
+
+    val title = extractTitle(templateType, attributes, contentState)
+    val status = extractStatus(templateType, contentState)
+    val progress = contentState.optDouble("progress", -1.0)
+
+    val progressStyle = Notification.ProgressStyle()
+
+    if (progress in 0.0..1.0) {
+      progressStyle.setProgress((progress * 100).toInt())
+    } else {
+      progressStyle.setProgressIndeterminate(true)
+    }
+
+    val builder = Notification.Builder(context, channelId)
+      .setSmallIcon(smallIconRes)
+      .setContentTitle(title)
+      .setContentText(status)
+      .setStyle(progressStyle)
+      .setOngoing(true)
+      .setCategory(Notification.CATEGORY_PROGRESS)
+
+    if (deepLinkUrl.isNotEmpty()) {
+      val intent = createDeepLinkIntent(deepLinkUrl)
+      if (intent != null) {
+        val pendingIntent = PendingIntent.getActivity(
+          context, notificationId, intent,
+          PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
+        )
+        builder.setContentIntent(pendingIntent)
+      }
+    }
+
+    notificationManager.notify(notificationId, builder.build())
+  }
+
+  // ---- Fallback (pre-API 36) ----
+
+  private fun showFallbackNotification(
+    notificationId: Int,
+    templateType: String,
+    attributes: JSONObject,
+    contentState: JSONObject,
+    channelId: String,
+    smallIconRes: Int,
+    deepLinkUrl: String
+  ) {
+    val title = extractTitle(templateType, attributes, contentState)
+    val status = extractStatus(templateType, contentState)
+    val progress = contentState.optDouble("progress", -1.0)
+    val indeterminate = contentState.optBoolean("indeterminate", false)
+
+    val builder = NotificationCompat.Builder(context, channelId)
+      .setSmallIcon(smallIconRes)
+      .setContentTitle(title)
+      .setContentText(status)
+      .setOngoing(true)
+      .setPriority(NotificationCompat.PRIORITY_HIGH)
+      .setCategory(NotificationCompat.CATEGORY_PROGRESS)
+
+    if (indeterminate) {
+      builder.setProgress(0, 0, true)
+    } else if (progress in 0.0..1.0) {
+      builder.setProgress(100, (progress * 100).toInt(), false)
+    }
+
+    if (deepLinkUrl.isNotEmpty()) {
+      val intent = createDeepLinkIntent(deepLinkUrl)
+      if (intent != null) {
+        val pendingIntent = PendingIntent.getActivity(
+          context, notificationId, intent,
+          PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
+        )
+        builder.setContentIntent(pendingIntent)
+      }
+    }
+
+    notificationManager.notify(notificationId, builder.build())
+  }
+
+  // ---- Helpers ----
+
+  private fun extractTitle(
+    templateType: String,
+    attributes: JSONObject,
+    contentState: JSONObject
+  ): String {
+    return when (templateType) {
+      "delivery" -> "${attributes.optString("startLabel", "")} → ${attributes.optString("endLabel", "")}"
+      "timer" -> attributes.optString("title", "Timer")
+      "media" -> contentState.optString("trackTitle", attributes.optString("title", "Now Playing"))
+      "progress" -> attributes.optString("title", "Progress")
+      else -> attributes.optString("title", "Live Activity")
+    }
+  }
+
+  private fun extractStatus(templateType: String, contentState: JSONObject): String {
+    return when (templateType) {
+      "delivery" -> contentState.optString("status", "In progress")
+      "timer" -> contentState.optString("subtitle", "Running")
+      "media" -> {
+        val artist = contentState.optString("artist", "")
+        val playing = if (contentState.optBoolean("isPlaying", false)) "Playing" else "Paused"
+        if (artist.isNotEmpty()) "$artist • $playing" else playing
+      }
+      "progress" -> contentState.optString("status", "In progress")
+      else -> contentState.optString("status", "")
+    }
+  }
+
+  private fun getIconResource(name: String): Int {
+    val res = context.resources.getIdentifier(name, "drawable", context.packageName)
+    return if (res != 0) res else android.R.drawable.ic_popup_sync
+  }
+
+  private fun createDeepLinkIntent(url: String): Intent? {
+    return try {
+      val intent = Intent(Intent.ACTION_VIEW, android.net.Uri.parse(url))
+      intent.setPackage(context.packageName)
+      intent
+    } catch (e: Exception) {
+      null
+    }
+  }
+}

package/idealyst-live-activity.podspec

@@ -0,0 +1,22 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "idealyst-live-activity"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["documentation"]
+  s.license      = package["license"]
+  s.authors      = { "Idealyst" => "contact@idealyst.io" }
+  s.source       = { :git => package["repository"]["url"], :tag => s.version }
+
+  s.platforms    = { :ios => "16.2" }
+  s.swift_version = "5.9"
+
+  s.source_files = "ios/**/*.{swift,h,m,mm}"
+
+  s.dependency "React-Core"
+
+  s.frameworks = "ActivityKit", "WidgetKit", "SwiftUI"
+end

package/ios/IdealystLiveActivity-Bridging-Header.h

@@ -0,0 +1,2 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>