react-native-alarmageddon 1.1.1 → 2.1.0

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

@@ -1,485 +1,261 @@
 package com.rnalarmmodule
 
+import com.facebook.react.bridge.*
 import android.app.AlarmManager
 import android.app.PendingIntent
 import android.content.Context
 import android.content.Intent
-import android.content.SharedPreferences
 import android.os.Build
-import android.provider.Settings
+import java.text.SimpleDateFormat
+import java.util.*
 import android.util.Log
-import com.facebook.react.bridge.*
-import com.facebook.react.modules.core.DeviceEventManagerModule.RCTDeviceEventEmitter
-import org.json.JSONArray
 import org.json.JSONObject
+import android.content.pm.PackageManager
 import java.lang.ref.WeakReference
-import java.text.SimpleDateFormat
-import java.util.*
 
 class AlarmModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
 
     companion object {
         private const val TAG = "AlarmModule"
-        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"
-        private const val ACTIVE_ALARM_KEY = "active_alarm_id"
 
-        // Weak reference to avoid memory leaks
+        // Weak reference to avoid memory leaks - used by AlarmReceiver to emit events
         private var reactContextRef: WeakReference<ReactApplicationContext>? = null
 
         fun getReactContext(): ReactApplicationContext? = reactContextRef?.get()
-
-        fun emitActiveAlarmId(id: String?) {
-            val reactContext = getReactContext()
-            if (reactContext != null && reactContext.hasActiveCatalystInstance()) {
-                try {
-                    reactContext
-                        .getJSModule(RCTDeviceEventEmitter::class.java)
-                        .emit("activeAlarmId", id)
-                } catch (e: Exception) {
-                    Log.e(TAG, "Failed to emit activeAlarmId event: ${e.message}")
-                }
-            }
-        }
     }
 
-    private val prefs: SharedPreferences = reactContext.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
-    private val dateFormat = SimpleDateFormat(DATE_PATTERN, Locale.getDefault())
-
     init {
+        // Update the reference whenever the module is instantiated
         reactContextRef = WeakReference(reactContext)
-        dateFormat.timeZone = TimeZone.getDefault()
     }
 
     override fun getName(): String = "AlarmModule"
 
-    override fun getConstants(): Map<String, Any> {
-        return mapOf(
-            "EXACT_ALARM_PERMISSION_REQUIRED" to (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S)
-        )
-    }
-
     @ReactMethod
-    fun addListener(eventName: String) {
-        // Required for NativeEventEmitter
-    }
-
-    @ReactMethod
-    fun removeListeners(count: Int) {
-        // Required for NativeEventEmitter
-    }
-
-    @ReactMethod
-    fun scheduleAlarm(alarmParams: ReadableMap, promise: Promise) {
-        try {
-            val id = alarmParams.getString("id") ?: run {
-                promise.reject("INVALID_PARAMS", "Alarm ID is required")
-                return
-            }
-            val datetimeISO = alarmParams.getString("datetimeISO") ?: run {
-                promise.reject("INVALID_PARAMS", "datetimeISO is required")
-                return
-            }
-            val title = alarmParams.getString("title") ?: "Alarm"
-            val body = alarmParams.getString("body") ?: ""
-            val soundUri = if (alarmParams.hasKey("soundUri")) alarmParams.getString("soundUri") else null
-            val vibrate = if (alarmParams.hasKey("vibrate")) alarmParams.getBoolean("vibrate") else true
-            val snoozeMinutes = if (alarmParams.hasKey("snoozeMinutes")) alarmParams.getInt("snoozeMinutes") else 5
-            val autoStopSeconds = if (alarmParams.hasKey("autoStopSeconds")) alarmParams.getInt("autoStopSeconds") else 60
-
-            val triggerTime = parseDateTime(datetimeISO)
-            if (triggerTime == null) {
-                promise.reject("INVALID_DATE", "Could not parse datetimeISO: $datetimeISO")
-                return
-            }
-
-            // Store alarm in SharedPreferences
-            val alarm = JSONObject().apply {
-                put("id", id)
-                put("datetimeISO", datetimeISO)
-                put("triggerTime", triggerTime)
-                put("title", title)
-                put("body", body)
-                put("soundUri", soundUri ?: "")
-                put("vibrate", vibrate)
-                put("snoozeMinutes", snoozeMinutes)
-                put("autoStopSeconds", autoStopSeconds)
-            }
-            saveAlarm(alarm)
-
-            // Schedule the alarm
-            scheduleExactAlarm(id, triggerTime, title, body, soundUri, vibrate, snoozeMinutes, autoStopSeconds)
-
-            Log.d(TAG, "Alarm scheduled: id=$id, triggerTime=$triggerTime")
+    fun getCurrentAlarmPlaying(promise: Promise) {
+        if (AlarmReceiver.activeAlarmId != null) {
+            val map = Arguments.createMap()
+            map.putString("activeAlarmId", AlarmReceiver.activeAlarmId)
+            promise.resolve(map)
+        } else {
             promise.resolve(null)
-        } catch (e: Exception) {
-            Log.e(TAG, "Failed to schedule alarm: ${e.message}", e)
-            promise.reject("SCHEDULE_ERROR", "Failed to schedule alarm: ${e.message}", e)
         }
     }
 
     @ReactMethod
-    fun cancelAlarm(id: String, promise: Promise) {
+    fun stopCurrentAlarm(id: String, promise: Promise) {
         try {
-            cancelScheduledAlarm(id)
-            removeAlarm(id)
-            Log.d(TAG, "Alarm cancelled: id=$id")
+            val intent = Intent(reactApplicationContext, AlarmReceiver::class.java).apply {
+                action = AlarmReceiver.ACTION_STOP
+                putExtra("id", id)
+            }
+            reactApplicationContext.sendBroadcast(intent)
             promise.resolve(null)
         } catch (e: Exception) {
-            Log.e(TAG, "Failed to cancel alarm: ${e.message}", e)
-            promise.reject("CANCEL_ERROR", "Failed to cancel alarm: ${e.message}", e)
+            Log.e(TAG, "Failed to stop alarm: ${e.message}")
+            promise.reject("STOP_ERROR", e)
         }
     }
 
     @ReactMethod
-    fun listAlarms(promise: Promise) {
+    fun snoozeCurrentAlarm(id: String, minutes: Int, promise: Promise) {
         try {
-            val alarms = getStoredAlarms()
-            val result = Arguments.createArray()
-            for (i in 0 until alarms.length()) {
-                val alarm = alarms.getJSONObject(i)
-                val map = Arguments.createMap().apply {
-                    putString("id", alarm.getString("id"))
-                    putString("datetimeISO", alarm.getString("datetimeISO"))
-                    putString("title", alarm.optString("title", "Alarm"))
-                    putString("body", alarm.optString("body", ""))
-                    putBoolean("vibrate", alarm.optBoolean("vibrate", true))
-                    putInt("snoozeMinutes", alarm.optInt("snoozeMinutes", 5))
-                    putInt("autoStopSeconds", alarm.optInt("autoStopSeconds", 60))
-                }
-                result.pushMap(map)
+            val alarm = getAlarm(id) ?: throw Exception("Alarm not found")
+            val title = alarm.optString("title", "Alarm")
+            val body = alarm.optString("body", "")
+            val snoozeEnabled = alarm.optBoolean("snoozeEnabled", true)
+            val snoozeInterval = alarm.optInt("snoozeInterval", 5)
+
+            val intent = Intent(reactApplicationContext, AlarmReceiver::class.java).apply {
+                action = AlarmReceiver.ACTION_SNOOZE
+                putExtra("id", id)
+                putExtra("title", title)
+                putExtra("body", "$body (Snoozed)")
+                putExtra("snoozeMinutes", minutes)
+                putExtra("snoozeEnabled", snoozeEnabled)
+                putExtra("snoozeInterval", snoozeInterval)
             }
-            promise.resolve(result)
+            reactApplicationContext.sendBroadcast(intent)
+            promise.resolve(null)
         } catch (e: Exception) {
-            Log.e(TAG, "Failed to list alarms: ${e.message}", e)
-            promise.reject("LIST_ERROR", "Failed to list alarms: ${e.message}", e)
+            Log.e(TAG, "Failed to snooze alarm: ${e.message}")
+            promise.reject("SNOOZE_ERROR", e)
         }
     }
 
     @ReactMethod
     fun requestPermissions(promise: Promise) {
-        try {
-            val result = Arguments.createMap()
-            
-            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
-                val alarmManager = reactApplicationContext.getSystemService(Context.ALARM_SERVICE) as AlarmManager
-                val canScheduleExact = alarmManager.canScheduleExactAlarms()
-                result.putBoolean("granted", canScheduleExact)
-                result.putBoolean("exactAlarmGranted", canScheduleExact)
-                
-                if (!canScheduleExact) {
-                    // Open settings to grant exact alarm permission
-                    try {
-                        val intent = Intent(Settings.ACTION_REQUEST_SCHEDULE_EXACT_ALARM).apply {
-                            flags = Intent.FLAG_ACTIVITY_NEW_TASK
-                        }
-                        reactApplicationContext.startActivity(intent)
-                    } catch (e: Exception) {
-                        Log.e(TAG, "Failed to open exact alarm settings: ${e.message}")
-                    }
-                }
-            } else {
-                result.putBoolean("granted", true)
-                result.putBoolean("exactAlarmGranted", true)
-            }
-            
-            promise.resolve(result)
-        } catch (e: Exception) {
-            Log.e(TAG, "Failed to request permissions: ${e.message}", e)
-            promise.reject("PERMISSION_ERROR", "Failed to request permissions: ${e.message}", e)
-        }
+        val granted = if (Build.VERSION.SDK_INT >= 33) {
+            reactApplicationContext.checkSelfPermission(android.Manifest.permission.POST_NOTIFICATIONS) == PackageManager.PERMISSION_GRANTED
+        } else true
+        val map = Arguments.createMap()
+        map.putBoolean("granted", granted)
+        promise.resolve(map)
     }
 
     @ReactMethod
-    fun checkExactAlarmPermission(promise: Promise) {
+    fun scheduleAlarm(alarm: ReadableMap, promise: Promise) {
         try {
-            val result = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
-                val alarmManager = reactApplicationContext.getSystemService(Context.ALARM_SERVICE) as AlarmManager
-                alarmManager.canScheduleExactAlarms()
-            } else {
-                true
+            val id = alarm.getString("id") ?: UUID.randomUUID().toString()
+            val datetimeISO = alarm.getString("datetimeISO") ?: throw Exception("datetimeISO required")
+            val title = alarm.getString("title") ?: "Alarm"
+            val body = alarm.getString("body") ?: ""
+            val snoozeEnabled = if (alarm.hasKey("snoozeEnabled")) alarm.getBoolean("snoozeEnabled") else true
+            val snoozeInterval = if (alarm.hasKey("snoozeInterval")) alarm.getInt("snoozeInterval") else 5
+
+            val sdf = SimpleDateFormat(DATE_PATTERN, Locale.getDefault())
+            val date = sdf.parse(datetimeISO) ?: throw Exception("Invalid date format")
+            val triggerAt = date.time
+
+            val now = System.currentTimeMillis()
+            if (triggerAt < now) {
+                Log.w(TAG, "scheduleAlarm: trigger time in past ($datetimeISO); scheduling anyway.")
             }
-            promise.resolve(result)
-        } catch (e: Exception) {
-            Log.e(TAG, "Failed to check exact alarm permission: ${e.message}", e)
-            promise.reject("PERMISSION_ERROR", "Failed to check permission: ${e.message}", e)
-        }
-    }
 
-    @ReactMethod
-    fun openExactAlarmSettings(promise: Promise) {
-        try {
-            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
-                val intent = Intent(Settings.ACTION_REQUEST_SCHEDULE_EXACT_ALARM).apply {
-                    flags = Intent.FLAG_ACTIVITY_NEW_TASK
-                }
-                reactApplicationContext.startActivity(intent)
+            val alarmManager = reactApplicationContext.getSystemService(Context.ALARM_SERVICE) as AlarmManager
+            val alarmIntent = Intent(reactApplicationContext, AlarmReceiver::class.java).apply {
+                putExtra("id", id)
+                putExtra("title", title)
+                putExtra("body", body)
+                putExtra("snoozeEnabled", snoozeEnabled)
+                putExtra("snoozeInterval", snoozeInterval)
             }
-            promise.resolve(null)
-        } catch (e: Exception) {
-            Log.e(TAG, "Failed to open exact alarm settings: ${e.message}", e)
-            promise.reject("SETTINGS_ERROR", "Failed to open settings: ${e.message}", e)
-        }
-    }
 
-    @ReactMethod
-    fun snoozeAlarm(id: String, minutes: Int, promise: Promise) {
-        try {
-            val alarm = getAlarmById(id)
-            if (alarm == null) {
-                promise.reject("NOT_FOUND", "Alarm not found: $id")
-                return
-            }
-
-            val snoozeTime = System.currentTimeMillis() + (minutes * 60 * 1000L)
-            val newDatetimeISO = dateFormat.format(Date(snoozeTime))
-            
-            // Update alarm with new time
-            alarm.put("datetimeISO", newDatetimeISO)
-            alarm.put("triggerTime", snoozeTime)
-            updateAlarm(alarm)
-
-            // Reschedule
-            scheduleExactAlarm(
-                id,
-                snoozeTime,
-                alarm.optString("title", "Alarm"),
-                alarm.optString("body", ""),
-                alarm.optString("soundUri", null),
-                alarm.optBoolean("vibrate", true),
-                alarm.optInt("snoozeMinutes", 5),
-                alarm.optInt("autoStopSeconds", 60)
+            val pendingIntent = PendingIntent.getBroadcast(
+                reactApplicationContext,
+                id.hashCode(),
+                alarmIntent,
+                PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
             )
 
-            Log.d(TAG, "Alarm snoozed: id=$id, new trigger=$snoozeTime")
+            // Use exact alarm scheduling
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+                alarmManager.setExactAndAllowWhileIdle(AlarmManager.RTC_WAKEUP, triggerAt, pendingIntent)
+            } else {
+                alarmManager.setExact(AlarmManager.RTC_WAKEUP, triggerAt, pendingIntent)
+            }
+
+            saveAlarm(id, datetimeISO, title, body, snoozeEnabled, snoozeInterval)
+            Log.d(TAG, "Scheduled alarm id=$id at=$datetimeISO")
             promise.resolve(null)
         } catch (e: Exception) {
-            Log.e(TAG, "Failed to snooze alarm: ${e.message}", e)
-            promise.reject("SNOOZE_ERROR", "Failed to snooze alarm: ${e.message}", e)
+            Log.e(TAG, "Failed to schedule alarm: ${e.message}")
+            promise.reject("SCHEDULE_ERROR", e)
         }
     }
 
     @ReactMethod
-    fun stopCurrentAlarm(id: String, promise: Promise) {
+    fun cancelAlarm(id: String, promise: Promise) {
         try {
-            // Stop the alarm service
-            val stopIntent = Intent(reactApplicationContext, AlarmService::class.java).apply {
-                action = AlarmService.ACTION_STOP
-                putExtra("alarmId", id)
-            }
-            reactApplicationContext.stopService(stopIntent)
-
-            // Clear active alarm state
-            prefs.edit().remove(ACTIVE_ALARM_KEY).apply()
-            emitActiveAlarmId(null)
-
-            Log.d(TAG, "Alarm stopped: id=$id")
+            val intent = Intent(reactApplicationContext, AlarmReceiver::class.java)
+            val pi = PendingIntent.getBroadcast(
+                reactApplicationContext,
+                id.hashCode(),
+                intent,
+                PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
+            )
+            val am = reactApplicationContext.getSystemService(Context.ALARM_SERVICE) as AlarmManager
+            am.cancel(pi)
+            removeAlarm(id)
+            Log.d(TAG, "Cancelled alarm id=$id")
             promise.resolve(null)
         } catch (e: Exception) {
-            Log.e(TAG, "Failed to stop alarm: ${e.message}", e)
-            promise.reject("STOP_ERROR", "Failed to stop alarm: ${e.message}", e)
+            Log.e(TAG, "Failed to cancel alarm: ${e.message}")
+            promise.reject("CANCEL_ERROR", e)
         }
     }
 
     @ReactMethod
-    fun snoozeCurrentAlarm(id: String, minutes: Int, promise: Promise) {
-        try {
-            // Stop the current alarm
-            val stopIntent = Intent(reactApplicationContext, AlarmService::class.java).apply {
-                action = AlarmService.ACTION_STOP
-                putExtra("alarmId", id)
+    fun listAlarms(promise: Promise) {
+        val arr = Arguments.createArray()
+        val prefs = reactApplicationContext.getSharedPreferences(PREFS, Context.MODE_PRIVATE)
+        val all = prefs.all
+        for ((id, rawJson) in all) {
+            val jsonStr = rawJson as? String ?: continue
+            val obj = try {
+                JSONObject(jsonStr)
+            } catch (_: Exception) {
+                continue
             }
-            reactApplicationContext.stopService(stopIntent)
-
-            // Clear active alarm state
-            prefs.edit().remove(ACTIVE_ALARM_KEY).apply()
-            emitActiveAlarmId(null)
-
-            // Schedule snooze
-            snoozeAlarm(id, minutes, promise)
-        } catch (e: Exception) {
-            Log.e(TAG, "Failed to snooze current alarm: ${e.message}", e)
-            promise.reject("SNOOZE_ERROR", "Failed to snooze current alarm: ${e.message}", e)
+            val map = Arguments.createMap()
+            map.putString("id", id)
+            map.putString("datetimeISO", obj.optString("datetimeISO"))
+            map.putString("title", obj.optString("title"))
+            map.putString("body", obj.optString("body"))
+            map.putBoolean("snoozeEnabled", obj.optBoolean("snoozeEnabled", true))
+            map.putInt("snoozeInterval", obj.optInt("snoozeInterval", 5))
+            arr.pushMap(map)
         }
+        promise.resolve(arr)
     }
 
     @ReactMethod
-    fun getCurrentAlarmPlaying(promise: Promise) {
+    fun snoozeAlarm(message: String, snoozeMinutes: Int, promise: Promise) {
         try {
-            val activeAlarmId = prefs.getString(ACTIVE_ALARM_KEY, null)
-            if (activeAlarmId != null) {
-                val result = Arguments.createMap().apply {
-                    putString("activeAlarmId", activeAlarmId)
-                }
-                promise.resolve(result)
-            } else {
-                promise.resolve(null)
+            val id = UUID.randomUUID().toString()
+            val alarmIntent = Intent(reactApplicationContext, AlarmReceiver::class.java).apply {
+                putExtra("id", id)
+                putExtra("title", "Snoozed Alarm")
+                putExtra("body", message)
             }
-        } catch (e: Exception) {
-            Log.e(TAG, "Failed to get current alarm: ${e.message}", e)
-            promise.reject("GET_ERROR", "Failed to get current alarm: ${e.message}", e)
-        }
-    }
-
-    private fun parseDateTime(datetimeISO: String): Long? {
-        return try {
-            // Try parsing with timezone info
-            val formats = listOf(
-                SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSXXX", Locale.getDefault()),
-                SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ssXXX", Locale.getDefault()),
-                SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'", Locale.getDefault()),
-                SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'", Locale.getDefault()),
-                SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS", Locale.getDefault()),
-                SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss", Locale.getDefault()),
-                SimpleDateFormat("yyyy-MM-dd HH:mm:ss", Locale.getDefault())
+            val pendingIntent = PendingIntent.getBroadcast(
+                reactApplicationContext,
+                id.hashCode(),
+                alarmIntent,
+                PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
             )
-            
-            for (format in formats) {
-                try {
-                    val date = format.parse(datetimeISO)
-                    if (date != null) {
-                        return date.time
-                    }
-                } catch (e: Exception) {
-                    // Try next format
-                }
-            }
-            null
-        } catch (e: Exception) {
-            Log.e(TAG, "Failed to parse date: $datetimeISO", e)
-            null
-        }
-    }
-
-    private fun scheduleExactAlarm(
-        id: String,
-        triggerTimeMillis: Long,
-        title: String,
-        body: String,
-        soundUri: String?,
-        vibrate: Boolean,
-        snoozeMinutes: Int,
-        autoStopSeconds: Int
-    ) {
-        val alarmManager = reactApplicationContext.getSystemService(Context.ALARM_SERVICE) as AlarmManager
-        
-        val intent = Intent(reactApplicationContext, AlarmReceiver::class.java).apply {
-            action = "com.rnalarmmodule.ALARM_TRIGGER"
-            putExtra("alarmId", id)
-            putExtra("title", title)
-            putExtra("body", body)
-            putExtra("soundUri", soundUri ?: "")
-            putExtra("vibrate", vibrate)
-            putExtra("snoozeMinutes", snoozeMinutes)
-            putExtra("autoStopSeconds", autoStopSeconds)
-        }
-
-        val pendingIntent = PendingIntent.getBroadcast(
-            reactApplicationContext,
-            id.hashCode(),
-            intent,
-            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")
-                }
-            } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
-                alarmManager.setAlarmClock(
-                    AlarmManager.AlarmClockInfo(triggerTimeMillis, pendingIntent),
-                    pendingIntent
-                )
+            val alarmManager = reactApplicationContext.getSystemService(Context.ALARM_SERVICE) as AlarmManager
+            val triggerAt = System.currentTimeMillis() + snoozeMinutes * 60_000L
+            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: ${e.message}", e)
-            throw e
-        }
-    }
-
-    private fun cancelScheduledAlarm(id: String) {
-        val alarmManager = reactApplicationContext.getSystemService(Context.ALARM_SERVICE) as AlarmManager
-        
-        val intent = Intent(reactApplicationContext, AlarmReceiver::class.java).apply {
-            action = "com.rnalarmmodule.ALARM_TRIGGER"
+            Log.d(TAG, "Snoozed alarm for $snoozeMinutes minutes")
+            promise.resolve(null)
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to snooze alarm: ${e.message}")
+            promise.reject("SNOOZE_ERROR", e)
         }
-
-        val pendingIntent = PendingIntent.getBroadcast(
-            reactApplicationContext,
-            id.hashCode(),
-            intent,
-            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
-        )
-
-        alarmManager.cancel(pendingIntent)
-        pendingIntent.cancel()
     }
 
-    private fun getStoredAlarms(): JSONArray {
-        val alarmsJson = prefs.getString(ALARMS_KEY, "[]") ?: "[]"
-        return JSONArray(alarmsJson)
+    @ReactMethod
+    fun addListener(eventName: String) {
+        // Required for NativeEventEmitter
     }
 
-    private fun saveAlarm(alarm: JSONObject) {
-        val alarms = getStoredAlarms()
-        val id = alarm.getString("id")
-        
-        // Remove existing alarm with same ID
-        val filteredAlarms = JSONArray()
-        for (i in 0 until alarms.length()) {
-            val existingAlarm = alarms.getJSONObject(i)
-            if (existingAlarm.getString("id") != id) {
-                filteredAlarms.put(existingAlarm)
-            }
-        }
-        
-        filteredAlarms.put(alarm)
-        prefs.edit().putString(ALARMS_KEY, filteredAlarms.toString()).apply()
+    @ReactMethod
+    fun removeListeners(count: Int) {
+        // Required for NativeEventEmitter
     }
 
-    private fun updateAlarm(alarm: JSONObject) {
-        saveAlarm(alarm)
+    private fun saveAlarm(id: String, datetimeISO: String, title: String, body: String, snoozeEnabled: Boolean = true, snoozeInterval: Int = 5) {
+        val obj = JSONObject()
+            .put("id", id)
+            .put("datetimeISO", datetimeISO)
+            .put("title", title)
+            .put("body", body)
+            .put("snoozeEnabled", snoozeEnabled)
+            .put("snoozeInterval", snoozeInterval)
+        val prefs = reactApplicationContext.getSharedPreferences(PREFS, Context.MODE_PRIVATE)
+        prefs.edit().putString(id, obj.toString()).apply()
     }
 
     private fun removeAlarm(id: String) {
-        val alarms = getStoredAlarms()
-        val filteredAlarms = JSONArray()
-        for (i in 0 until alarms.length()) {
-            val existingAlarm = alarms.getJSONObject(i)
-            if (existingAlarm.getString("id") != id) {
-                filteredAlarms.put(existingAlarm)
-            }
-        }
-        prefs.edit().putString(ALARMS_KEY, filteredAlarms.toString()).apply()
+        val prefs = reactApplicationContext.getSharedPreferences(PREFS, Context.MODE_PRIVATE)
+        prefs.edit().remove(id).apply()
     }
 
-    private fun getAlarmById(id: String): JSONObject? {
-        val alarms = getStoredAlarms()
-        for (i in 0 until alarms.length()) {
-            val alarm = alarms.getJSONObject(i)
-            if (alarm.getString("id") == id) {
-                return alarm
-            }
+    private fun getAlarm(id: String): JSONObject? {
+        val prefs = reactApplicationContext.getSharedPreferences(PREFS, Context.MODE_PRIVATE)
+        val jsonStr = prefs.getString(id, null) ?: return null
+        return try {
+            JSONObject(jsonStr)
+        } catch (_: Exception) {
+            null
         }
-        return null
     }
 }

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

@@ -6,7 +6,6 @@ import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.uimanager.ViewManager
 
 class AlarmPackage : ReactPackage {
-
     override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
         return listOf(AlarmModule(reactContext))
     }