react-native-alarms 0.0.0-stage → 0.0.2

package/ios/alarm/AlarmData.swift

@@ -0,0 +1,97 @@
+import Foundation
+
+/// iOS mirror of the Android `AlarmData` model: same fields, same JS shape
+/// (`toDictionary()` == Android `toWritableMap()`), same `nextTrigger` rules.
+struct AlarmData: Codable {
+  var id: String
+  var timestamp: Double // ms since epoch
+  var title: String
+  var body: String
+  var sound: String
+  var vibrate: Bool
+  var snoozeEnabled: Bool
+  var snoozeMinutes: Int
+  var repeatType: String // none | daily | weekly | interval
+  var weekdays: [Int] // 1 = Sunday ... 7 = Saturday
+  var intervalMs: Double
+  var data: String
+  var enabled: Bool = true
+
+  static func now() -> Double { Date().timeIntervalSince1970 * 1000 }
+
+  var date: Date { Date(timeIntervalSince1970: timestamp / 1000) }
+
+  /// 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 }
+    switch repeatType {
+    case "daily":
+      return nextMatching(from: from) { _ in true }
+    case "weekly":
+      return nextMatching(from: from) { weekdays.isEmpty || weekdays.contains($0) }
+    case "interval":
+      if intervalMs <= 0 { return 0 }
+      if timestamp > from { return timestamp }
+      return timestamp + (floor((from - timestamp) / intervalMs) + 1) * intervalMs
+    default:
+      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)
+    var day = Date(timeIntervalSince1970: from / 1000)
+    for _ in 0..<8 {
+      var comps = cal.dateComponents([.year, .month, .day], from: day)
+      comps.hour = base.hour
+      comps.minute = base.minute
+      comps.second = 0
+      if let candidate = cal.date(from: comps) {
+        let ms = candidate.timeIntervalSince1970 * 1000
+        if ms > from && ok(cal.component(.weekday, from: candidate)) { return ms }
+      }
+      day = cal.date(byAdding: .day, value: 1, to: day) ?? day
+    }
+    return 0
+  }
+
+  // MARK: - JS bridge shape (same keys as Android)
+
+  func toDictionary() -> [String: Any] {
+    [
+      "alarmId": id,
+      "timestamp": timestamp,
+      "title": title,
+      "body": body,
+      "sound": sound,
+      "vibrate": vibrate,
+      "snoozeEnabled": snoozeEnabled,
+      "snoozeMinutes": snoozeMinutes,
+      "repeat": ["type": repeatType, "weekdays": weekdays, "intervalMs": intervalMs],
+      "data": data,
+      "enabled": enabled,
+      "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]
+    return AlarmData(
+      id: id,
+      timestamp: (m["timestamp"] as? NSNumber)?.doubleValue ?? 0,
+      title: m["title"] as? String ?? "",
+      body: m["body"] as? String ?? "",
+      sound: m["sound"] as? String ?? "default",
+      vibrate: (m["vibrate"] as? NSNumber)?.boolValue ?? true,
+      snoozeEnabled: (m["snoozeEnabled"] as? NSNumber)?.boolValue ?? true,
+      snoozeMinutes: (m["snoozeMinutes"] as? NSNumber)?.intValue ?? 5,
+      repeatType: r?["type"] as? String ?? "none",
+      weekdays: (r?["weekdays"] as? [NSNumber])?.map { $0.intValue } ?? [],
+      intervalMs: (r?["intervalMs"] as? NSNumber)?.doubleValue ?? 0,
+      data: m["data"] as? String ?? "",
+      enabled: true
+    )
+  }
+}

package/ios/alarm/AlarmKitBackend.swift

@@ -0,0 +1,212 @@
+import CryptoKit
+import Foundation
+import SwiftUI
+
+#if canImport(AlarmKit)
+import ActivityKit
+import AlarmKit
+
+/// Metadata type required by `AlarmAttributes`; extend it if you add a Live Activity widget.
+@available(iOS 26.0, *)
+struct RNAlarmMetadata: AlarmMetadata {}
+
+/// 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.
+@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
+  /// reports "snoozed" instead of "dismissed").
+  private var snoozing: Set<UUID> = []
+
+  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 {
+    case .authorized: return "granted"
+    case .denied: return "denied"
+    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 {
+    let key = snooze ? id + "_s" : id
+    if !snooze, let u = UUID(uuidString: key) { return u }
+    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
+    switch a.repeatType {
+    case "daily":
+      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] }
+      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>
+  {
+    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)
+    }
+
+    let attributes = AlarmAttributes<RNAlarmMetadata>(
+      presentation: AlarmPresentation(alert: alert, countdown: countdown),
+      metadata: RNAlarmMetadata(),
+      tintColor: .blue
+    )
+    let sound: AlertConfiguration.AlertSound =
+      (a.sound.isEmpty || a.sound == "default") ? .default : .named(a.sound)
+
+    return AlarmManager.AlarmConfiguration(
+      countdownDuration: duration,
+      schedule: schedule,
+      attributes: attributes,
+      sound: sound
+    )
+  }
+
+  func cancel(_ id: String) {
+    try? manager.cancel(id: Self.uuid(for: id))
+    try? manager.cancel(id: Self.uuid(for: id, snooze: true))
+  }
+
+  func cancelAll() {
+    for alarm in (try? manager.alarms) ?? [] { try? manager.cancel(id: alarm.id) }
+  }
+
+  func stop(_ id: String) {
+    try? manager.stop(id: Self.uuid(for: id))
+    try? manager.stop(id: Self.uuid(for: id, snooze: true))
+  }
+
+  /// 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) ?? []
+    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)
+      try? manager.stop(id: uuid)
+    }
+    let date = Date().addingTimeInterval(Double(max(1, minutes)) * 60)
+    _ = try await manager.schedule(
+      id: Self.uuid(for: a.id, snooze: true),
+      configuration: configuration(for: a, schedule: .fixed(date))
+    )
+    startObserving()
+  }
+
+  func ringingAlarm() -> AlarmData? {
+    guard let alerting = ((try? manager.alarms) ?? []).first(where: { $0.state == .alerting }) else {
+      return nil
+    }
+    return stored(for: alerting.id)
+  }
+
+  // MARK: - Events
+
+  /// Translates AlarmKit state changes into the Android-style events.
+  func startObserving() {
+    guard observer == nil else { return }
+    for alarm in (try? manager.alarms) ?? [] { lastStates[alarm.id] = alarm.state }
+    observer = Task { [weak self] in
+      for await alarms in AlarmManager.shared.alarmUpdates {
+        self?.handle(alarms)
+      }
+    }
+  }
+
+  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 {
+        onEvent?(AlarmModule.eventFired, a)
+      } else if lastStates[uuid] == .alerting {
+        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 {
+      guard let a = stored(for: uuid) else { continue }
+      if snoozing.remove(uuid) != nil {
+        onEvent?(AlarmModule.eventSnoozed, a)
+      } else {
+        onEvent?(AlarmModule.eventDismissed, a)
+        if a.repeatType == "interval" {
+          Task { try? await self.schedule(a) }
+        }
+      }
+    }
+
+    lastStates = states
+  }
+}
+#endif

package/ios/alarm/AlarmModule.m

@@ -0,0 +1,53 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+
+// Exposes the Swift `AlarmModule` to JS as `NativeModules.Alarm`, the same name
+// as Android's `AlarmModule.NAME`. Method names and signatures match Android.
+@interface RCT_EXTERN_REMAP_MODULE(Alarm, AlarmModule, RCTEventEmitter)
+
+// ---------- Permissions ----------
+RCT_EXTERN_METHOD(checkPermission:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(requestPermission:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(canScheduleExactAlarms:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(openAutoStartSettings:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+
+// ---------- Scheduling ----------
+RCT_EXTERN_METHOD(scheduleAlarm:(NSDictionary *)config
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(updateAlarm:(NSString *)alarmId
+                  config:(NSDictionary *)config
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(cancelAlarm:(NSString *)alarmId
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(cancelAllAlarms:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+
+// ---------- Control (while ringing) ----------
+RCT_EXTERN_METHOD(stopAlarm:(NSString *)alarmId
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(snoozeAlarm:(NSString *)alarmId
+                  minutes:(double)minutes
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(getRingingAlarm:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+
+// ---------- Queries ----------
+RCT_EXTERN_METHOD(getAlarm:(NSString *)alarmId
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(getAllAlarms:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(isScheduled:(NSString *)alarmId
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+
+@end

package/ios/alarm/AlarmModule.swift

@@ -0,0 +1,284 @@
+import Foundation
+import React
+import UIKit
+import UserNotifications
+
+/// iOS counterpart of the Android `AlarmModule`: same JS name (`Alarm`), same method
+/// names, same payload shapes and the same `onAlarmFired` / `onAlarmDismissed` /
+/// `onAlarmSnoozed` events, so JS code is shared between the platforms.
+///
+/// Backend: AlarmKit on iOS 26+ once the user grants alarm access (real alarms that
+/// ring through silent mode); local notifications everywhere else.
+@objc(AlarmModule)
+final class AlarmModule: RCTEventEmitter {
+  static let eventFired = "onAlarmFired"
+  static let eventDismissed = "onAlarmDismissed"
+  static let eventSnoozed = "onAlarmSnoozed"
+
+  private var hasListeners = false
+
+  override init() {
+    super.init()
+    NotificationBackend.install()
+    NotificationBackend.shared.onEvent = { [weak self] name, alarm in self?.emit(name, alarm) }
+    #if canImport(AlarmKit)
+    if #available(iOS 26.0, *) {
+      AlarmKitBackend.shared.onEvent = { [weak self] name, alarm in self?.emit(name, alarm) }
+      AlarmKitBackend.shared.startObserving()
+    }
+    #endif
+  }
+
+  @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: [
+      "alarmId": a.id,
+      "timestamp": AlarmData.now(),
+      "title": a.title,
+      "body": a.body,
+      "data": a.data,
+    ])
+  }
+
+  // MARK: - Backend selection
+
+  private var useAlarmKit: Bool {
+    #if canImport(AlarmKit)
+    if #available(iOS 26.0, *) { return AlarmKitBackend.shared.isAuthorized }
+    #endif
+    return false
+  }
+
+  private func cancelNative(_ id: String) {
+    NotificationBackend.shared.cancel(id)
+    #if canImport(AlarmKit)
+    if #available(iOS 26.0, *) { AlarmKitBackend.shared.cancel(id) }
+    #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 #available(iOS 26.0, *) {
+        status = AlarmKitBackend.shared.status
+        backend = "alarmkit"
+      }
+      #endif
+      done([
+        "status": status,
+        "notifications": status == "granted" || notifications == "granted",
+        "canScheduleExact": status == "granted",
+        "canDrawOverlays": true,
+        "canUseFullScreenIntent": true,
+        "backend": backend,
+      ])
+    }
+  }
+
+  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() {
+    if let url = URL(string: UIApplication.openSettingsURLString) {
+      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 #available(iOS 26.0, *) {
+        let kit = AlarmKitBackend.shared
+        if kit.status == "notDetermined" { _ = await kit.requestAuthorization() }
+        if kit.isAuthorized {
+          self.permissionMap { resolve($0) }
+          return
+        }
+        await self.openSettings()
+      }
+      #endif
+      // Notifications back the fallback path.
+      let notifications = await self.notificationStatus()
+      if notifications == "notDetermined" {
+        await self.requestNotifications()
+      } else if notifications == "denied" {
+        await self.openSettings()
+      }
+      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 #available(iOS 26.0, *), useAlarmKit {
+      Task {
+        do {
+          try await AlarmKitBackend.shared.schedule(alarm)
+          done()
+        } catch {
+          reject(code, error.localizedDescription, error)
+        }
+      }
+      return
+    }
+    #endif
+
+    NotificationBackend.shared.status { status in
+      guard status == "granted" else {
+        // Mirrors Android's SecurityException when the exact-alarm permission is missing.
+        return reject(code, "Alarm permission not granted; call requestPermission() first", nil)
+      }
+      NotificationBackend.shared.schedule(alarm) { error in
+        if let error { reject(code, error.localizedDescription, error) } else { done() }
+      }
+    }
+  }
+
+  @objc(cancelAlarm:resolve:reject:)
+  func cancelAlarm(_ alarmId: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+    let existed = AlarmStore.get(alarmId) != nil
+    cancelNative(alarmId)
+    AlarmStore.remove(alarmId)
+    resolve(existed)
+  }
+
+  @objc(cancelAllAlarms:reject:)
+  func cancelAllAlarms(_ resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+    AlarmStore.all().forEach { cancelNative($0.id) }
+    NotificationBackend.shared.cancelAll()
+    #if canImport(AlarmKit)
+    if #available(iOS 26.0, *) { AlarmKitBackend.shared.cancelAll() }
+    #endif
+    AlarmStore.clear()
+    resolve(nil)
+  }
+
+  // MARK: - Control (while ringing)
+
+  @objc(stopAlarm:resolve:reject:)
+  func stopAlarm(_ alarmId: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+    NotificationBackend.shared.stop(alarmId)
+    #if canImport(AlarmKit)
+    if #available(iOS 26.0, *) { AlarmKitBackend.shared.stop(alarmId) }
+    #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 {
+      return reject("E_NOT_FOUND", "Alarm \(alarmId) not found", nil)
+    }
+    let mins = minutes > 0 ? Int(minutes) : alarm.snoozeMinutes
+
+    #if canImport(AlarmKit)
+    if #available(iOS 26.0, *), useAlarmKit {
+      Task {
+        do {
+          try await AlarmKitBackend.shared.snooze(alarm, minutes: mins)
+          resolve(nil)
+        } catch {
+          reject("E_SNOOZE", error.localizedDescription, error)
+        }
+      }
+      return
+    }
+    #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 #available(iOS 26.0, *), ringing == nil { ringing = AlarmKitBackend.shared.ringingAlarm() }
+    #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)
+    resolve(a != nil && a!.enabled && a!.nextTrigger() > 0)
+  }
+}

package/ios/alarm/AlarmStore.swift

@@ -0,0 +1,51 @@
+import Foundation
+
+/// UserDefaults-backed persistence, the iOS counterpart of Android's `AlarmStore`.
+enum AlarmStore {
+  private static let key = "RNAlarm.alarms"
+  private static let lock = NSLock()
+
+  static func all() -> [AlarmData] {
+    lock.lock(); defer { lock.unlock() }
+    return Array(load().values)
+  }
+
+  static func get(_ id: String) -> AlarmData? {
+    lock.lock(); defer { lock.unlock() }
+    return load()[id]
+  }
+
+  static func save(_ alarm: AlarmData) {
+    lock.lock(); defer { lock.unlock() }
+    var map = load()
+    map[alarm.id] = alarm
+    persist(map)
+  }
+
+  static func remove(_ id: String) {
+    lock.lock(); defer { lock.unlock() }
+    var map = load()
+    map.removeValue(forKey: id)
+    persist(map)
+  }
+
+  static func clear() {
+    lock.lock(); defer { lock.unlock() }
+    persist([:])
+  }
+
+  // MARK: - Private
+
+  private static func load() -> [String: AlarmData] {
+    guard let data = UserDefaults.standard.data(forKey: key),
+          let map = try? JSONDecoder().decode([String: AlarmData].self, from: data)
+    else { return [:] }
+    return map
+  }
+
+  private static func persist(_ map: [String: AlarmData]) {
+    if let data = try? JSONEncoder().encode(map) {
+      UserDefaults.standard.set(data, forKey: key)
+    }
+  }
+}