react-native-alarmageddon 1.0.0

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

@@ -0,0 +1,485 @@
+package com.rnalarmmodule
+
+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 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 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 DATE_PATTERN = "yyyy-MM-dd'T'HH:mm:ss"
+        private const val ACTIVE_ALARM_KEY = "active_alarm_id"
+
+        // Weak reference to avoid memory leaks
+        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 {
+        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")
+            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) {
+        try {
+            cancelScheduledAlarm(id)
+            removeAlarm(id)
+            Log.d(TAG, "Alarm cancelled: id=$id")
+            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)
+        }
+    }
+
+    @ReactMethod
+    fun listAlarms(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)
+            }
+            promise.resolve(result)
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to list alarms: ${e.message}", e)
+            promise.reject("LIST_ERROR", "Failed to list alarms: ${e.message}", 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)
+        }
+    }
+
+    @ReactMethod
+    fun checkExactAlarmPermission(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
+            }
+            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)
+            }
+            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)
+            )
+
+            Log.d(TAG, "Alarm snoozed: id=$id, new trigger=$snoozeTime")
+            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)
+        }
+    }
+
+    @ReactMethod
+    fun stopCurrentAlarm(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")
+            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)
+        }
+    }
+
+    @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)
+            }
+            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)
+        }
+    }
+
+    @ReactMethod
+    fun getCurrentAlarmPlaying(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)
+            }
+        } 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())
+            )
+            
+            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
+                )
+            } else {
+                alarmManager.setExact(
+                    AlarmManager.RTC_WAKEUP,
+                    triggerTimeMillis,
+                    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"
+        }
+
+        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)
+    }
+
+    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()
+    }
+
+    private fun updateAlarm(alarm: JSONObject) {
+        saveAlarm(alarm)
+    }
+
+    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()
+    }
+
+    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
+            }
+        }
+        return null
+    }
+}

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

@@ -0,0 +1,17 @@
+package com.rnalarmmodule
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+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))
+    }
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+        return emptyList()
+    }
+}

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

@@ -0,0 +1,183 @@
+package com.rnalarmmodule
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.os.Build
+import android.os.PowerManager
+import android.util.Log
+
+class AlarmReceiver : BroadcastReceiver() {
+
+    companion object {
+        private const val TAG = "AlarmReceiver"
+        const val ACTION_TRIGGER = "com.rnalarmmodule.ALARM_TRIGGER"
+        const val ACTION_STOP = "com.rnalarmmodule.ALARM_STOP"
+        const val ACTION_SNOOZE = "com.rnalarmmodule.ALARM_SNOOZE"
+    }
+
+    override fun onReceive(context: Context, intent: Intent) {
+        Log.d(TAG, "onReceive: action=${intent.action}")
+
+        // Acquire wake lock to ensure device stays awake
+        val powerManager = context.getSystemService(Context.POWER_SERVICE) as PowerManager
+        val wakeLock = powerManager.newWakeLock(
+            PowerManager.PARTIAL_WAKE_LOCK or PowerManager.ACQUIRE_CAUSES_WAKEUP,
+            "AlarmModule:AlarmWakeLock"
+        )
+        wakeLock.acquire(60 * 1000L) // 60 seconds max
+
+        try {
+            when (intent.action) {
+                ACTION_TRIGGER -> handleAlarmTrigger(context, intent)
+                ACTION_STOP -> handleAlarmStop(context, intent)
+                ACTION_SNOOZE -> handleAlarmSnooze(context, intent)
+                else -> {
+                    Log.w(TAG, "Unknown action: ${intent.action}")
+                }
+            }
+        } catch (e: Exception) {
+            Log.e(TAG, "Error handling alarm: ${e.message}", e)
+        } finally {
+            if (wakeLock.isHeld) {
+                wakeLock.release()
+            }
+        }
+    }
+
+    private fun handleAlarmTrigger(context: Context, intent: Intent) {
+        val alarmId = intent.getStringExtra("alarmId") ?: return
+        val title = intent.getStringExtra("title") ?: "Alarm"
+        val body = intent.getStringExtra("body") ?: ""
+        val soundUri = intent.getStringExtra("soundUri") ?: ""
+        val vibrate = intent.getBooleanExtra("vibrate", true)
+        val snoozeMinutes = intent.getIntExtra("snoozeMinutes", 5)
+        val autoStopSeconds = intent.getIntExtra("autoStopSeconds", 60)
+
+        Log.d(TAG, "Alarm triggered: id=$alarmId, title=$title")
+
+        // Store active alarm ID in SharedPreferences
+        val prefs = context.getSharedPreferences("rn_alarm_module_alarms", Context.MODE_PRIVATE)
+        prefs.edit().putString("active_alarm_id", alarmId).apply()
+
+        // Start the alarm service
+        val serviceIntent = Intent(context, AlarmService::class.java).apply {
+            action = AlarmService.ACTION_START
+            putExtra("alarmId", alarmId)
+            putExtra("title", title)
+            putExtra("body", body)
+            putExtra("soundUri", soundUri)
+            putExtra("vibrate", vibrate)
+            putExtra("snoozeMinutes", snoozeMinutes)
+            putExtra("autoStopSeconds", autoStopSeconds)
+        }
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            context.startForegroundService(serviceIntent)
+        } else {
+            context.startService(serviceIntent)
+        }
+
+        // Try to emit event to React Native
+        AlarmModule.emitActiveAlarmId(alarmId)
+
+        // Launch full-screen activity to wake up screen
+        launchAlarmActivity(context, alarmId, title, body, snoozeMinutes)
+    }
+
+    private fun handleAlarmStop(context: Context, intent: Intent) {
+        val alarmId = intent.getStringExtra("alarmId") ?: return
+        Log.d(TAG, "Stopping alarm: id=$alarmId")
+
+        // Stop the alarm service
+        val serviceIntent = Intent(context, AlarmService::class.java).apply {
+            action = AlarmService.ACTION_STOP
+            putExtra("alarmId", alarmId)
+        }
+        context.stopService(serviceIntent)
+
+        // Clear active alarm state
+        val prefs = context.getSharedPreferences("rn_alarm_module_alarms", Context.MODE_PRIVATE)
+        prefs.edit().remove("active_alarm_id").apply()
+
+        // Emit null to indicate alarm stopped
+        AlarmModule.emitActiveAlarmId(null)
+    }
+
+    private fun handleAlarmSnooze(context: Context, intent: Intent) {
+        val alarmId = intent.getStringExtra("alarmId") ?: return
+        val snoozeMinutes = intent.getIntExtra("snoozeMinutes", 5)
+        Log.d(TAG, "Snoozing alarm: id=$alarmId, minutes=$snoozeMinutes")
+
+        // Stop current alarm
+        handleAlarmStop(context, intent)
+
+        // Reschedule the alarm
+        val snoozeTime = System.currentTimeMillis() + (snoozeMinutes * 60 * 1000L)
+        
+        val triggerIntent = Intent(context, AlarmReceiver::class.java).apply {
+            action = ACTION_TRIGGER
+            putExtra("alarmId", alarmId)
+            putExtra("title", intent.getStringExtra("title") ?: "Alarm")
+            putExtra("body", intent.getStringExtra("body") ?: "")
+            putExtra("soundUri", intent.getStringExtra("soundUri") ?: "")
+            putExtra("vibrate", intent.getBooleanExtra("vibrate", true))
+            putExtra("snoozeMinutes", snoozeMinutes)
+            putExtra("autoStopSeconds", intent.getIntExtra("autoStopSeconds", 60))
+        }
+
+        val pendingIntent = android.app.PendingIntent.getBroadcast(
+            context,
+            alarmId.hashCode(),
+            triggerIntent,
+            android.app.PendingIntent.FLAG_UPDATE_CURRENT or android.app.PendingIntent.FLAG_IMMUTABLE
+        )
+
+        val alarmManager = context.getSystemService(Context.ALARM_SERVICE) as android.app.AlarmManager
+        
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+            if (alarmManager.canScheduleExactAlarms()) {
+                alarmManager.setAlarmClock(
+                    android.app.AlarmManager.AlarmClockInfo(snoozeTime, pendingIntent),
+                    pendingIntent
+                )
+            } else {
+                alarmManager.setAndAllowWhileIdle(
+                    android.app.AlarmManager.RTC_WAKEUP,
+                    snoozeTime,
+                    pendingIntent
+                )
+            }
+        } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+            alarmManager.setAlarmClock(
+                android.app.AlarmManager.AlarmClockInfo(snoozeTime, pendingIntent),
+                pendingIntent
+            )
+        } else {
+            alarmManager.setExact(
+                android.app.AlarmManager.RTC_WAKEUP,
+                snoozeTime,
+                pendingIntent
+            )
+        }
+
+        Log.d(TAG, "Alarm snoozed and rescheduled for: $snoozeTime")
+    }
+
+    private fun launchAlarmActivity(context: Context, alarmId: String, title: String, body: String, snoozeMinutes: Int) {
+        try {
+            val activityIntent = Intent(context, AlarmActivity::class.java).apply {
+                flags = Intent.FLAG_ACTIVITY_NEW_TASK or 
+                        Intent.FLAG_ACTIVITY_CLEAR_TOP or 
+                        Intent.FLAG_ACTIVITY_SINGLE_TOP
+                putExtra("alarmId", alarmId)
+                putExtra("title", title)
+                putExtra("body", body)
+                putExtra("snoozeMinutes", snoozeMinutes)
+            }
+            context.startActivity(activityIntent)
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to launch alarm activity: ${e.message}", e)
+        }
+    }
+}