react-native-alarms 0.0.3 → 0.0.4

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

@@ -20,13 +20,26 @@ final class AlarmModule: RCTEventEmitter {
   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 before this module existed.
+    if let ringing = NotificationBackend.shared.ringing {
+      DispatchQueue.main.async { [weak self] in AlarmRingPresenter.present(ringing, bridge: self?.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 +74,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 +221,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 +235,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 +249,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,108 @@
+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 { return }
+      // Cold start from a notification tap: the root surface or window may not be
+      // ready yet, so retry briefly.
+      guard let surface = makeSurface(bridge, props: alarm.toDictionary()),
+            let top = topViewController() else {
+        if attempt < 20 {
+          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
+      }
+      if let existing = controller {
+        existing.dismiss(animated: false, completion: show)
+      } else {
+        show()
+      }
+    }
+  }
+
+  /// 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
+  }
+}

package/ios/alarm/NotificationBackend.swift

@@ -7,6 +7,7 @@ import UserNotifications
 /// Limitations compared with a real alarm: sound plays for at most ~30 s, the
 /// silent switch and Focus modes are respected, and `interval` repeats are
 /// pre-scheduled as a batch of exact one-off notifications (see `schedule`).
+@objc(RNAlarmNotificationBackend)
 final class NotificationBackend: NSObject, UNUserNotificationCenterDelegate {
   static let shared = NotificationBackend()
 
@@ -24,11 +25,23 @@ final class NotificationBackend: NSObject, UNUserNotificationCenterDelegate {
   /// Wired by `AlarmModule` so native events reach JS.
   var onEvent: ((String, AlarmData) -> Void)?
 
+  /// Delegate that was installed before us (e.g. Notifee); non-alarm notifications go to it.
+  private weak var previousDelegate: UNUserNotificationCenterDelegate?
+  private static var installed = false
+
   /// Installs the delegate and actions. Call once at launch so a tap on a
   /// notification that starts the app is delivered to the module.
-  static func install() {
+  @objc static func install() {
     let center = UNUserNotificationCenter.current()
-    if center.delegate == nil { center.delegate = shared }
+    // Only once: a library that took over after us forwards to us, and taking the
+    // delegate back would make the two forward to each other forever.
+    if !installed {
+      installed = true
+      if center.delegate !== shared {
+        shared.previousDelegate = center.delegate
+        center.delegate = shared
+      }
+    }
     let snooze = UNNotificationAction(identifier: actionSnooze, title: "Snooze", options: [])
     let stop = UNNotificationAction(identifier: actionStop, title: "Stop", options: [.destructive])
     center.setNotificationCategories([
@@ -196,11 +209,19 @@ final class NotificationBackend: NSObject, UNUserNotificationCenterDelegate {
     willPresent notification: UNNotification,
     withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void
   ) {
-    if let a = alarm(from: notification) {
-      ringing = a
-      onEvent?(AlarmModule.eventFired, a)
+    guard let a = alarm(from: notification) else {
+      if let previous = previousDelegate,
+         previous.responds(to: #selector(UNUserNotificationCenterDelegate.userNotificationCenter(_:willPresent:withCompletionHandler:))) {
+        previous.userNotificationCenter?(center, willPresent: notification, withCompletionHandler: completionHandler)
+      } else {
+        completionHandler([.banner, .list, .sound])
+      }
+      return
     }
-    completionHandler([.banner, .list, .sound])
+    ringing = a
+    onEvent?(AlarmModule.eventFired, a)
+    // The ring screen takes over; keep the sound but skip the banner when it can show.
+    completionHandler(onEvent == nil ? [.banner, .list, .sound] : [.list, .sound])
   }
 
   func userNotificationCenter(
@@ -208,8 +229,16 @@ final class NotificationBackend: NSObject, UNUserNotificationCenterDelegate {
     didReceive response: UNNotificationResponse,
     withCompletionHandler completionHandler: @escaping () -> Void
   ) {
+    guard let a = alarm(from: response.notification) else {
+      if let previous = previousDelegate,
+         previous.responds(to: #selector(UNUserNotificationCenterDelegate.userNotificationCenter(_:didReceive:withCompletionHandler:))) {
+        previous.userNotificationCenter?(center, didReceive: response, withCompletionHandler: completionHandler)
+      } else {
+        completionHandler()
+      }
+      return
+    }
     defer { completionHandler() }
-    guard let a = alarm(from: response.notification) else { return }
     switch response.actionIdentifier {
     case Self.actionSnooze:
       snooze(a, minutes: a.snoozeMinutes)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-alarms",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "description": "A powerful, cross-platform alarm management library for React Native",
   "private": false,
   "main": "index.ts",
@@ -13,7 +13,8 @@
     "./service": {
       "types": "./AlarmService.d.ts",
       "default": "./AlarmService.ts"
-    }
+    },
+    "./package.json": "./package.json"
   },
   "scripts": {
     "android": "react-native run-android",
@@ -45,13 +46,10 @@
   },
   "license": "MIT",
   "peerDependencies": {
-    "react": ">=18.0.0",
-    "react-native": ">=0.70.0"
+    "react": "*",
+    "react-native": "*"
   },
   "dependencies": {
-    "react": "19.3.0",
-    "react-native": "0.88.0",
-    "@react-native/new-app-screen": "0.88.0",
     "react-native-safe-area-context": "^5.5.2"
   },
   "devDependencies": {
@@ -72,23 +70,12 @@
     "eslint": "^8.19.0",
     "jest": "^29.6.3",
     "prettier": "2.8.8",
+    "react": "19.3.0",
+    "react-native": "0.88.0",
     "react-test-renderer": "19.3.0",
     "typescript": "^6.0.3"
   },
   "engines": {
     "node": ">= 22.11.0"
-  },
-  "codegenConfig": {
-    "name": "RNAlarmSpec",
-    "type": "modules",
-    "jsSrcsDir": "specs",
-    "android": {
-      "javaPackageName": "com.reactnativealarm.alarm"
-    },
-    "ios": {
-      "modulesProvider": {
-        "Alarm": "Alarm"
-      }
-    }
   }
 }

package/react-native-alarms.podspec

@@ -0,0 +1,20 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name         = 'react-native-alarms'
+  s.version      = package['version']
+  s.summary      = package['description']
+  s.license      = package['license']
+  s.authors      = package['author']['name']
+  s.homepage     = package['repository']['url']
+  s.source       = { :git => package['repository']['url'], :tag => "v#{s.version}" }
+
+  s.platforms    = { :ios => '15.0' }
+  s.swift_version = '5.9'
+  s.source_files = 'ios/alarm/**/*.{h,m,mm,swift}'
+  s.frameworks   = 'UserNotifications', 'UIKit'
+
+  install_modules_dependencies(s)
+end

package/react-native.config.js

@@ -0,0 +1,16 @@
+// Autolinking config for apps that install this package. The root android/ folder is
+// the example app, so Android points at android-lib/ instead.
+module.exports = {
+  dependency: {
+    platforms: {
+      android: {
+        sourceDir: './android-lib',
+        packageImportPath: 'import com.reactnativealarms.RNAlarmsPackage;',
+        packageInstance: 'new RNAlarmsPackage()',
+      },
+      ios: {
+        podspecPath: './react-native-alarms.podspec',
+      },
+    },
+  },
+};

package/specs/NativeAlarm.ts

@@ -1,5 +1,5 @@
 import type { TurboModule } from 'react-native';
-import { TurboModuleRegistry } from 'react-native';
+import { NativeModules, Platform, TurboModuleRegistry } from 'react-native';
 
 /**
  * Shared contract of the native `Alarm` module.
@@ -92,4 +92,22 @@ export interface Spec extends TurboModule {
   removeListeners(count: number): void;
 }
 
-export default TurboModuleRegistry.getEnforcing<Spec>('Alarm');
+const LINKING_ERROR =
+  "react-native-alarms: the native 'Alarm' module is not linked. " +
+  Platform.select({
+    ios: "Run 'pod install' in the ios folder, then rebuild the app.",
+    default: 'Rebuild the app after installing the package.',
+  });
+
+// Both platforms register a legacy module, reachable through either registry
+// depending on the architecture. Throw on first use, not on import.
+const Alarm: Spec =
+  TurboModuleRegistry.get<Spec>('Alarm') ??
+  NativeModules.Alarm ??
+  new Proxy({} as Spec, {
+    get() {
+      throw new Error(LINKING_ERROR);
+    },
+  });
+
+export default Alarm;

package/app.json

@@ -1,4 +0,0 @@
-{
-  "name": "ReactNativeAlarm",
-  "displayName": "ReactNativeAlarm"
-}

package/index.js

@@ -1,12 +0,0 @@
-/**
- * @format
- */
-
-import { AppRegistry } from 'react-native';
-import App from './App';
-import { name as appName } from './app.json';
-import { AlarmRingScreen } from './AlarmRingScreen';
-
-AppRegistry.registerComponent(appName, () => App);
-
-AppRegistry.registerComponent('AlarmRing', () => AlarmRingScreen);