react-native-alarmageddon 1.1.1 → 2.1.0

package/android/src/main/java/com/rnalarmmodule/BootReceiver.kt

@@ -1,156 +1,98 @@
 package com.rnalarmmodule
 
-import android.app.AlarmManager
-import android.app.PendingIntent
 import android.content.BroadcastReceiver
 import android.content.Context
 import android.content.Intent
+import android.app.AlarmManager
+import android.app.PendingIntent
 import android.os.Build
+import org.json.JSONObject
+import java.text.SimpleDateFormat
+import java.util.Locale
 import android.util.Log
-import org.json.JSONArray
 
 class BootReceiver : BroadcastReceiver() {
 
     companion object {
         private const val TAG = "BootReceiver"
-        private const val PREFS_NAME = "rn_alarm_module_alarms"
-        private const val ALARMS_KEY = "alarms"
+        private const val PREFS = "rn_alarm_module_alarms"
+        private const val DATE_PATTERN = "yyyy-MM-dd'T'HH:mm:ss"
     }
 
-    override fun onReceive(context: Context, intent: Intent) {
-        val action = intent.action
-        Log.d(TAG, "onReceive: action=$action")
-
-        when (action) {
+    override fun onReceive(context: Context, intent: Intent?) {
+        if (intent == null) return
+        when (intent.action) {
             Intent.ACTION_BOOT_COMPLETED,
-            Intent.ACTION_LOCKED_BOOT_COMPLETED,
             Intent.ACTION_TIME_CHANGED,
-            Intent.ACTION_TIMEZONE_CHANGED,
-            Intent.ACTION_MY_PACKAGE_REPLACED -> {
-                rescheduleAllAlarms(context)
-            }
-            else -> {
-                Log.w(TAG, "Unhandled action: $action")
+            Intent.ACTION_TIMEZONE_CHANGED -> {
+                Log.d(TAG, "Rescheduling alarms after: ${intent.action}")
+                rescheduleAlarms(context)
             }
         }
     }
 
-    private fun rescheduleAllAlarms(context: Context) {
-        Log.d(TAG, "Rescheduling all alarms...")
-
-        try {
-            val prefs = context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
-            val alarmsJson = prefs.getString(ALARMS_KEY, "[]") ?: "[]"
-            val alarms = JSONArray(alarmsJson)
+    private fun rescheduleAlarms(context: Context) {
+        val prefs = context.getSharedPreferences(PREFS, Context.MODE_PRIVATE)
+        val all = prefs.all
+        if (all.isEmpty()) {
+            Log.d(TAG, "No alarms to reschedule.")
+            return
+        }
 
-            val currentTime = System.currentTimeMillis()
-            val validAlarms = JSONArray()
-            var rescheduledCount = 0
+        val sdf = SimpleDateFormat(DATE_PATTERN, Locale.getDefault())
+        val alarmManager = context.getSystemService(Context.ALARM_SERVICE) as AlarmManager
+        val now = System.currentTimeMillis()
 
-            for (i in 0 until alarms.length()) {
-                val alarm = alarms.getJSONObject(i)
-                val id = alarm.getString("id")
-                val triggerTime = alarm.getLong("triggerTime")
-                val title = alarm.optString("title", "Alarm")
-                val body = alarm.optString("body", "")
-                val soundUri = alarm.optString("soundUri", "")
-                val vibrate = alarm.optBoolean("vibrate", true)
-                val snoozeMinutes = alarm.optInt("snoozeMinutes", 5)
-                val autoStopSeconds = alarm.optInt("autoStopSeconds", 60)
+        var rescheduledCount = 0
+        var skippedCount = 0
 
-                // Only reschedule alarms that are in the future
-                if (triggerTime > currentTime) {
-                    scheduleAlarm(
-                        context,
-                        id,
-                        triggerTime,
-                        title,
-                        body,
-                        soundUri,
-                        vibrate,
-                        snoozeMinutes,
-                        autoStopSeconds
-                    )
-                    validAlarms.put(alarm)
-                    rescheduledCount++
-                    Log.d(TAG, "Rescheduled alarm: id=$id, triggerTime=$triggerTime")
-                } else {
-                    Log.d(TAG, "Skipping past alarm: id=$id, triggerTime=$triggerTime")
-                }
+        for ((id, rawJson) in all) {
+            val jsonStr = rawJson as? String ?: continue
+            val obj = try {
+                JSONObject(jsonStr)
+            } catch (_: Exception) {
+                continue
+            }
+            val datetimeISO = obj.optString("datetimeISO", "")
+            val title = obj.optString("title", "Alarm")
+            val body = obj.optString("body", "")
+
+            val date = try {
+                sdf.parse(datetimeISO)
+            } catch (_: Exception) {
+                null
+            } ?: continue
+            
+            val triggerAt = date.time
+            if (triggerAt <= now) {
+                // Past alarms: skip (could optionally fire immediately if desired)
+                skippedCount++
+                continue
             }
 
-            // Update stored alarms to only include valid (future) ones
-            prefs.edit().putString(ALARMS_KEY, validAlarms.toString()).apply()
-
-            Log.d(TAG, "Rescheduled $rescheduledCount alarms")
-        } catch (e: Exception) {
-            Log.e(TAG, "Failed to reschedule alarms: ${e.message}", e)
-        }
-    }
-
-    private fun scheduleAlarm(
-        context: Context,
-        id: String,
-        triggerTimeMillis: Long,
-        title: String,
-        body: String,
-        soundUri: String,
-        vibrate: Boolean,
-        snoozeMinutes: Int,
-        autoStopSeconds: Int
-    ) {
-        val alarmManager = context.getSystemService(Context.ALARM_SERVICE) as AlarmManager
-
-        val intent = Intent(context, AlarmReceiver::class.java).apply {
-            action = AlarmReceiver.ACTION_TRIGGER
-            putExtra("alarmId", id)
-            putExtra("title", title)
-            putExtra("body", body)
-            putExtra("soundUri", soundUri)
-            putExtra("vibrate", vibrate)
-            putExtra("snoozeMinutes", snoozeMinutes)
-            putExtra("autoStopSeconds", autoStopSeconds)
-        }
+            val alarmIntent = Intent(context, AlarmReceiver::class.java).apply {
+                putExtra("id", id)
+                putExtra("title", title)
+                putExtra("body", body)
+            }
 
-        val pendingIntent = PendingIntent.getBroadcast(
-            context,
-            id.hashCode(),
-            intent,
-            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
-        )
+            val pendingIntent = PendingIntent.getBroadcast(
+                context,
+                id.hashCode(),
+                alarmIntent,
+                PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
+            )
 
-        try {
-            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
-                if (alarmManager.canScheduleExactAlarms()) {
-                    alarmManager.setAlarmClock(
-                        AlarmManager.AlarmClockInfo(triggerTimeMillis, pendingIntent),
-                        pendingIntent
-                    )
-                } else {
-                    // Fallback to inexact alarm if exact permission not granted
-                    alarmManager.setAndAllowWhileIdle(
-                        AlarmManager.RTC_WAKEUP,
-                        triggerTimeMillis,
-                        pendingIntent
-                    )
-                    Log.w(TAG, "Exact alarm permission not granted, using inexact alarm for: $id")
-                }
-            } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
-                alarmManager.setAlarmClock(
-                    AlarmManager.AlarmClockInfo(triggerTimeMillis, pendingIntent),
-                    pendingIntent
-                )
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+                alarmManager.setExactAndAllowWhileIdle(AlarmManager.RTC_WAKEUP, triggerAt, pendingIntent)
             } else {
-                alarmManager.setExact(
-                    AlarmManager.RTC_WAKEUP,
-                    triggerTimeMillis,
-                    pendingIntent
-                )
+                alarmManager.setExact(AlarmManager.RTC_WAKEUP, triggerAt, pendingIntent)
             }
-        } catch (e: SecurityException) {
-            Log.e(TAG, "Security exception scheduling alarm $id: ${e.message}", e)
-        } catch (e: Exception) {
-            Log.e(TAG, "Failed to schedule alarm $id: ${e.message}", e)
+
+            rescheduledCount++
+            Log.d(TAG, "Rescheduled alarm id=$id at=$datetimeISO")
         }
+
+        Log.d(TAG, "Rescheduling complete: $rescheduledCount rescheduled, $skippedCount skipped (past)")
     }
 }

package/ios/{RNAlarmModule.m → AlarmModule.m}

@@ -3,46 +3,35 @@
 
 @interface RCT_EXTERN_MODULE(AlarmModule, RCTEventEmitter)
 
+RCT_EXTERN_METHOD(requestPermissions:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
 RCT_EXTERN_METHOD(scheduleAlarm:(NSDictionary *)alarm
                   resolver:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)
 
-RCT_EXTERN_METHOD(cancelAlarm:(NSString *)alarmId
+RCT_EXTERN_METHOD(cancelAlarm:(NSString *)id
                   resolver:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)
 
 RCT_EXTERN_METHOD(listAlarms:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)
 
-RCT_EXTERN_METHOD(requestPermissions:(RCTPromiseResolveBlock)resolve
-                  rejecter:(RCTPromiseRejectBlock)reject)
-
-RCT_EXTERN_METHOD(checkExactAlarmPermission:(RCTPromiseResolveBlock)resolve
-                  rejecter:(RCTPromiseRejectBlock)reject)
-
-RCT_EXTERN_METHOD(openExactAlarmSettings:(RCTPromiseResolveBlock)resolve
-                  rejecter:(RCTPromiseRejectBlock)reject)
-
-RCT_EXTERN_METHOD(snoozeAlarm:(NSString *)alarmId
-                  minutes:(nonnull NSNumber *)minutes
+RCT_EXTERN_METHOD(snoozeAlarm:(NSString *)id
+                  minutes:(int)minutes
                   resolver:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)
 
-RCT_EXTERN_METHOD(stopCurrentAlarm:(NSString *)alarmId
+RCT_EXTERN_METHOD(stopCurrentAlarm:(NSString *)id
                   resolver:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)
 
-RCT_EXTERN_METHOD(snoozeCurrentAlarm:(NSString *)alarmId
-                  minutes:(nonnull NSNumber *)minutes
+RCT_EXTERN_METHOD(snoozeCurrentAlarm:(NSString *)id
+                  minutes:(int)minutes
                   resolver:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)
 
 RCT_EXTERN_METHOD(getCurrentAlarmPlaying:(RCTPromiseResolveBlock)resolve
                   rejecter:(RCTPromiseRejectBlock)reject)
 
-+ (BOOL)requiresMainQueueSetup
-{
-  return NO;
-}
-
 @end

package/ios/AlarmModule.swift

@@ -1,79 +1,284 @@
 import Foundation
 import React
+import UserNotifications
 
 @objc(AlarmModule)
 class AlarmModule: RCTEventEmitter {
     
-    private var hasListeners = false
+    private static let PREFS_KEY = "rn_alarm_module_alarms"
     
     override init() {
         super.init()
     }
     
     @objc override static func requiresMainQueueSetup() -> Bool {
-        return false
+        return true
     }
     
     override func supportedEvents() -> [String]! {
         return ["activeAlarmId"]
     }
     
-    override func startObserving() {
-        hasListeners = true
-    }
+    // MARK: - Permission Methods
     
-    override func stopObserving() {
-        hasListeners = false
+    @objc(requestPermissions:rejecter:)
+    func requestPermissions(_ resolve: @escaping RCTPromiseResolveBlock,
+                            rejecter reject: @escaping RCTPromiseRejectBlock) {
+        UNUserNotificationCenter.current().requestAuthorization(options: [.alert, .sound, .badge]) { granted, error in
+            if let error = error {
+                reject("PERMISSION_ERROR", error.localizedDescription, error)
+                return
+            }
+            resolve(["granted": granted])
+        }
     }
     
-    @objc func scheduleAlarm(_ alarm: NSDictionary, resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
-        // iOS stub - alarms are not yet implemented
-        // iOS uses different mechanisms (UNUserNotificationCenter) which require different handling
-        reject("NOT_IMPLEMENTED", "Alarm scheduling is not yet implemented for iOS. Consider using local notifications.", nil)
+    // MARK: - Alarm Scheduling
+    
+    @objc(scheduleAlarm:resolver:rejecter:)
+    func scheduleAlarm(_ alarm: NSDictionary,
+                       resolver resolve: @escaping RCTPromiseResolveBlock,
+                       rejecter reject: @escaping RCTPromiseRejectBlock) {
+        guard let id = alarm["id"] as? String,
+              let datetimeISO = alarm["datetimeISO"] as? String else {
+            reject("INVALID_PARAMS", "id and datetimeISO are required", nil)
+            return
+        }
+        
+        let title = alarm["title"] as? String ?? "Alarm"
+        let body = alarm["body"] as? String ?? ""
+        let snoozeEnabled = alarm["snoozeEnabled"] as? Bool ?? true
+        let snoozeInterval = alarm["snoozeInterval"] as? Int ?? 5
+        
+        // Parse ISO date
+        let dateFormatter = ISO8601DateFormatter()
+        dateFormatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
+        
+        var triggerDate: Date?
+        triggerDate = dateFormatter.date(from: datetimeISO)
+        
+        // Try without fractional seconds if first parse fails
+        if triggerDate == nil {
+            dateFormatter.formatOptions = [.withInternetDateTime]
+            triggerDate = dateFormatter.date(from: datetimeISO)
+        }
+        
+        // Try basic format
+        if triggerDate == nil {
+            let basicFormatter = DateFormatter()
+            basicFormatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss"
+            basicFormatter.locale = Locale(identifier: "en_US_POSIX")
+            triggerDate = basicFormatter.date(from: datetimeISO)
+        }
+        
+        guard let date = triggerDate else {
+            reject("INVALID_DATE", "Could not parse datetimeISO: \(datetimeISO)", nil)
+            return
+        }
+        
+        // Create notification content
+        let content = UNMutableNotificationContent()
+        content.title = title
+        content.body = body
+        content.sound = UNNotificationSound.default
+        content.categoryIdentifier = snoozeEnabled ? "ALARM_CATEGORY_WITH_SNOOZE" : "ALARM_CATEGORY"
+        content.userInfo = [
+            "alarmId": id,
+            "snoozeEnabled": snoozeEnabled,
+            "snoozeInterval": snoozeInterval
+        ]
+        
+        // Register notification category with appropriate actions
+        registerNotificationCategory(snoozeEnabled: snoozeEnabled)
+        
+        // Create trigger
+        let calendar = Calendar.current
+        let components = calendar.dateComponents([.year, .month, .day, .hour, .minute, .second], from: date)
+        let trigger = UNCalendarNotificationTrigger(dateMatching: components, repeats: false)
+        
+        // Create request
+        let request = UNNotificationRequest(identifier: id, content: content, trigger: trigger)
+        
+        UNUserNotificationCenter.current().add(request) { error in
+            if let error = error {
+                reject("SCHEDULE_ERROR", error.localizedDescription, error)
+                return
+            }
+            
+            // Save alarm to UserDefaults
+            self.saveAlarm(id: id, datetimeISO: datetimeISO, title: title, body: body, snoozeEnabled: snoozeEnabled, snoozeInterval: snoozeInterval)
+            resolve(nil)
+        }
     }
     
-    @objc func cancelAlarm(_ alarmId: String, resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
-        // iOS stub
-        reject("NOT_IMPLEMENTED", "Alarm cancellation is not yet implemented for iOS.", nil)
+    private func registerNotificationCategory(snoozeEnabled: Bool) {
+        let stopAction = UNNotificationAction(
+            identifier: "STOP_ACTION",
+            title: "Stop",
+            options: [.destructive, .foreground]
+        )
+        
+        if snoozeEnabled {
+            let snoozeAction = UNNotificationAction(
+                identifier: "SNOOZE_ACTION",
+                title: "Snooze",
+                options: []
+            )
+            
+            let categoryWithSnooze = UNNotificationCategory(
+                identifier: "ALARM_CATEGORY_WITH_SNOOZE",
+                actions: [stopAction, snoozeAction],
+                intentIdentifiers: [],
+                options: [.customDismissAction]
+            )
+            UNUserNotificationCenter.current().setNotificationCategories([categoryWithSnooze])
+        } else {
+            let categoryWithoutSnooze = UNNotificationCategory(
+                identifier: "ALARM_CATEGORY",
+                actions: [stopAction],
+                intentIdentifiers: [],
+                options: [.customDismissAction]
+            )
+            UNUserNotificationCenter.current().setNotificationCategories([categoryWithoutSnooze])
+        }
     }
     
-    @objc func listAlarms(_ resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
-        // iOS stub - return empty array
-        resolve([])
+    @objc(cancelAlarm:resolver:rejecter:)
+    func cancelAlarm(_ id: String,
+                     resolver resolve: @escaping RCTPromiseResolveBlock,
+                     rejecter reject: @escaping RCTPromiseRejectBlock) {
+        UNUserNotificationCenter.current().removePendingNotificationRequests(withIdentifiers: [id])
+        removeAlarm(id: id)
+        resolve(nil)
     }
     
-    @objc func requestPermissions(_ resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
-        // iOS stub - would request notification permissions
-        resolve(["granted": true, "exactAlarmGranted": true])
+    @objc(listAlarms:rejecter:)
+    func listAlarms(_ resolve: @escaping RCTPromiseResolveBlock,
+                    rejecter reject: @escaping RCTPromiseRejectBlock) {
+        let alarms = getAlarms()
+        resolve(alarms)
     }
     
-    @objc func checkExactAlarmPermission(_ resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
-        // iOS doesn't have exact alarm permission concept
-        resolve(true)
+    // MARK: - Snooze Methods
+    
+    @objc(snoozeAlarm:minutes:resolver:rejecter:)
+    func snoozeAlarm(_ id: String,
+                     minutes: Int,
+                     resolver resolve: @escaping RCTPromiseResolveBlock,
+                     rejecter reject: @escaping RCTPromiseRejectBlock) {
+        // Create a new alarm in X minutes
+        let content = UNMutableNotificationContent()
+        content.title = "Snoozed Alarm"
+        content.body = id
+        content.sound = UNNotificationSound.default
+        content.categoryIdentifier = "ALARM_CATEGORY"
+        
+        let trigger = UNTimeIntervalNotificationTrigger(timeInterval: TimeInterval(minutes * 60), repeats: false)
+        let request = UNNotificationRequest(identifier: UUID().uuidString, content: content, trigger: trigger)
+        
+        UNUserNotificationCenter.current().add(request) { error in
+            if let error = error {
+                reject("SNOOZE_ERROR", error.localizedDescription, error)
+                return
+            }
+            resolve(nil)
+        }
     }
     
-    @objc func openExactAlarmSettings(_ resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
-        // iOS stub - no equivalent
+    // MARK: - Current Alarm Methods
+    
+    @objc(stopCurrentAlarm:resolver:rejecter:)
+    func stopCurrentAlarm(_ id: String,
+                          resolver resolve: @escaping RCTPromiseResolveBlock,
+                          rejecter reject: @escaping RCTPromiseRejectBlock) {
+        // iOS doesn't have persistent alarm sounds like Android
+        // Remove the delivered notification
+        UNUserNotificationCenter.current().removeDeliveredNotifications(withIdentifiers: [id])
         resolve(nil)
     }
     
-    @objc func snoozeAlarm(_ alarmId: String, minutes: NSNumber, resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
-        // iOS stub
-        reject("NOT_IMPLEMENTED", "Alarm snooze is not yet implemented for iOS.", nil)
+    @objc(snoozeCurrentAlarm:minutes:resolver:rejecter:)
+    func snoozeCurrentAlarm(_ id: String,
+                            minutes: Int,
+                            resolver resolve: @escaping RCTPromiseResolveBlock,
+                            rejecter reject: @escaping RCTPromiseRejectBlock) {
+        // Remove current notification
+        UNUserNotificationCenter.current().removeDeliveredNotifications(withIdentifiers: [id])
+        
+        // Get alarm details
+        if let alarm = getAlarmById(id: id) {
+            let title = alarm["title"] ?? "Alarm"
+            let body = (alarm["body"] ?? "") + " (Snoozed)"
+            let snoozeEnabled = (alarm["snoozeEnabled"] as NSString?)?.boolValue ?? true
+            let snoozeInterval = Int(alarm["snoozeInterval"] ?? "5") ?? 5
+            
+            let content = UNMutableNotificationContent()
+            content.title = title
+            content.body = body
+            content.sound = UNNotificationSound.default
+            content.categoryIdentifier = snoozeEnabled ? "ALARM_CATEGORY_WITH_SNOOZE" : "ALARM_CATEGORY"
+            content.userInfo = [
+                "alarmId": id,
+                "snoozeEnabled": snoozeEnabled,
+                "snoozeInterval": snoozeInterval
+            ]
+            
+            registerNotificationCategory(snoozeEnabled: snoozeEnabled)
+            
+            let trigger = UNTimeIntervalNotificationTrigger(timeInterval: TimeInterval(minutes * 60), repeats: false)
+            let request = UNNotificationRequest(identifier: id, content: content, trigger: trigger)
+            
+            UNUserNotificationCenter.current().add(request) { error in
+                if let error = error {
+                    reject("SNOOZE_ERROR", error.localizedDescription, error)
+                    return
+                }
+                resolve(nil)
+            }
+        } else {
+            // Alarm not found, just snooze with generic content
+            snoozeAlarm(id, minutes: minutes, resolver: resolve, rejecter: reject)
+        }
     }
     
-    @objc func stopCurrentAlarm(_ alarmId: String, resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
-        // iOS stub
+    @objc(getCurrentAlarmPlaying:rejecter:)
+    func getCurrentAlarmPlaying(_ resolve: @escaping RCTPromiseResolveBlock,
+                                 rejecter reject: @escaping RCTPromiseRejectBlock) {
+        // iOS doesn't have a concept of "currently playing" alarm like Android
+        // Return nil as there's no persistent alarm sound
         resolve(nil)
     }
     
-    @objc func snoozeCurrentAlarm(_ alarmId: String, minutes: NSNumber, resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
-        // iOS stub
-        reject("NOT_IMPLEMENTED", "Alarm snooze is not yet implemented for iOS.", nil)
+    // MARK: - Storage Helpers
+    
+    private func saveAlarm(id: String, datetimeISO: String, title: String, body: String, snoozeEnabled: Bool = true, snoozeInterval: Int = 5) {
+        var alarms = getAlarmsDict()
+        alarms[id] = [
+            "id": id,
+            "datetimeISO": datetimeISO,
+            "title": title,
+            "body": body,
+            "snoozeEnabled": String(snoozeEnabled),
+            "snoozeInterval": String(snoozeInterval)
+        ]
+        UserDefaults.standard.set(alarms, forKey: AlarmModule.PREFS_KEY)
     }
     
-    @objc func getCurrentAlarmPlaying(_ resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
-        // iOS stub - no alarm playing
-        resolve(nil)
+    private func removeAlarm(id: String) {
+        var alarms = getAlarmsDict()
+        alarms.removeValue(forKey: id)
+        UserDefaults.standard.set(alarms, forKey: AlarmModule.PREFS_KEY)
+    }
+    
+    private func getAlarmsDict() -> [String: [String: String]] {
+        return UserDefaults.standard.dictionary(forKey: AlarmModule.PREFS_KEY) as? [String: [String: String]] ?? [:]
+    }
+    
+    private func getAlarms() -> [[String: String]] {
+        return Array(getAlarmsDict().values)
+    }
+    
+    private func getAlarmById(id: String) -> [String: String]? {
+        return getAlarmsDict()[id]
     }
 }

package/ios/RNAlarmModule-Bridging-Header.h

@@ -1,3 +1,7 @@
+//
+//  Use this file to import your target's public headers that you would like to expose to Swift.
+//
+
 #import <React/RCTBridgeModule.h>
 #import <React/RCTEventEmitter.h>
-#import <React/RCTUtils.h>
+#import <React/RCTViewManager.h>