react-native-alarms 0.0.3 → 0.0.5

package/README.md

@@ -45,7 +45,33 @@ Since this is a native module, you'll need to link it:
 cd ios && pod install && cd ..
 ```
 
-For Android, the native code should auto-link.
+For Android, the native code auto-links, including the permissions, ring activity,
+service and receivers in its manifest. No `MainApplication` or `AndroidManifest.xml`
+changes are needed. Rebuild the app after installing.
+
+### Register the ring screen
+
+When an alarm rings, both platforms show a full-screen React component registered as
+`AlarmRing`, with the alarm (`alarmId`, `title`, `body`, `snoozeEnabled`,
+`snoozeMinutes`, `data`) as props. Register your own component in `index.js`:
+
+```js
+import { AppRegistry } from 'react-native';
+import { AlarmRingScreen } from './src/AlarmRingScreen';
+
+AppRegistry.registerComponent('AlarmRing', () => AlarmRingScreen);
+```
+
+Call `Alarm.stopAlarm(alarmId)` or `Alarm.snoozeAlarm(alarmId, minutes)` from its
+buttons; the screen closes itself.
+
+### Direct module access
+
+```ts
+import Alarm, { AlarmService } from 'react-native-alarms';
+
+const id = await Alarm.scheduleAlarm({ timestamp: Date.now() + 60_000, title: 'Wake up' });
+```
 
 ## Quick Start
 

package/android-lib/build.gradle

@@ -0,0 +1,36 @@
+// Library module autolinked into consumer apps (see react-native.config.js).
+// Sources stay in the example app's tree; this module only references them.
+apply plugin: "com.android.library"
+apply plugin: "org.jetbrains.kotlin.android"
+
+def safeExtGet(prop, fallback) {
+  rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+}
+
+android {
+  namespace "com.reactnativealarms"
+  compileSdk safeExtGet("compileSdkVersion", 35)
+
+  defaultConfig {
+    minSdkVersion safeExtGet("minSdkVersion", 24)
+    targetSdkVersion safeExtGet("targetSdkVersion", 35)
+  }
+
+  sourceSets {
+    main {
+      manifest.srcFile "src/main/AndroidManifest.xml"
+      java.srcDirs = ["src/main/java", "../android/app/src/main/java/com/reactnativealarm/alarm"]
+      res.srcDirs = ["src/main/res"]
+    }
+  }
+}
+
+repositories {
+  google()
+  mavenCentral()
+}
+
+dependencies {
+  implementation "com.facebook.react:react-android"
+  implementation "androidx.appcompat:appcompat:1.7.0"
+}

package/android-lib/src/main/AndroidManifest.xml

@@ -0,0 +1,49 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
+    <uses-permission android:name="android.permission.USE_EXACT_ALARM" />
+    <uses-permission
+        android:name="android.permission.SCHEDULE_EXACT_ALARM"
+        android:maxSdkVersion="32" />
+    <uses-permission android:name="android.permission.WAKE_LOCK" />
+    <uses-permission android:name="android.permission.VIBRATE" />
+    <uses-permission android:name="android.permission.USE_FULL_SCREEN_INTENT" />
+    <uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW" />
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_MEDIA_PLAYBACK" />
+    <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
+
+    <application>
+      <activity
+        android:name="com.alarm.AlarmRingActivity"
+        android:configChanges="keyboard|keyboardHidden|orientation|screenLayout|screenSize|smallestScreenSize|uiMode"
+        android:excludeFromRecents="true"
+        android:exported="false"
+        android:launchMode="singleInstance"
+        android:showWhenLocked="true"
+        android:taskAffinity=""
+        android:theme="@style/RNAlarmRingTheme"
+        android:turnScreenOn="true" />
+
+      <service
+        android:name="com.alarm.AlarmService"
+        android:exported="false"
+        android:foregroundServiceType="mediaPlayback" />
+
+      <receiver
+        android:name="com.alarm.AlarmReceiver"
+        android:exported="false" />
+
+      <receiver
+        android:name="com.alarm.BootReceiver"
+        android:enabled="true"
+        android:exported="true">
+        <intent-filter>
+          <action android:name="android.intent.action.BOOT_COMPLETED" />
+          <action android:name="android.intent.action.MY_PACKAGE_REPLACED" />
+          <action android:name="android.intent.action.TIME_SET" />
+          <action android:name="android.intent.action.TIMEZONE_CHANGED" />
+        </intent-filter>
+      </receiver>
+    </application>
+</manifest>

package/android-lib/src/main/java/com/reactnativealarms/RNAlarmsPackage.kt

@@ -0,0 +1,18 @@
+package com.reactnativealarms
+
+import com.alarm.AlarmPackage
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfoProvider
+
+// Autolinking entry point: the RN CLI only detects ReactPackage classes located inside
+// android-lib/, while the real implementation lives in the example app's source tree.
+class RNAlarmsPackage : BaseReactPackage() {
+  private val impl = AlarmPackage()
+
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? =
+    impl.getModule(name, reactContext)
+
+  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider = impl.getReactModuleInfoProvider()
+}

package/android-lib/src/main/res/values/styles.xml

@@ -0,0 +1,3 @@
+<resources>
+    <style name="RNAlarmRingTheme" parent="Theme.AppCompat.DayNight.NoActionBar" />
+</resources>

package/index.d.ts

@@ -3,6 +3,8 @@
  * Cross-platform alarm management for React Native
  */
 
+import type { Spec } from './specs/NativeAlarm';
+
 export type {
   AlarmRepeat,
   AlarmConfig,
@@ -12,5 +14,7 @@ export type {
   Spec as AlarmModuleSpec,
 } from './specs/NativeAlarm';
 
-// Default export for type compatibility
-export type { Spec as default } from './specs/NativeAlarm';
+export { AlarmService } from './AlarmService';
+
+declare const Alarm: Spec;
+export default Alarm;

package/index.ts

@@ -14,6 +14,7 @@ export type {
   Spec as AlarmModuleSpec,
 } from './specs/NativeAlarm';
 
-// Default export for backward compatibility
+export { AlarmService } from './AlarmService';
+
 import NativeAlarm from './specs/NativeAlarm';
 export default NativeAlarm;

package/ios/ReactNativeAlarm.xcodeproj/project.pbxproj

@@ -18,6 +18,7 @@
 		7A1A000000000000000B0004 /* AlarmStore.swift in Sources */ = {isa = PBXBuildFile; fileRef = 7A1A000000000000000A0004 /* AlarmStore.swift */; };
 		7A1A000000000000000B0005 /* AlarmKitBackend.swift in Sources */ = {isa = PBXBuildFile; fileRef = 7A1A000000000000000A0005 /* AlarmKitBackend.swift */; };
 		7A1A000000000000000B0006 /* NotificationBackend.swift in Sources */ = {isa = PBXBuildFile; fileRef = 7A1A000000000000000A0006 /* NotificationBackend.swift */; };
+		7A1A000000000000000B0007 /* AlarmRingPresenter.swift in Sources */ = {isa = PBXBuildFile; fileRef = 7A1A000000000000000A0007 /* AlarmRingPresenter.swift */; };
 		81AB9BB82411601600AC10FF /* LaunchScreen.storyboard in Resources */ = {isa = PBXBuildFile; fileRef = 81AB9BB72411601600AC10FF /* LaunchScreen.storyboard */; };
 /* End PBXBuildFile section */
 
@@ -37,6 +38,7 @@
 		7A1A000000000000000A0004 /* AlarmStore.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = AlarmStore.swift; sourceTree = "<group>"; };
 		7A1A000000000000000A0005 /* AlarmKitBackend.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = AlarmKitBackend.swift; sourceTree = "<group>"; };
 		7A1A000000000000000A0006 /* NotificationBackend.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = NotificationBackend.swift; sourceTree = "<group>"; };
+		7A1A000000000000000A0007 /* AlarmRingPresenter.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = AlarmRingPresenter.swift; sourceTree = "<group>"; };
 		81AB9BB72411601600AC10FF /* LaunchScreen.storyboard */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = file.storyboard; name = LaunchScreen.storyboard; path = ReactNativeAlarm/LaunchScreen.storyboard; sourceTree = "<group>"; };
 		ED297162215061F000B7C4FE /* JavaScriptCore.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = JavaScriptCore.framework; path = System/Library/Frameworks/JavaScriptCore.framework; sourceTree = SDKROOT; };
 /* End PBXFileReference section */
@@ -84,6 +86,7 @@
 				7A1A000000000000000A0004 /* AlarmStore.swift */,
 				7A1A000000000000000A0005 /* AlarmKitBackend.swift */,
 				7A1A000000000000000A0006 /* NotificationBackend.swift */,
+				7A1A000000000000000A0007 /* AlarmRingPresenter.swift */,
 			);
 			path = alarm;
 			sourceTree = "<group>";
@@ -283,6 +286,7 @@
 				7A1A000000000000000B0004 /* AlarmStore.swift in Sources */,
 				7A1A000000000000000B0005 /* AlarmKitBackend.swift in Sources */,
 				7A1A000000000000000B0006 /* NotificationBackend.swift in Sources */,
+				7A1A000000000000000B0007 /* AlarmRingPresenter.swift in Sources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};

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.m

@@ -1,5 +1,30 @@
 #import <React/RCTBridgeModule.h>
 #import <React/RCTEventEmitter.h>
+#import <UIKit/UIKit.h>
+
+// The notification delegate must be set before launch finishes, or a tap on an alarm
+// notification that launches the app is lost. JS creates the module lazily, so install
+// it here instead of requiring an AppDelegate change in every app.
+@interface RNAlarmBootstrap : NSObject
+@end
+
+@implementation RNAlarmBootstrap
+
++ (void)load
+{
+  [[NSNotificationCenter defaultCenter] addObserverForName:UIApplicationDidFinishLaunchingNotification
+                                                    object:nil
+                                                     queue:nil
+                                                usingBlock:^(NSNotification *note) {
+    Class backend = NSClassFromString(@"RNAlarmNotificationBackend");
+    SEL install = NSSelectorFromString(@"install");
+    if ([backend respondsToSelector:install]) {
+      ((void (*)(id, SEL))[backend methodForSelector:install])(backend, install);
+    }
+  }];
+}
+
+@end
 
 // Exposes the Swift `AlarmModule` to JS as `NativeModules.Alarm`, the same name
 // as Android's `AlarmModule.NAME`. Method names and signatures match Android.

package/ios/alarm/AlarmModule.swift

@@ -16,17 +16,47 @@ final class AlarmModule: RCTEventEmitter {
   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?.emit(name, alarm) }
+    NotificationBackend.shared.onEvent = { [weak self] name, alarm in self?.handle(name, alarm) }
     #if canImport(AlarmKit)
     if #available(iOS 26.0, *) {
-      AlarmKitBackend.shared.onEvent = { [weak self] name, alarm in self?.emit(name, alarm) }
+      AlarmKitBackend.shared.onEvent = { [weak self] name, alarm in self?.handle(name, alarm) }
       AlarmKitBackend.shared.startObserving()
     }
     #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
+    // 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) {
+    if name == Self.eventFired {
+      AlarmRingPresenter.present(alarm, bridge: bridge)
+    } else {
+      AlarmRingPresenter.dismiss(alarm.id)
+    }
+    emit(name, alarm)
   }
 
   @objc override static func requiresMainQueueSetup() -> Bool { false }
@@ -61,6 +91,7 @@ final class AlarmModule: RCTEventEmitter {
   }
 
   private func cancelNative(_ id: String) {
+    AlarmRingPresenter.dismiss(id)
     NotificationBackend.shared.cancel(id)
     #if canImport(AlarmKit)
     if #available(iOS 26.0, *) { AlarmKitBackend.shared.cancel(id) }
@@ -207,6 +238,7 @@ final class AlarmModule: RCTEventEmitter {
 
   @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)
@@ -220,6 +252,7 @@ final class AlarmModule: RCTEventEmitter {
 
   @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 #available(iOS 26.0, *) { AlarmKitBackend.shared.stop(alarmId) }
@@ -233,6 +266,7 @@ final class AlarmModule: RCTEventEmitter {
       return reject("E_NOT_FOUND", "Alarm \(alarmId) not found", nil)
     }
     let mins = minutes > 0 ? Int(minutes) : alarm.snoozeMinutes
+    AlarmRingPresenter.dismiss(alarmId)
 
     #if canImport(AlarmKit)
     if #available(iOS 26.0, *), useAlarmKit {

package/ios/alarm/AlarmRingPresenter.swift

@@ -0,0 +1,126 @@
+import React
+import UIKit
+
+/// iOS counterpart of Android's `AlarmRingActivity`: presents the React component
+/// registered as `AlarmRing` full screen, with the ringing alarm as initial props.
+///
+/// iOS cannot launch an app or draw over the lock screen from a local notification,
+/// so this shows when the alarm fires while the app is in the foreground, or when the
+/// user opens the app by tapping the alarm notification.
+final class AlarmRingPresenter {
+  static let componentName = "AlarmRing"
+
+  private static weak var controller: UIViewController?
+  private static var alarmId: String?
+
+  static func present(_ alarm: AlarmData, bridge: RCTBridge?, attempt: Int = 0) {
+    DispatchQueue.main.async {
+      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 < 60 {
+          DispatchQueue.main.asyncAfter(deadline: .now() + 0.25) {
+            present(alarm, bridge: bridge, attempt: attempt + 1)
+          }
+        } else {
+          NSLog("[react-native-alarms] Could not present %@: no surface presenter or window", componentName)
+        }
+        return
+      }
+
+      let vc = UIViewController()
+      let root = RCTSurfaceHostingProxyRootView(surface: surface)
+      root.backgroundColor = .systemBackground
+      vc.view = root
+      surface.start()
+      vc.modalPresentationStyle = .fullScreen
+      vc.isModalInPresentation = true
+
+      let show = {
+        top.present(vc, animated: true)
+        controller = vc
+        alarmId = alarm.id
+        silenceIfActive(alarm.id)
+      }
+      if let existing = controller {
+        existing.dismiss(animated: false, completion: show)
+      } else {
+        show()
+      }
+    }
+  }
+
+  /// 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 {
+      guard let vc = controller, id == nil || id == alarmId else { return }
+      controller = nil
+      alarmId = nil
+      vc.dismiss(animated: true)
+    }
+  }
+
+  private static let createSurface = NSSelectorFromString("createFabricSurfaceForModuleName:initialProperties:")
+
+  /// `RCTSurfacePresenter` implements `createFabricSurfaceForModuleName:initialProperties:`
+  /// without formally adopting `RCTSurfacePresenterStub`, and its header is ObjC++ (not
+  /// importable from Swift), so call it by selector.
+  private static func makeSurface(_ bridge: RCTBridge?, props: [String: Any]) -> RCTSurfaceProtocol? {
+    guard let presenter = surfacePresenter(bridge), presenter.responds(to: createSurface) else { return nil }
+    return presenter.perform(createSurface, with: componentName, with: props)?
+      .takeUnretainedValue() as? RCTSurfaceProtocol
+  }
+
+  /// Bridgeless mode skips `bridge.surfacePresenter` (and injection) for modules
+  /// registered with `RCT_EXTERN_MODULE`, so fall back to the presenter of the app's
+  /// root React surface, which `RCTFabricSurface` keeps in a weak `_surfacePresenter` ivar.
+  private static func surfacePresenter(_ bridge: RCTBridge?) -> NSObject? {
+    if let p = bridge?.surfacePresenter() as? NSObject { return p }
+    guard let root = keyWindow()?.rootViewController?.view,
+          let hosting = findHostingView(in: root),
+          let surface = hosting.surface as AnyObject?,
+          let ivar = class_getInstanceVariable(type(of: surface), "_surfacePresenter")
+    else { return nil }
+    return object_getIvar(surface, ivar) as? NSObject
+  }
+
+  private static func findHostingView(in view: UIView) -> RCTSurfaceHostingView? {
+    if let hosting = view as? RCTSurfaceHostingView { return hosting }
+    for sub in view.subviews {
+      if let hosting = findHostingView(in: sub) { return hosting }
+    }
+    return nil
+  }
+
+  private static func keyWindow() -> UIWindow? {
+    UIApplication.shared.connectedScenes
+      .compactMap { $0 as? UIWindowScene }
+      .flatMap { $0.windows }
+      .first { $0.isKeyWindow }
+  }
+
+  private static func topViewController() -> UIViewController? {
+    var top = keyWindow()?.rootViewController
+    while let presented = top?.presentedViewController { top = presented }
+    return top
+  }
+}