react-native-alarms 0.0.4 → 0.0.5

package/ios/alarm/AlarmKitBackend.swift

@@ -5,11 +5,34 @@ import SwiftUI
 #if canImport(AlarmKit)
 import ActivityKit
 import AlarmKit
+import AppIntents
 
 /// Metadata type required by `AlarmAttributes`; extend it if you add a Live Activity widget.
 @available(iOS 26.0, *)
 struct RNAlarmMetadata: AlarmMetadata {}
 
+/// Backs the "Open" button on the AlarmKit alert. An AlarmKit alert ignores taps on
+/// its body, so this intent (run in the app process, `openAppWhenRun`) is the only
+/// way the alert can open the app and show the React ring screen.
+@available(iOS 26.0, *)
+struct OpenAlarmAppIntent: LiveActivityIntent {
+  static let title: LocalizedStringResource = "Open Alarm"
+  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()
+  }
+}
+
 /// Real alarms on iOS 26+: ring through silent mode and Focus with the system alarm UI.
 /// Only compiled with an SDK that ships AlarmKit (Xcode 26+); older toolchains build
 /// the app with the notification fallback only.
@@ -26,6 +49,10 @@ final class AlarmKitBackend {
   /// Alarms we are stopping as part of a programmatic snooze (so the observer
   /// reports "snoozed" instead of "dismissed").
   private var snoozing: Set<UUID> = []
+  /// Alarms stopped only to silence the system sound while the in-app ring screen
+  /// (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,
@@ -98,23 +125,16 @@ final class AlarmKitBackend {
   {
     let title = LocalizedStringResource(stringLiteral: a.title.isEmpty ? "Alarm" : a.title)
     let stop = AlarmButton(text: "Stop", textColor: .white, systemImageName: "stop.fill")
-
-    let alert: AlarmPresentation.Alert
-    var countdown: AlarmPresentation.Countdown?
-    var duration: Alarm.CountdownDuration?
-    if a.snoozeEnabled {
-      let snooze = AlarmButton(text: "Snooze", textColor: .white, systemImageName: "zzz")
-      alert = AlarmPresentation.Alert(
-        title: title, stopButton: stop, secondaryButton: snooze, secondaryButtonBehavior: .countdown
-      )
-      countdown = AlarmPresentation.Countdown(title: "Snoozed", pauseButton: nil)
-      duration = Alarm.CountdownDuration(preAlert: nil, postAlert: Double(max(1, a.snoozeMinutes)) * 60)
-    } else {
-      alert = AlarmPresentation.Alert(title: title, stopButton: stop)
-    }
+    // The alert's body ignores taps and it allows a single secondary button, so it
+    // must be "Open" (via OpenAlarmAppIntent): the React ring screen it opens has
+    // its own Snooze/Finish. The system countdown-snooze button is dropped for it.
+    let open = AlarmButton(text: "Open", textColor: .white, systemImageName: "arrow.up.forward.app")
+    let alert = AlarmPresentation.Alert(
+      title: title, stopButton: stop, secondaryButton: open, secondaryButtonBehavior: .custom
+    )
 
     let attributes = AlarmAttributes<RNAlarmMetadata>(
-      presentation: AlarmPresentation(alert: alert, countdown: countdown),
+      presentation: AlarmPresentation(alert: alert),
       metadata: RNAlarmMetadata(),
       tintColor: .blue
     )
@@ -122,16 +142,18 @@ final class AlarmKitBackend {
       (a.sound.isEmpty || a.sound == "default") ? .default : .named(a.sound)
 
     return AlarmManager.AlarmConfiguration(
-      countdownDuration: duration,
       schedule: schedule,
       attributes: attributes,
+      secondaryIntent: OpenAlarmAppIntent(alarmID: a.id),
       sound: sound
     )
   }
 
   func cancel(_ id: String) {
-    try? manager.cancel(id: Self.uuid(for: id))
-    try? manager.cancel(id: Self.uuid(for: id, snooze: true))
+    for uuid in [Self.uuid(for: id), Self.uuid(for: id, snooze: true)] {
+      try? manager.cancel(id: uuid)
+      silenced.removeValue(forKey: uuid)
+    }
   }
 
   func cancelAll() {
@@ -139,19 +161,60 @@ final class AlarmKitBackend {
   }
 
   func stop(_ id: String) {
-    try? manager.stop(id: Self.uuid(for: id))
-    try? manager.stop(id: Self.uuid(for: id, snooze: true))
+    for uuid in [Self.uuid(for: id), Self.uuid(for: id, snooze: true)] {
+      try? manager.stop(id: uuid)
+      // Ended a session we had silenced earlier: the observer saw nothing change,
+      // so report the dismissal (and re-arm intervals) here instead.
+      if let a = silenced.removeValue(forKey: uuid) {
+        onEvent?(AlarmModule.eventDismissed, a)
+        if a.repeatType == "interval" { Task { try? await self.schedule(a) } }
+      }
+    }
   }
 
-  /// 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 {
+  /// "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.
+  func openFromAlert(_ id: String) {
+    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 }) {
-      snoozing.insert(uuid)
+      silenced[uuid] = a
+      try? manager.stop(id: uuid)
+    }
+    // The system may have stopped it before we ran; the session is still ours.
+    if !silenced.values.contains(where: { $0.id == a.id }) {
+      silenced[Self.uuid(for: a.id)] = a
+    }
+    DispatchQueue.main.async { AlarmRingPresenter.present(a, bridge: nil) }
+  }
+
+  /// 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 }) {
+      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 {
+    let current = (try? manager.alarms) ?? []
+    var wasSilenced = false
+    for uuid in [Self.uuid(for: a.id), Self.uuid(for: a.id, snooze: true)] {
+      if silenced.removeValue(forKey: uuid) != nil { wasSilenced = true }
+      if current.contains(where: { $0.id == uuid && $0.state == .alerting }) {
+        snoozing.insert(uuid)
+        try? manager.stop(id: uuid)
+      }
+    }
+    // Snoozed a session we had silenced: the observer saw nothing change, report it here.
+    if wasSilenced { onEvent?(AlarmModule.eventSnoozed, a) }
     let date = Date().addingTimeInterval(Double(max(1, minutes)) * 60)
     _ = try await manager.schedule(
       id: Self.uuid(for: a.id, snooze: true),
@@ -161,10 +224,11 @@ final class AlarmKitBackend {
   }
 
   func ringingAlarm() -> AlarmData? {
-    guard let alerting = ((try? manager.alarms) ?? []).first(where: { $0.state == .alerting }) else {
-      return nil
+    if let alerting = ((try? manager.alarms) ?? []).first(where: { $0.state == .alerting }) {
+      return stored(for: alerting.id)
     }
-    return stored(for: alerting.id)
+    // Sound silenced for the in-app ring screen, but the session is still live.
+    return silenced.values.first
   }
 
   // MARK: - Events
@@ -187,14 +251,17 @@ final class AlarmKitBackend {
     for (uuid, state) in states where lastStates[uuid] != state {
       guard let a = stored(for: uuid) else { continue }
       if state == .alerting {
+        silenced.removeValue(forKey: uuid) // ringing again supersedes any old silence
         onEvent?(AlarmModule.eventFired, a)
       } else if lastStates[uuid] == .alerting {
+        if silenced[uuid] != nil { continue } // silenced for the ring screen, not over yet
         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
       guard let a = stored(for: uuid) else { continue }
       if snoozing.remove(uuid) != nil {
         onEvent?(AlarmModule.eventSnoozed, a)

package/ios/alarm/AlarmModule.swift

@@ -16,6 +16,7 @@ final class AlarmModule: RCTEventEmitter {
   static let eventSnoozed = "onAlarmSnoozed"
 
   private var hasListeners = false
+  private var activeObserver: NSObjectProtocol?
 
   override init() {
     super.init()
@@ -27,10 +28,26 @@ final class AlarmModule: RCTEventEmitter {
       AlarmKitBackend.shared.startObserving()
     }
     #endif
-    // App launched by tapping the alarm notification before this module existed.
-    if let ringing = NotificationBackend.shared.ringing {
-      DispatchQueue.main.async { [weak self] in AlarmRingPresenter.present(ringing, bridge: self?.bridge) }
-    }
+    // 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
+    // foregrounds the app without any delegate callback, so also check on activation.
+    activeObserver = NotificationCenter.default.addObserver(
+      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 #available(iOS 26.0, *), ringing == nil { ringing = AlarmKitBackend.shared.ringingAlarm() }
+    #endif
+    if let ringing { AlarmRingPresenter.present(ringing, bridge: bridge) }
   }
 
   private func handle(_ name: String, _ alarm: AlarmData) {

package/ios/alarm/AlarmRingPresenter.swift

@@ -15,12 +15,17 @@ final class AlarmRingPresenter {
 
   static func present(_ alarm: AlarmData, bridge: RCTBridge?, attempt: Int = 0) {
     DispatchQueue.main.async {
-      if controller != nil, alarmId == alarm.id { return }
-      // Cold start from a notification tap: the root surface or window may not be
-      // ready yet, so retry briefly.
+      if controller != nil, alarmId == alarm.id {
+        // Already showing (e.g. presented while backgrounded, now foregrounded):
+        // still make sure the native sound yields to the screen's own TTS.
+        silenceIfActive(alarm.id)
+        return
+      }
+      // Cold start from a notification tap or the AlarmKit "Open" button: the root
+      // surface or window may not be ready yet, so retry for up to ~15 s.
       guard let surface = makeSurface(bridge, props: alarm.toDictionary()),
             let top = topViewController() else {
-        if attempt < 20 {
+        if attempt < 60 {
           DispatchQueue.main.asyncAfter(deadline: .now() + 0.25) {
             present(alarm, bridge: bridge, attempt: attempt + 1)
           }
@@ -42,6 +47,7 @@ final class AlarmRingPresenter {
         top.present(vc, animated: true)
         controller = vc
         alarmId = alarm.id
+        silenceIfActive(alarm.id)
       }
       if let existing = controller {
         existing.dismiss(animated: false, completion: show)
@@ -51,6 +57,18 @@ final class AlarmRingPresenter {
     }
   }
 
+  /// The ring screen speaks the task via TTS, and iOS won't play it over the
+  /// notification / AlarmKit sound, so stop that sound once the screen is up.
+  /// Only while the app is frontmost: in the background the system alert is the
+  /// only thing the user can hear, so it must keep ringing.
+  private static func silenceIfActive(_ id: String) {
+    guard UIApplication.shared.applicationState == .active else { return }
+    NotificationBackend.shared.silence(id)
+    #if canImport(AlarmKit)
+    if #available(iOS 26.0, *) { AlarmKitBackend.shared.silence(id) }
+    #endif
+  }
+
   /// Called when ringing ends for any reason (stop, snooze, cancel).
   static func dismiss(_ id: String? = nil) {
     DispatchQueue.main.async {

package/ios/alarm/NotificationBackend.swift

@@ -169,6 +169,12 @@ final class NotificationBackend: NSObject, UNUserNotificationCenterDelegate {
     if ringing?.id == a.id { ringing = nil }
   }
 
+  /// Stops the notification's sound (by clearing the delivered notification) while the
+  /// in-app ring screen takes over; `ringing` stays set so the session is still live.
+  func silence(_ id: String) {
+    center.removeDeliveredNotifications(withIdentifiers: ids(for: id))
+  }
+
   func cancel(_ id: String) {
     center.removePendingNotificationRequests(withIdentifiers: ids(for: id))
     center.removeDeliveredNotifications(withIdentifiers: ids(for: id))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-alarms",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "description": "A powerful, cross-platform alarm management library for React Native",
   "private": false,
   "main": "index.ts",