react-native-alarms 0.0.6 → 0.0.7

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
   }
 }

package/ios/alarm/AlarmModule.swift

@@ -14,20 +14,20 @@ final class AlarmModule: RCTEventEmitter {
   static let eventFired = "onAlarmFired"
   static let eventDismissed = "onAlarmDismissed"
   static let eventSnoozed = "onAlarmSnoozed"
-
+  
   private var hasListeners = false
   private var activeObserver: NSObjectProtocol?
-
+  
   override init() {
     super.init()
     NotificationBackend.install()
     NotificationBackend.shared.onEvent = { [weak self] name, alarm in self?.handle(name, alarm) }
-    #if canImport(AlarmKit)
+#if canImport(AlarmKit)
     if #available(iOS 26.0, *) {
       AlarmKitBackend.shared.onEvent = { [weak self] name, alarm in self?.handle(name, alarm) }
       AlarmKitBackend.shared.startObserving()
     }
-    #endif
+#endif
     // App launched by tapping the alarm notification/alert before this module existed.
     DispatchQueue.main.async { [weak self] in self?.presentIfRinging() }
     // Tapping an AlarmKit alert (and some notification taps on a warm start) only
@@ -36,40 +36,44 @@ final class AlarmModule: RCTEventEmitter {
       forName: UIApplication.didBecomeActiveNotification, object: nil, queue: .main
     ) { [weak self] _ in self?.presentIfRinging() }
   }
-
+  
   deinit {
     if let activeObserver { NotificationCenter.default.removeObserver(activeObserver) }
   }
-
+  
   /// Shows the ring screen when a backend says an alarm is ringing right now.
   private func presentIfRinging() {
     var ringing = NotificationBackend.shared.ringing
-    #if canImport(AlarmKit)
+#if canImport(AlarmKit)
     if #available(iOS 26.0, *), ringing == nil { ringing = AlarmKitBackend.shared.ringingAlarm() }
-    #endif
-    if let ringing { AlarmRingPresenter.present(ringing, bridge: bridge) }
+#endif
+    if let ringing { AlarmRingPresenter.present(ringing, bridge: bridge,
+                                                componentName: ringing.componentName ?? "AlarmRing",
+                                                componentProps: ringing.componentProps ?? [:]) }
   }
-
+  
   private func handle(_ name: String, _ alarm: AlarmData) {
     if name == Self.eventFired {
-      AlarmRingPresenter.present(alarm, bridge: bridge)
+      AlarmRingPresenter.present(alarm, bridge: bridge,
+                                 componentName: alarm.componentName ?? "AlarmRing",
+                                 componentProps: alarm.componentProps ?? [:])
     } else {
       AlarmRingPresenter.dismiss(alarm.id)
     }
     emit(name, alarm)
   }
-
+  
   @objc override static func requiresMainQueueSetup() -> Bool { false }
-
+  
   // MARK: - Events
-
+  
   override func supportedEvents() -> [String]! {
     [Self.eventFired, Self.eventDismissed, Self.eventSnoozed]
   }
-
+  
   override func startObserving() { hasListeners = true }
   override func stopObserving() { hasListeners = false }
-
+  
   private func emit(_ name: String, _ a: AlarmData) {
     guard hasListeners else { return }
     sendEvent(withName: name, body: [
@@ -80,38 +84,38 @@ final class AlarmModule: RCTEventEmitter {
       "data": a.data,
     ])
   }
-
+  
   // MARK: - Backend selection
-
+  
   private var useAlarmKit: Bool {
-    #if canImport(AlarmKit)
+#if canImport(AlarmKit)
     if #available(iOS 26.0, *) { return AlarmKitBackend.shared.isAuthorized }
-    #endif
+#endif
     return false
   }
-
+  
   private func cancelNative(_ id: String) {
     AlarmRingPresenter.dismiss(id)
     NotificationBackend.shared.cancel(id)
-    #if canImport(AlarmKit)
+#if canImport(AlarmKit)
     if #available(iOS 26.0, *) { AlarmKitBackend.shared.cancel(id) }
-    #endif
+#endif
   }
-
+  
   // MARK: - Permissions
-
+  
   /// Same keys as Android's `permissionMap()`. The Android-only flags are always
   /// true here so shared UI code can treat them as granted.
   private func permissionMap(_ done: @escaping ([String: Any]) -> Void) {
     NotificationBackend.shared.status { notifications in
       var status = notifications
       var backend = "notifications"
-      #if canImport(AlarmKit)
+#if canImport(AlarmKit)
       if #available(iOS 26.0, *) {
         status = AlarmKitBackend.shared.status
         backend = "alarmkit"
       }
-      #endif
+#endif
       done([
         "status": status,
         "notifications": status == "granted" || notifications == "granted",
@@ -122,15 +126,15 @@ final class AlarmModule: RCTEventEmitter {
       ])
     }
   }
-
+  
   private func notificationStatus() async -> String {
     await withCheckedContinuation { c in NotificationBackend.shared.status { c.resume(returning: $0) } }
   }
-
+  
   private func requestNotifications() async {
     _ = await withCheckedContinuation { c in NotificationBackend.shared.request { c.resume(returning: $0) } }
   }
-
+  
   /// iOS never re-prompts after a denial, so (like Android for its special
   /// permissions) send the user to the app's Settings page.
   @MainActor private func openSettings() {
@@ -138,16 +142,16 @@ final class AlarmModule: RCTEventEmitter {
       UIApplication.shared.open(url)
     }
   }
-
+  
   @objc(checkPermission:reject:)
   func checkPermission(_ resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
     permissionMap { resolve($0) }
   }
-
+  
   @objc(requestPermission:reject:)
   func requestPermission(_ resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
     Task {
-      #if canImport(AlarmKit)
+#if canImport(AlarmKit)
       if #available(iOS 26.0, *) {
         let kit = AlarmKitBackend.shared
         if kit.status == "notDetermined" { _ = await kit.requestAuthorization() }
@@ -157,7 +161,7 @@ final class AlarmModule: RCTEventEmitter {
         }
         await self.openSettings()
       }
-      #endif
+#endif
       // Notifications back the fallback path.
       let notifications = await self.notificationStatus()
       if notifications == "notDetermined" {
@@ -168,42 +172,42 @@ final class AlarmModule: RCTEventEmitter {
       self.permissionMap { resolve($0) }
     }
   }
-
+  
   @objc(canScheduleExactAlarms:reject:)
   func canScheduleExactAlarms(_ resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
     permissionMap { (map: [String: Any]) in
       resolve((map["canScheduleExact"] as? Bool) ?? false)
     }
   }
-
+  
   /// Android OEM concept; iOS has no such screen.
   @objc(openAutoStartSettings:reject:)
   func openAutoStartSettings(_ resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
     resolve(false)
   }
-
+  
   // MARK: - Scheduling
-
+  
   @objc(scheduleAlarm:resolve:reject:)
   func scheduleAlarm(_ config: NSDictionary, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
     let dict = config as? [String: Any] ?? [:]
     let id = (dict["alarmId"] as? String) ?? UUID().uuidString
     arm(AlarmData.from(config: dict, id: id), code: "E_SCHEDULE", reject: reject) { resolve(id) }
   }
-
+  
   @objc(updateAlarm:config:resolve:reject:)
   func updateAlarm(_ alarmId: String, config: NSDictionary, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
     guard AlarmStore.get(alarmId) != nil else { return resolve(false) }
     let dict = config as? [String: Any] ?? [:]
     arm(AlarmData.from(config: dict, id: alarmId), code: "E_UPDATE", reject: reject) { resolve(true) }
   }
-
+  
   /// Cancel → persist → schedule, the same sequence as Android.
   private func arm(_ alarm: AlarmData, code: String, reject: @escaping RCTPromiseRejectBlock, done: @escaping () -> Void) {
     cancelNative(alarm.id)
     AlarmStore.save(alarm)
-
-    #if canImport(AlarmKit)
+    
+#if canImport(AlarmKit)
     if #available(iOS 26.0, *), useAlarmKit {
       Task {
         do {
@@ -215,8 +219,8 @@ final class AlarmModule: RCTEventEmitter {
       }
       return
     }
-    #endif
-
+#endif
+    
     NotificationBackend.shared.status { status in
       guard status == "granted" else {
         // Mirrors Android's SecurityException when the exact-alarm permission is missing.
@@ -227,7 +231,7 @@ final class AlarmModule: RCTEventEmitter {
       }
     }
   }
-
+  
   @objc(cancelAlarm:resolve:reject:)
   func cancelAlarm(_ alarmId: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
     let existed = AlarmStore.get(alarmId) != nil
@@ -235,31 +239,31 @@ final class AlarmModule: RCTEventEmitter {
     AlarmStore.remove(alarmId)
     resolve(existed)
   }
-
+  
   @objc(cancelAllAlarms:reject:)
   func cancelAllAlarms(_ resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
     AlarmRingPresenter.dismiss()
     AlarmStore.all().forEach { cancelNative($0.id) }
     NotificationBackend.shared.cancelAll()
-    #if canImport(AlarmKit)
+#if canImport(AlarmKit)
     if #available(iOS 26.0, *) { AlarmKitBackend.shared.cancelAll() }
-    #endif
+#endif
     AlarmStore.clear()
     resolve(nil)
   }
-
+  
   // MARK: - Control (while ringing)
-
+  
   @objc(stopAlarm:resolve:reject:)
   func stopAlarm(_ alarmId: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
     AlarmRingPresenter.dismiss(alarmId)
     NotificationBackend.shared.stop(alarmId)
-    #if canImport(AlarmKit)
+#if canImport(AlarmKit)
     if #available(iOS 26.0, *) { AlarmKitBackend.shared.stop(alarmId) }
-    #endif
+#endif
     resolve(nil)
   }
-
+  
   @objc(snoozeAlarm:minutes:resolve:reject:)
   func snoozeAlarm(_ alarmId: String, minutes: Double, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
     guard let alarm = AlarmStore.get(alarmId) else {
@@ -267,8 +271,8 @@ final class AlarmModule: RCTEventEmitter {
     }
     let mins = minutes > 0 ? Int(minutes) : alarm.snoozeMinutes
     AlarmRingPresenter.dismiss(alarmId)
-
-    #if canImport(AlarmKit)
+    
+#if canImport(AlarmKit)
     if #available(iOS 26.0, *), useAlarmKit {
       Task {
         do {
@@ -280,36 +284,36 @@ final class AlarmModule: RCTEventEmitter {
       }
       return
     }
-    #endif
-
+#endif
+    
     let wasRinging = NotificationBackend.shared.ringing?.id == alarmId
     NotificationBackend.shared.snooze(alarm, minutes: mins)
     if wasRinging { emit(Self.eventSnoozed, alarm) }
     resolve(nil)
   }
-
+  
   /// The alarm currently ringing (if any), so JS can show the ring UI on launch.
   @objc(getRingingAlarm:reject:)
   func getRingingAlarm(_ resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
     var ringing = NotificationBackend.shared.ringing
-    #if canImport(AlarmKit)
+#if canImport(AlarmKit)
     if #available(iOS 26.0, *), ringing == nil { ringing = AlarmKitBackend.shared.ringingAlarm() }
-    #endif
+#endif
     resolve(ringing?.toDictionary())
   }
-
+  
   // MARK: - Queries
-
+  
   @objc(getAlarm:resolve:reject:)
   func getAlarm(_ alarmId: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
     resolve(AlarmStore.get(alarmId)?.toDictionary())
   }
-
+  
   @objc(getAllAlarms:reject:)
   func getAllAlarms(_ resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
     resolve(AlarmStore.all().sorted { $0.timestamp < $1.timestamp }.map { $0.toDictionary() })
   }
-
+  
   @objc(isScheduled:resolve:reject:)
   func isScheduled(_ alarmId: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
     let a = AlarmStore.get(alarmId)