react-native-alarms 0.0.0-stage → 0.0.2

package/ios/alarm/NotificationBackend.swift

@@ -0,0 +1,227 @@
+import Foundation
+import UserNotifications
+
+/// Fallback backend for devices without AlarmKit (iOS < 26, or AlarmKit denied):
+/// local notifications with Stop / Snooze actions.
+///
+/// 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`).
+final class NotificationBackend: NSObject, UNUserNotificationCenterDelegate {
+  static let shared = NotificationBackend()
+
+  static let category = "RN_ALARM"
+  static let actionSnooze = "RN_ALARM_SNOOZE"
+  static let actionStop = "RN_ALARM_STOP"
+  private static let prefix = "rnalarm:"
+  /// How many `interval` occurrences to pre-schedule (iOS caps pending requests at 64).
+  private static let intervalOccurrences = 12
+
+  private let center = UNUserNotificationCenter.current()
+
+  /// The alarm whose notification is currently being shown (foreground) or was tapped.
+  private(set) var ringing: AlarmData?
+  /// Wired by `AlarmModule` so native events reach JS.
+  var onEvent: ((String, AlarmData) -> Void)?
+
+  /// 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() {
+    let center = UNUserNotificationCenter.current()
+    if center.delegate == nil { center.delegate = shared }
+    let snooze = UNNotificationAction(identifier: actionSnooze, title: "Snooze", options: [])
+    let stop = UNNotificationAction(identifier: actionStop, title: "Stop", options: [.destructive])
+    center.setNotificationCategories([
+      UNNotificationCategory(
+        identifier: category, actions: [snooze, stop], intentIdentifiers: [],
+        options: [.customDismissAction]
+      ),
+    ])
+  }
+
+  // MARK: - Permission
+
+  /// 'granted' | 'denied' | 'notDetermined', same vocabulary as Android.
+  func status(_ completion: @escaping (String) -> Void) {
+    center.getNotificationSettings { settings in
+      switch settings.authorizationStatus {
+      case .authorized, .provisional, .ephemeral: completion("granted")
+      case .denied: completion("denied")
+      default: completion("notDetermined")
+      }
+    }
+  }
+
+  func request(_ completion: @escaping (Bool) -> Void) {
+    center.requestAuthorization(options: [.alert, .sound, .badge]) { ok, _ in completion(ok) }
+  }
+
+  // MARK: - Scheduling
+
+  private func ids(for alarmId: String) -> [String] {
+    let base = Self.prefix + alarmId
+    return [base, base + ":snooze"]
+      + (1...7).map { base + ":wd\($0)" }
+      + (0..<Self.intervalOccurrences).map { base + ":i\($0)" }
+  }
+
+  private func content(for a: AlarmData) -> UNMutableNotificationContent {
+    let c = UNMutableNotificationContent()
+    c.title = a.title.isEmpty ? "Alarm" : a.title
+    c.body = a.body.isEmpty ? "Alarm is ringing" : a.body
+    c.categoryIdentifier = Self.category
+    c.userInfo = ["alarmId": a.id]
+    c.sound = (a.sound.isEmpty || a.sound == "default")
+      ? .default
+      : UNNotificationSound(named: UNNotificationSoundName(rawValue: a.sound))
+    // Breaks through Focus when the Time Sensitive Notifications capability is enabled;
+    // silently downgraded to a normal notification otherwise.
+    c.interruptionLevel = .timeSensitive
+    return c
+  }
+
+  private func request(_ id: String, _ a: AlarmData, _ trigger: UNNotificationTrigger) -> UNNotificationRequest {
+    UNNotificationRequest(identifier: id, content: content(for: a), trigger: trigger)
+  }
+
+  func schedule(_ a: AlarmData, completion: @escaping (Error?) -> Void) {
+    cancel(a.id)
+    let cal = Calendar.current
+    let base = Self.prefix + a.id
+    let hm = cal.dateComponents([.hour, .minute], from: a.date)
+    var requests: [UNNotificationRequest] = []
+
+    switch a.repeatType {
+    case "daily":
+      var dc = DateComponents()
+      dc.hour = hm.hour
+      dc.minute = hm.minute
+      requests.append(request(base, a, UNCalendarNotificationTrigger(dateMatching: dc, repeats: true)))
+
+    case "weekly":
+      let days = a.weekdays.isEmpty ? Array(1...7) : a.weekdays.filter { (1...7).contains($0) }
+      for d in days {
+        var dc = DateComponents()
+        dc.weekday = d
+        dc.hour = hm.hour
+        dc.minute = hm.minute
+        requests.append(request(base + ":wd\(d)", a, UNCalendarNotificationTrigger(dateMatching: dc, repeats: true)))
+      }
+
+    case "interval":
+      // iOS repeating interval triggers count from "now", not from `timestamp`, so
+      // pre-schedule the next N exact occurrences instead.
+      var t = a.nextTrigger()
+      guard t > 0 else { return completion(nil) }
+      for k in 0..<Self.intervalOccurrences {
+        requests.append(request(base + ":i\(k)", a, exactTrigger(ms: t)))
+        t += a.intervalMs
+      }
+
+    default:
+      let next = a.nextTrigger()
+      guard next > 0 else { return completion(nil) } // nothing in the future, same as Android
+      requests.append(request(base, a, exactTrigger(ms: next)))
+    }
+
+    add(requests, completion: completion)
+  }
+
+  private func exactTrigger(ms: Double) -> UNCalendarNotificationTrigger {
+    let dc = Calendar.current.dateComponents(
+      [.year, .month, .day, .hour, .minute, .second],
+      from: Date(timeIntervalSince1970: ms / 1000)
+    )
+    return UNCalendarNotificationTrigger(dateMatching: dc, repeats: false)
+  }
+
+  private func add(_ requests: [UNNotificationRequest], completion: @escaping (Error?) -> Void) {
+    let group = DispatchGroup()
+    var firstError: Error?
+    for r in requests {
+      group.enter()
+      center.add(r) { error in
+        if firstError == nil { firstError = error }
+        group.leave()
+      }
+    }
+    group.notify(queue: .main) { completion(firstError) }
+  }
+
+  /// One-off re-ring in `minutes`, equivalent to Android's `AlarmScheduler.scheduleSnooze`.
+  func snooze(_ a: AlarmData, minutes: Int) {
+    center.removeDeliveredNotifications(withIdentifiers: ids(for: a.id))
+    let trigger = UNTimeIntervalNotificationTrigger(timeInterval: Double(max(1, minutes)) * 60, repeats: false)
+    center.add(request(Self.prefix + a.id + ":snooze", a, trigger))
+    if ringing?.id == a.id { ringing = nil }
+  }
+
+  func cancel(_ id: String) {
+    center.removePendingNotificationRequests(withIdentifiers: ids(for: id))
+    center.removeDeliveredNotifications(withIdentifiers: ids(for: id))
+    if ringing?.id == id { ringing = nil }
+  }
+
+  func cancelAll() {
+    center.getPendingNotificationRequests { (requests: [UNNotificationRequest]) in
+      let ours = requests.map { $0.identifier }.filter { $0.hasPrefix(Self.prefix) }
+      self.center.removePendingNotificationRequests(withIdentifiers: ours)
+    }
+    center.getDeliveredNotifications { (notifications: [UNNotification]) in
+      let ours = notifications.map { $0.request.identifier }.filter { $0.hasPrefix(Self.prefix) }
+      self.center.removeDeliveredNotifications(withIdentifiers: ours)
+    }
+    ringing = nil
+  }
+
+  /// Dismiss: clear the shown notification and, like Android, drop a pending snooze.
+  func stop(_ id: String) {
+    center.removeDeliveredNotifications(withIdentifiers: ids(for: id))
+    center.removePendingNotificationRequests(withIdentifiers: [Self.prefix + id + ":snooze"])
+    if let a = ringing, a.id == id {
+      ringing = nil
+      onEvent?(AlarmModule.eventDismissed, a)
+    }
+  }
+
+  // MARK: - UNUserNotificationCenterDelegate
+
+  private func alarm(from notification: UNNotification) -> AlarmData? {
+    guard let id = notification.request.content.userInfo["alarmId"] as? String else { return nil }
+    return AlarmStore.get(id)
+  }
+
+  func userNotificationCenter(
+    _ center: UNUserNotificationCenter,
+    willPresent notification: UNNotification,
+    withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void
+  ) {
+    if let a = alarm(from: notification) {
+      ringing = a
+      onEvent?(AlarmModule.eventFired, a)
+    }
+    completionHandler([.banner, .list, .sound])
+  }
+
+  func userNotificationCenter(
+    _ center: UNUserNotificationCenter,
+    didReceive response: UNNotificationResponse,
+    withCompletionHandler completionHandler: @escaping () -> Void
+  ) {
+    defer { completionHandler() }
+    guard let a = alarm(from: response.notification) else { return }
+    switch response.actionIdentifier {
+    case Self.actionSnooze:
+      snooze(a, minutes: a.snoozeMinutes)
+      onEvent?(AlarmModule.eventSnoozed, a)
+    case UNNotificationDefaultActionIdentifier:
+      // Tapped: the app is now open; let JS show its ring UI (getRingingAlarm / onAlarmFired).
+      ringing = a
+      onEvent?(AlarmModule.eventFired, a)
+    default: // Stop action or swiped away
+      ringing = nil
+      center.removePendingNotificationRequests(withIdentifiers: [Self.prefix + a.id + ":snooze"])
+      onEvent?(AlarmModule.eventDismissed, a)
+    }
+  }
+}

package/package.json

@@ -1,6 +1,94 @@
 {
   "name": "react-native-alarms",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.0.2",
+  "description": "A powerful, cross-platform alarm management library for React Native",
+  "private": false,
+  "main": "index.ts",
+  "types": "index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./index.ts"
+    },
+    "./service": {
+      "types": "./AlarmService.d.ts",
+      "default": "./AlarmService.ts"
+    }
+  },
+  "scripts": {
+    "android": "react-native run-android",
+    "ios": "react-native run-ios",
+    "lint": "eslint .",
+    "start": "react-native start",
+    "test": "jest",
+    "prepare": "npm run build",
+    "build": "tsc",
+    "clean": "rm -rf dist types *.d.ts"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/surajprasad13/react-native-alarms"
+  },
+  "keywords": [
+    "react-native",
+    "alarm",
+    "notification",
+    "schedule",
+    "cross-platform",
+    "ios",
+    "android"
+  ],
+  "author": {
+    "name": "Suraj Prasad",
+    "email": "surajvishwakarma830@gmail.com",
+    "url": "https://github.com/surajprasad13"
+  },
+  "license": "MIT",
+  "peerDependencies": {
+    "react": ">=18.0.0",
+    "react-native": ">=0.70.0"
+  },
+  "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": {
+    "@babel/core": "^7.25.2",
+    "@babel/preset-env": "^7.25.3",
+    "@babel/runtime": "^7.25.0",
+    "@react-native-community/cli": "20.2.0",
+    "@react-native-community/cli-platform-android": "20.2.0",
+    "@react-native-community/cli-platform-ios": "20.2.0",
+    "@react-native/babel-preset": "0.88.0",
+    "@react-native/eslint-config": "0.88.0",
+    "@react-native/jest-preset": "0.88.0",
+    "@react-native/metro-config": "0.88.0",
+    "@react-native/typescript-config": "0.88.0",
+    "@types/jest": "^29.5.13",
+    "@types/react": "^19.2.0",
+    "@types/react-test-renderer": "^19.1.0",
+    "eslint": "^8.19.0",
+    "jest": "^29.6.3",
+    "prettier": "2.8.8",
+    "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/specs/NativeAlarm.ts

@@ -0,0 +1,95 @@
+import type { TurboModule } from 'react-native';
+import { TurboModuleRegistry } from 'react-native';
+
+/**
+ * Shared contract of the native `Alarm` module.
+ *
+ * Both platforms register a legacy-style module named `Alarm` with these exact
+ * method names (Android: AlarmModule.kt, iOS: ios/alarm/AlarmModule.swift) and
+ * emit the same events through `NativeEventEmitter`:
+ *   onAlarmFired | onAlarmDismissed | onAlarmSnoozed  -> AlarmEvent
+ */
+
+/** type: 'none' | 'daily' | 'weekly' | 'interval' */
+export type AlarmRepeat = {
+  type: string;
+  weekdays?: number[]; // 1 = Sunday ... 7 = Saturday (weekly)
+  intervalMs?: number; // interval
+};
+
+export type AlarmConfig = {
+  alarmId?: string;
+  timestamp: number; // ms since epoch
+  title: string;
+  body?: string;
+  sound?: string; // 'default' or a bundled sound file name
+  vibrate?: boolean; // Android only (iOS alarms always vibrate per system settings)
+  snoozeEnabled?: boolean;
+  snoozeMinutes?: number;
+  repeat?: AlarmRepeat;
+  data?: string; // JSON string payload
+};
+
+export type Alarm = {
+  alarmId: string;
+  timestamp: number;
+  title: string;
+  body: string;
+  sound: string;
+  vibrate: boolean;
+  snoozeEnabled: boolean;
+  snoozeMinutes: number;
+  repeat: AlarmRepeat;
+  data: string;
+  enabled: boolean;
+  nextTriggerAt: number; // 0 if none
+};
+
+/** status: 'granted' | 'denied' | 'notDetermined' */
+export type AlarmPermission = {
+  status: string;
+  notifications: boolean;
+  canScheduleExact: boolean;
+  canDrawOverlays: boolean; // Android only; always true on iOS
+  canUseFullScreenIntent: boolean; // Android only; always true on iOS
+  backend?: string; // iOS only: 'alarmkit' (iOS 26+) | 'notifications'
+};
+
+export type AlarmEvent = {
+  alarmId: string;
+  timestamp: number;
+  title: string;
+  body: string;
+  data: string;
+};
+
+export interface Spec extends TurboModule {
+  // ---------- Permissions ----------
+  checkPermission(): Promise<AlarmPermission>;
+  requestPermission(): Promise<AlarmPermission>;
+  canScheduleExactAlarms(): Promise<boolean>;
+  /** Opens the vendor Autostart screen on Android; resolves false on iOS. */
+  openAutoStartSettings(): Promise<boolean>;
+
+  // ---------- Scheduling ----------
+  scheduleAlarm(config: AlarmConfig): Promise<string>;
+  updateAlarm(alarmId: string, config: AlarmConfig): Promise<boolean>;
+  cancelAlarm(alarmId: string): Promise<boolean>;
+  cancelAllAlarms(): Promise<void>;
+
+  // ---------- Control (while ringing) ----------
+  stopAlarm(alarmId: string): Promise<void>;
+  snoozeAlarm(alarmId: string, minutes: number): Promise<void>;
+  getRingingAlarm(): Promise<Alarm | null>;
+
+  // ---------- Queries ----------
+  getAlarm(alarmId: string): Promise<Alarm | null>;
+  getAllAlarms(): Promise<Alarm[]>;
+  isScheduled(alarmId: string): Promise<boolean>;
+
+  // ---------- Events (used by NativeEventEmitter) ----------
+  addListener(eventName: string): void;
+  removeListeners(count: number): void;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('Alarm');