react-native-alarms 0.0.5 → 0.0.7

package/android/app/src/main/java/com/reactnativealarm/alarm/AlarmData.kt

@@ -3,6 +3,7 @@ package com.alarm
 import android.os.Bundle
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableArray
 import com.facebook.react.bridge.WritableMap
 import org.json.JSONArray
 import org.json.JSONObject
@@ -21,8 +22,29 @@ data class AlarmData(
   val weekdays: List<Int>,
   val intervalMs: Long,
   val data: String,
-  var enabled: Boolean = true
+  var enabled: Boolean = true,
+  val componentName: String = "AlarmRing",
+  val componentPropsJSON: String = "{}"
 ) {
+  val componentProps: Map<String, Any>
+    get() {
+      return try {
+        val obj = JSONObject(componentPropsJSON)
+        val map = mutableMapOf<String, Any>()
+        val keys = obj.keys()
+        while (keys.hasNext()) {
+          val key = keys.next()
+          val value = obj.get(key)
+          if (value != JSONObject.NULL) {
+            map[key] = value
+          }
+        }
+        map
+      } catch (_: Exception) {
+        emptyMap()
+      }
+    }
+
   fun nextTrigger(from: Long = System.currentTimeMillis()): Long {
     if (!enabled) return 0
     return when (repeatType) {
@@ -59,6 +81,8 @@ data class AlarmData(
     put("snoozeMinutes", snoozeMinutes); put("repeatType", repeatType)
     put("weekdays", JSONArray(weekdays)); put("intervalMs", intervalMs)
     put("data", data); put("enabled", enabled)
+    put("componentName", componentName)
+    put("componentPropsJSON", componentPropsJSON)
   }.toString()
 
   fun toWritableMap(): WritableMap = Arguments.createMap().apply {
@@ -78,6 +102,13 @@ data class AlarmData(
     putString("data", data)
     putBoolean("enabled", enabled)
     putDouble("nextTriggerAt", nextTrigger().toDouble())
+    putString("componentName", componentName)
+    putString("componentPropsJSON", componentPropsJSON)
+    try {
+      putMap("componentProps", jsonToWritableMap(JSONObject(componentPropsJSON)))
+    } catch (_: Exception) {
+      putMap("componentProps", Arguments.createMap())
+    }
   }
 
   /** Initial props for the React ring screen hosted by [AlarmRingActivity]. */
@@ -89,19 +120,70 @@ data class AlarmData(
     putBoolean("snoozeEnabled", snoozeEnabled)
     putInt("snoozeMinutes", snoozeMinutes)
     putString("data", data)
+    putString("componentName", componentName)
+    putString("componentPropsJSON", componentPropsJSON)
+    try {
+      val propsObj = JSONObject(componentPropsJSON)
+      val propsBundle = jsonToBundle(propsObj)
+      putBundle("componentProps", propsBundle)
+      for (key in propsBundle.keySet()) {
+        if (!containsKey(key)) {
+          val v = propsBundle.get(key)
+          when (v) {
+            is String -> putString(key, v)
+            is Boolean -> putBoolean(key, v)
+            is Int -> putInt(key, v)
+            is Long -> putLong(key, v)
+            is Double -> putDouble(key, v)
+            is Bundle -> putBundle(key, v)
+          }
+        }
+      }
+    } catch (_: Exception) {}
+  }
+
+  private fun jsonToBundle(jsonObject: JSONObject): Bundle {
+    val bundle = Bundle()
+    val iter = jsonObject.keys()
+    while (iter.hasNext()) {
+      val key = iter.next()
+      when (val value = jsonObject.opt(key)) {
+        is JSONObject -> bundle.putBundle(key, jsonToBundle(value))
+        is JSONArray -> bundle.putString(key, value.toString())
+        is Boolean -> bundle.putBoolean(key, value)
+        is Int -> bundle.putInt(key, value)
+        is Long -> bundle.putLong(key, value)
+        is Double -> bundle.putDouble(key, value)
+        is String -> bundle.putString(key, value)
+        else -> if (value != null && value != JSONObject.NULL) {
+          bundle.putString(key, value.toString())
+        }
+      }
+    }
+    return bundle
   }
 
   companion object {
     fun fromJson(s: String): AlarmData {
       val o = JSONObject(s)
       val wd = o.optJSONArray("weekdays")
+      val compName = o.optString("componentName", "AlarmRing").trim()
       return AlarmData(
-        o.getString("id"), o.getLong("timestamp"), o.optString("title"), o.optString("body"),
-        o.optString("sound", "default"), o.optBoolean("vibrate", true),
-        o.optBoolean("snoozeEnabled", true), o.optInt("snoozeMinutes", 5),
-        o.optString("repeatType", "none"),
-        if (wd == null) emptyList() else (0 until wd.length()).map { wd.getInt(it) },
-        o.optLong("intervalMs", 0), o.optString("data"), o.optBoolean("enabled", true)
+        id = o.getString("id"),
+        timestamp = o.getLong("timestamp"),
+        title = o.optString("title"),
+        body = o.optString("body"),
+        sound = o.optString("sound", "default"),
+        vibrate = o.optBoolean("vibrate", true),
+        snoozeEnabled = o.optBoolean("snoozeEnabled", true),
+        snoozeMinutes = o.optInt("snoozeMinutes", 5),
+        repeatType = o.optString("repeatType", "none"),
+        weekdays = if (wd == null) emptyList() else (0 until wd.length()).map { wd.getInt(it) },
+        intervalMs = o.optLong("intervalMs", 0),
+        data = o.optString("data"),
+        enabled = o.optBoolean("enabled", true),
+        componentName = if (compName.isEmpty()) "AlarmRing" else compName,
+        componentPropsJSON = o.optString("componentPropsJSON", "{}").ifBlank { "{}" }
       )
     }
 
@@ -109,6 +191,24 @@ data class AlarmData(
       val r = if (m.hasKey("repeat") && !m.isNull("repeat")) m.getMap("repeat") else null
       val wd = r?.takeIf { it.hasKey("weekdays") }?.getArray("weekdays")
         ?.let { a -> (0 until a.size()).map { a.getInt(it) } } ?: emptyList()
+
+      val componentPropsStr = when {
+        m.hasKey("componentPropsJSON") && !m.isNull("componentPropsJSON") ->
+          m.getString("componentPropsJSON") ?: "{}"
+        m.hasKey("componentProps") && !m.isNull("componentProps") -> {
+          val propsMap = m.getMap("componentProps")
+          try {
+            val hashMap = propsMap?.toHashMap() ?: emptyMap<String, Any>()
+            JSONObject(hashMap).toString()
+          } catch (_: Exception) {
+            "{}"
+          }
+        }
+        else -> "{}"
+      }
+
+      val compName = m.str("componentName", "AlarmRing").trim()
+
       return AlarmData(
         id = id,
         timestamp = m.getDouble("timestamp").toLong(),
@@ -121,10 +221,56 @@ data class AlarmData(
         repeatType = r?.str("type", "none") ?: "none",
         weekdays = wd,
         intervalMs = if (r != null && r.hasKey("intervalMs")) r.getDouble("intervalMs").toLong() else 0,
-        data = m.str("data")
+        data = m.str("data"),
+        componentName = if (compName.isEmpty()) "AlarmRing" else compName,
+        componentPropsJSON = componentPropsStr
       )
     }
 
+    private fun jsonToWritableMap(jsonObject: JSONObject): WritableMap {
+      val map = Arguments.createMap()
+      val iter = jsonObject.keys()
+      while (iter.hasNext()) {
+        val key = iter.next()
+        when (val value = jsonObject.opt(key)) {
+          is JSONObject -> map.putMap(key, jsonToWritableMap(value))
+          is JSONArray -> map.putArray(key, jsonToWritableArray(value))
+          is Boolean -> map.putBoolean(key, value)
+          is Int -> map.putInt(key, value)
+          is Long -> map.putDouble(key, value.toDouble())
+          is Double -> map.putDouble(key, value)
+          is String -> map.putString(key, value)
+          else -> if (value == null || value == JSONObject.NULL) {
+            map.putNull(key)
+          } else {
+            map.putString(key, value.toString())
+          }
+        }
+      }
+      return map
+    }
+
+    private fun jsonToWritableArray(jsonArray: JSONArray): WritableArray {
+      val array = Arguments.createArray()
+      for (i in 0 until jsonArray.length()) {
+        when (val value = jsonArray.opt(i)) {
+          is JSONObject -> array.pushMap(jsonToWritableMap(value))
+          is JSONArray -> array.pushArray(jsonToWritableArray(value))
+          is Boolean -> array.pushBoolean(value)
+          is Int -> array.pushInt(value)
+          is Long -> array.pushDouble(value.toDouble())
+          is Double -> array.pushDouble(value)
+          is String -> array.pushString(value)
+          else -> if (value == null || value == JSONObject.NULL) {
+            array.pushNull()
+          } else {
+            array.pushString(value.toString())
+          }
+        }
+      }
+      return array
+    }
+
     private fun ReadableMap.str(k: String, d: String = "") =
       if (hasKey(k) && !isNull(k)) getString(k) ?: d else d
 

package/android/app/src/main/java/com/reactnativealarm/alarm/AlarmModule.kt

@@ -31,14 +31,14 @@ class AlarmModule(private val ctx: ReactApplicationContext) : ReactContextBaseJa
   private fun notificationsGranted(): Boolean =
     if (Build.VERSION.SDK_INT >= 33)
       ContextCompat.checkSelfPermission(ctx, Manifest.permission.POST_NOTIFICATIONS) ==
-        PackageManager.PERMISSION_GRANTED
+              PackageManager.PERMISSION_GRANTED
     else NotificationManagerCompat.from(ctx).areNotificationsEnabled()
 
   private fun canDrawOverlays(): Boolean = Settings.canDrawOverlays(ctx)
 
   private fun canUseFullScreenIntent(): Boolean =
     Build.VERSION.SDK_INT < 34 ||
-      ctx.getSystemService(NotificationManager::class.java).canUseFullScreenIntent()
+            ctx.getSystemService(NotificationManager::class.java).canUseFullScreenIntent()
 
   private fun permissionMap(): WritableMap = Arguments.createMap().apply {
     val ok = notificationsGranted()

package/android/app/src/main/java/com/reactnativealarm/alarm/AlarmRingActivity.kt

@@ -18,7 +18,8 @@ import java.lang.ref.WeakReference
  */
 class AlarmRingActivity : ReactActivity() {
 
-  override fun getMainComponentName(): String = COMPONENT_NAME
+  override fun getMainComponentName(): String =
+    AlarmService.current?.componentName?.takeIf { it.isNotBlank() } ?: COMPONENT_NAME
 
   override fun createReactActivityDelegate(): ReactActivityDelegate =
     object : DefaultReactActivityDelegate(this, mainComponentName, fabricEnabled) {
@@ -45,7 +46,7 @@ class AlarmRingActivity : ReactActivity() {
       @Suppress("DEPRECATION")
       window.addFlags(
         WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED or
-          WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON
+                WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON
       )
     }
     window.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)

package/android/local.properties

@@ -0,0 +1,8 @@
+## This file must *NOT* be checked into Version Control Systems,
+# as it contains information specific to your local configuration.
+#
+# Location of the SDK. This is only used by Gradle.
+# For customization when using a Version Control System, please read the
+# header note.
+#Fri Oct 23 16:38:30 IST 2026
+sdk.dir=/Users/apple/Library/Android/sdk

package/commitlint.config.mjs

@@ -0,0 +1 @@
+export default { extends: ['@commitlint/config-conventional'] };

package/index.d.ts

@@ -8,13 +8,13 @@ import type { Spec } from './specs/NativeAlarm';
 export type {
   AlarmRepeat,
   AlarmConfig,
-  Alarm,
+  AlarmProp,
   AlarmPermission,
   AlarmEvent,
-  Spec as AlarmModuleSpec,
-} from './specs/NativeAlarm';
+} from './src/types';
 
 export { AlarmService } from './AlarmService';
 
 declare const Alarm: Spec;
+
 export default Alarm;

package/index.ts

@@ -8,13 +8,13 @@
 export type {
   AlarmRepeat,
   AlarmConfig,
-  Alarm,
+  AlarmProp,
   AlarmPermission,
   AlarmEvent,
-  Spec as AlarmModuleSpec,
-} from './specs/NativeAlarm';
+} from './src/types';
 
 export { AlarmService } from './AlarmService';
 
-import NativeAlarm from './specs/NativeAlarm';
-export default NativeAlarm;
+import Alarm from './specs/NativeAlarm';
+
+export default Alarm;

package/ios/alarm/AlarmData.swift

@@ -16,11 +16,25 @@ struct AlarmData: Codable {
   var intervalMs: Double
   var data: String
   var enabled: Bool = true
-
+  var componentName: String = "AlarmRing"
+  var componentPropsJSON: String = "{}"
+  
   static func now() -> Double { Date().timeIntervalSince1970 * 1000 }
-
+  
   var date: Date { Date(timeIntervalSince1970: timestamp / 1000) }
 
+   var componentProps: [String: Any] {
+        guard
+            let jsonData = componentPropsJSON.data(using: .utf8),
+            let object = try? JSONSerialization.jsonObject(with: jsonData),
+            let props = object as? [String: Any]
+        else {
+            return [:]
+        }
+
+        return props
+    }
+  
   /// Next time this alarm should ring, in ms since epoch, or 0 if never.
   func nextTrigger(from: Double = AlarmData.now()) -> Double {
     if !enabled { return 0 }
@@ -37,7 +51,7 @@ struct AlarmData: Codable {
       return timestamp > from ? timestamp : 0
     }
   }
-
+  
   private func nextMatching(from: Double, ok: (Int) -> Bool) -> Double {
     let cal = Calendar.current
     let base = cal.dateComponents([.hour, .minute], from: date)
@@ -55,9 +69,9 @@ struct AlarmData: Codable {
     }
     return 0
   }
-
+  
   // MARK: - JS bridge shape (same keys as Android)
-
+  
   func toDictionary() -> [String: Any] {
     [
       "alarmId": id,
@@ -74,7 +88,7 @@ struct AlarmData: Codable {
       "nextTriggerAt": nextTrigger(),
     ]
   }
-
+  
   /// Parses the `AlarmConfig` object JS passes to `scheduleAlarm` / `updateAlarm`.
   static func from(config m: [String: Any], id: String) -> AlarmData {
     let r = m["repeat"] as? [String: Any]

package/ios/alarm/AlarmKitBackend.swift

@@ -20,13 +20,13 @@ struct OpenAlarmAppIntent: LiveActivityIntent {
   static let description = IntentDescription("Opens the ringing alarm's screen")
   static let openAppWhenRun: Bool = true
   static let isDiscoverable: Bool = false
-
+  
   @Parameter(title: "alarmID")
   var alarmID: String
-
+  
   init() {}
   init(alarmID: String) { self.alarmID = alarmID }
-
+  
   func perform() async throws -> some IntentResult {
     AlarmKitBackend.shared.openFromAlert(alarmID)
     return .result()
@@ -39,11 +39,11 @@ struct OpenAlarmAppIntent: LiveActivityIntent {
 @available(iOS 26.0, *)
 final class AlarmKitBackend {
   static let shared = AlarmKitBackend()
-
+  
   private let manager = AlarmManager.shared
   /// Wired by `AlarmModule` so native events reach JS.
   var onEvent: ((String, AlarmData) -> Void)?
-
+  
   private var observer: Task<Void, Never>?
   private var lastStates: [UUID: Alarm.State] = [:]
   /// Alarms we are stopping as part of a programmatic snooze (so the observer
@@ -53,15 +53,15 @@ final class AlarmKitBackend {
   /// (with its own TTS) is showing. The ring session stays alive until JS calls
   /// stop/snooze, so the observer must not report these as dismissed.
   private var silenced: [UUID: AlarmData] = [:]
-
+  
   private static let allWeekdays: [Locale.Weekday] = [
     .sunday, .monday, .tuesday, .wednesday, .thursday, .friday, .saturday,
   ]
-
+  
   // MARK: - Authorization
-
+  
   var isAuthorized: Bool { manager.authorizationState == .authorized }
-
+  
   /// 'granted' | 'denied' | 'notDetermined', same vocabulary as Android.
   var status: String {
     switch manager.authorizationState {
@@ -70,13 +70,13 @@ final class AlarmKitBackend {
     default: return "notDetermined"
     }
   }
-
+  
   func requestAuthorization() async -> Bool {
     (try? await manager.requestAuthorization()) == .authorized
   }
-
+  
   // MARK: - Ids
-
+  
   /// Android ids are free-form strings; AlarmKit wants UUIDs. Real UUIDs pass through,
   /// anything else is hashed deterministically so cancel/stop can find it again.
   static func uuid(for id: String, snooze: Bool = false) -> UUID {
@@ -85,20 +85,20 @@ final class AlarmKitBackend {
     let bytes = Array(SHA256.hash(data: Data(key.utf8)).prefix(16))
     return bytes.withUnsafeBufferPointer { NSUUID(uuidBytes: $0.baseAddress!) as UUID }
   }
-
+  
   private func stored(for uuid: UUID) -> AlarmData? {
     AlarmStore.all().first {
       Self.uuid(for: $0.id) == uuid || Self.uuid(for: $0.id, snooze: true) == uuid
     }
   }
-
+  
   // MARK: - Scheduling
-
+  
   func schedule(_ a: AlarmData) async throws {
     cancel(a.id)
     let next = a.nextTrigger()
     guard next > 0 else { return } // nothing in the future; Android skips too
-
+    
     let hm = Calendar.current.dateComponents([.hour, .minute], from: a.date)
     let time = Alarm.Schedule.Relative.Time(hour: hm.hour ?? 0, minute: hm.minute ?? 0)
     let schedule: Alarm.Schedule
@@ -107,21 +107,21 @@ final class AlarmKitBackend {
       schedule = .relative(.init(time: time, repeats: .weekly(Self.allWeekdays)))
     case "weekly":
       let days = a.weekdays.isEmpty
-        ? Self.allWeekdays
-        : a.weekdays.filter { (1...7).contains($0) }.map { Self.allWeekdays[$0 - 1] }
+      ? Self.allWeekdays
+      : a.weekdays.filter { (1...7).contains($0) }.map { Self.allWeekdays[$0 - 1] }
       schedule = .relative(.init(time: time, repeats: .weekly(days)))
     default:
       // none: one exact ring. interval: one exact ring, re-armed by the observer
       // after it is dismissed (only while the app process is alive).
       schedule = .fixed(Date(timeIntervalSince1970: next / 1000))
     }
-
+    
     _ = try await manager.schedule(id: Self.uuid(for: a.id), configuration: configuration(for: a, schedule: schedule))
     startObserving()
   }
-
+  
   private func configuration(for a: AlarmData, schedule: Alarm.Schedule)
-    -> AlarmManager.AlarmConfiguration<RNAlarmMetadata>
+  -> AlarmManager.AlarmConfiguration<RNAlarmMetadata>
   {
     let title = LocalizedStringResource(stringLiteral: a.title.isEmpty ? "Alarm" : a.title)
     let stop = AlarmButton(text: "Stop", textColor: .white, systemImageName: "stop.fill")
@@ -132,15 +132,15 @@ final class AlarmKitBackend {
     let alert = AlarmPresentation.Alert(
       title: title, stopButton: stop, secondaryButton: open, secondaryButtonBehavior: .custom
     )
-
+    
     let attributes = AlarmAttributes<RNAlarmMetadata>(
       presentation: AlarmPresentation(alert: alert),
       metadata: RNAlarmMetadata(),
       tintColor: .blue
     )
     let sound: AlertConfiguration.AlertSound =
-      (a.sound.isEmpty || a.sound == "default") ? .default : .named(a.sound)
-
+    (a.sound.isEmpty || a.sound == "default") ? .default : .named(a.sound)
+    
     return AlarmManager.AlarmConfiguration(
       schedule: schedule,
       attributes: attributes,
@@ -148,18 +148,18 @@ final class AlarmKitBackend {
       sound: sound
     )
   }
-
+  
   func cancel(_ id: String) {
     for uuid in [Self.uuid(for: id), Self.uuid(for: id, snooze: true)] {
       try? manager.cancel(id: uuid)
       silenced.removeValue(forKey: uuid)
     }
   }
-
+  
   func cancelAll() {
     for alarm in (try? manager.alarms) ?? [] { try? manager.cancel(id: alarm.id) }
   }
-
+  
   func stop(_ id: String) {
     for uuid in [Self.uuid(for: id), Self.uuid(for: id, snooze: true)] {
       try? manager.stop(id: uuid)
@@ -171,7 +171,7 @@ final class AlarmKitBackend {
       }
     }
   }
-
+  
   /// "Open" tapped on the system alert (OpenAlarmAppIntent). The tap stops the
   /// AlarmKit alarm, so adopt the session as `silenced` — still ringing as far as
   /// JS is concerned — and show the React ring screen once the app is frontmost.
@@ -179,7 +179,7 @@ final class AlarmKitBackend {
     guard let a = AlarmStore.get(id) else { return }
     let current = (try? manager.alarms) ?? []
     for uuid in [Self.uuid(for: a.id), Self.uuid(for: a.id, snooze: true)]
-    where current.contains(where: { $0.id == uuid && $0.state == .alerting }) {
+          where current.contains(where: { $0.id == uuid && $0.state == .alerting }) {
       silenced[uuid] = a
       try? manager.stop(id: uuid)
     }
@@ -187,20 +187,23 @@ final class AlarmKitBackend {
     if !silenced.values.contains(where: { $0.id == a.id }) {
       silenced[Self.uuid(for: a.id)] = a
     }
-    DispatchQueue.main.async { AlarmRingPresenter.present(a, bridge: nil) }
+    DispatchQueue.main.async { AlarmRingPresenter.present(a, bridge: nil,
+                                                          componentName: a.componentName,
+                                                          componentProps: a.componentProps
+    ) }
   }
-
+  
   /// Stops the system alert's sound/UI while the in-app ring screen takes over.
   /// The session stays "ringing" (see `silenced`) until JS stops or snoozes it.
   func silence(_ id: String) {
     let current = (try? manager.alarms) ?? []
     for uuid in [Self.uuid(for: id), Self.uuid(for: id, snooze: true)]
-    where current.contains(where: { $0.id == uuid && $0.state == .alerting }) {
+          where current.contains(where: { $0.id == uuid && $0.state == .alerting }) {
       silenced[uuid] = stored(for: uuid)
       try? manager.stop(id: uuid)
     }
   }
-
+  
   /// Silences the ringing alarm (if any) and re-rings once in `minutes`,
   /// equivalent to Android's `AlarmScheduler.scheduleSnooze`.
   func snooze(_ a: AlarmData, minutes: Int) async throws {
@@ -222,7 +225,7 @@ final class AlarmKitBackend {
     )
     startObserving()
   }
-
+  
   func ringingAlarm() -> AlarmData? {
     if let alerting = ((try? manager.alarms) ?? []).first(where: { $0.state == .alerting }) {
       return stored(for: alerting.id)
@@ -230,9 +233,9 @@ final class AlarmKitBackend {
     // Sound silenced for the in-app ring screen, but the session is still live.
     return silenced.values.first
   }
-
+  
   // MARK: - Events
-
+  
   /// Translates AlarmKit state changes into the Android-style events.
   func startObserving() {
     guard observer == nil else { return }
@@ -243,11 +246,11 @@ final class AlarmKitBackend {
       }
     }
   }
-
+  
   private func handle(_ alarms: [Alarm]) {
     var states: [UUID: Alarm.State] = [:]
     for alarm in alarms { states[alarm.id] = alarm.state }
-
+    
     for (uuid, state) in states where lastStates[uuid] != state {
       guard let a = stored(for: uuid) else { continue }
       if state == .alerting {
@@ -258,7 +261,7 @@ final class AlarmKitBackend {
         onEvent?(state == .countdown ? AlarmModule.eventSnoozed : AlarmModule.eventDismissed, a)
       }
     }
-
+    
     // One-off (`.fixed`) alarms disappear once stopped.
     for (uuid, previous) in lastStates where states[uuid] == nil && previous == .alerting {
       if silenced[uuid] != nil { continue } // silenced for the ring screen, not over yet
@@ -272,7 +275,7 @@ final class AlarmKitBackend {
         }
       }
     }
-
+    
     lastStates = states
   }
 }