react-native-alarmageddon 1.0.0

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

@@ -0,0 +1,290 @@
+package com.rnalarmmodule
+
+import android.app.Notification
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.app.PendingIntent
+import android.app.Service
+import android.content.Context
+import android.content.Intent
+import android.media.AudioAttributes
+import android.media.AudioManager
+import android.media.MediaPlayer
+import android.media.RingtoneManager
+import android.net.Uri
+import android.os.Build
+import android.os.Handler
+import android.os.IBinder
+import android.os.Looper
+import android.os.VibrationEffect
+import android.os.Vibrator
+import android.os.VibratorManager
+import android.util.Log
+import androidx.core.app.NotificationCompat
+
+class AlarmService : Service() {
+
+    companion object {
+        private const val TAG = "AlarmService"
+        private const val NOTIFICATION_ID = 1001
+        private const val CHANNEL_ID = "alarm_channel"
+        private const val CHANNEL_NAME = "Alarm Notifications"
+
+        const val ACTION_START = "com.rnalarmmodule.ACTION_START"
+        const val ACTION_STOP = "com.rnalarmmodule.ACTION_STOP"
+    }
+
+    private var mediaPlayer: MediaPlayer? = null
+    private var vibrator: Vibrator? = null
+    private var autoStopHandler: Handler? = null
+    private var autoStopRunnable: Runnable? = null
+    private var currentAlarmId: String? = null
+
+    override fun onCreate() {
+        super.onCreate()
+        createNotificationChannel()
+    }
+
+    override fun onBind(intent: Intent?): IBinder? = null
+
+    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+        when (intent?.action) {
+            ACTION_START -> {
+                val alarmId = intent.getStringExtra("alarmId") ?: "unknown"
+                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)
+
+                currentAlarmId = alarmId
+                startForeground(NOTIFICATION_ID, createNotification(alarmId, title, body, snoozeMinutes))
+                startAlarm(soundUri, vibrate, autoStopSeconds)
+            }
+            ACTION_STOP -> {
+                stopAlarm()
+                stopForeground(STOP_FOREGROUND_REMOVE)
+                stopSelf()
+            }
+        }
+        return START_NOT_STICKY
+    }
+
+    override fun onDestroy() {
+        stopAlarm()
+        super.onDestroy()
+    }
+
+    private fun createNotificationChannel() {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            val channel = NotificationChannel(
+                CHANNEL_ID,
+                CHANNEL_NAME,
+                NotificationManager.IMPORTANCE_HIGH
+            ).apply {
+                description = "Alarm notifications"
+                setBypassDnd(true)
+                lockscreenVisibility = Notification.VISIBILITY_PUBLIC
+                setSound(null, null) // We handle sound separately
+                enableVibration(false) // We handle vibration separately
+            }
+
+            val notificationManager = getSystemService(NotificationManager::class.java)
+            notificationManager?.createNotificationChannel(channel)
+        }
+    }
+
+    private fun createNotification(alarmId: String, title: String, body: String, snoozeMinutes: Int): Notification {
+        // Stop action
+        val stopIntent = Intent(this, AlarmReceiver::class.java).apply {
+            action = AlarmReceiver.ACTION_STOP
+            putExtra("alarmId", alarmId)
+        }
+        val stopPendingIntent = PendingIntent.getBroadcast(
+            this,
+            alarmId.hashCode() + 1,
+            stopIntent,
+            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
+        )
+
+        // Snooze action
+        val snoozeIntent = Intent(this, AlarmReceiver::class.java).apply {
+            action = AlarmReceiver.ACTION_SNOOZE
+            putExtra("alarmId", alarmId)
+            putExtra("snoozeMinutes", snoozeMinutes)
+        }
+        val snoozePendingIntent = PendingIntent.getBroadcast(
+            this,
+            alarmId.hashCode() + 2,
+            snoozeIntent,
+            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
+        )
+
+        // Full screen intent to open app
+        val fullScreenIntent = packageManager.getLaunchIntentForPackage(packageName)?.apply {
+            flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP
+            putExtra("alarmId", alarmId)
+        }
+        val fullScreenPendingIntent = fullScreenIntent?.let {
+            PendingIntent.getActivity(
+                this,
+                alarmId.hashCode() + 3,
+                it,
+                PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
+            )
+        }
+
+        val builder = NotificationCompat.Builder(this, CHANNEL_ID)
+            .setContentTitle(title)
+            .setContentText(body)
+            .setSmallIcon(android.R.drawable.ic_lock_idle_alarm)
+            .setPriority(NotificationCompat.PRIORITY_MAX)
+            .setCategory(NotificationCompat.CATEGORY_ALARM)
+            .setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
+            .setOngoing(true)
+            .setAutoCancel(false)
+            .addAction(android.R.drawable.ic_menu_close_clear_cancel, "Stop", stopPendingIntent)
+            .addAction(android.R.drawable.ic_popup_sync, "Snooze ($snoozeMinutes min)", snoozePendingIntent)
+
+        if (fullScreenPendingIntent != null) {
+            builder.setFullScreenIntent(fullScreenPendingIntent, true)
+            builder.setContentIntent(fullScreenPendingIntent)
+        }
+
+        return builder.build()
+    }
+
+    private fun startAlarm(soundUri: String, vibrate: Boolean, autoStopSeconds: Int) {
+        Log.d(TAG, "Starting alarm: soundUri=$soundUri, vibrate=$vibrate, autoStop=${autoStopSeconds}s")
+
+        // Start sound
+        try {
+            mediaPlayer?.release()
+            mediaPlayer = MediaPlayer().apply {
+                setAudioAttributes(
+                    AudioAttributes.Builder()
+                        .setUsage(AudioAttributes.USAGE_ALARM)
+                        .setContentType(AudioAttributes.CONTENT_TYPE_SONIFICATION)
+                        .build()
+                )
+
+                val uri = if (soundUri.isNotEmpty()) {
+                    try {
+                        Uri.parse(soundUri)
+                    } catch (e: Exception) {
+                        getDefaultAlarmUri()
+                    }
+                } else {
+                    getDefaultAlarmUri()
+                }
+
+                try {
+                    setDataSource(this@AlarmService, uri)
+                } catch (e: Exception) {
+                    Log.w(TAG, "Failed to set data source, using default: ${e.message}")
+                    setDataSource(this@AlarmService, getDefaultAlarmUri())
+                }
+
+                isLooping = true
+                
+                // Set volume to max for alarm
+                val audioManager = getSystemService(Context.AUDIO_SERVICE) as AudioManager
+                val maxVolume = audioManager.getStreamMaxVolume(AudioManager.STREAM_ALARM)
+                audioManager.setStreamVolume(AudioManager.STREAM_ALARM, maxVolume, 0)
+
+                prepare()
+                start()
+            }
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to start alarm sound: ${e.message}", e)
+        }
+
+        // Start vibration
+        if (vibrate) {
+            startVibration()
+        }
+
+        // Schedule auto-stop
+        if (autoStopSeconds > 0) {
+            autoStopHandler = Handler(Looper.getMainLooper())
+            autoStopRunnable = Runnable {
+                Log.d(TAG, "Auto-stopping alarm after ${autoStopSeconds}s")
+                stopAlarm()
+                stopForeground(STOP_FOREGROUND_REMOVE)
+                stopSelf()
+                
+                // Clear active alarm state
+                val prefs = getSharedPreferences("rn_alarm_module_alarms", Context.MODE_PRIVATE)
+                prefs.edit().remove("active_alarm_id").apply()
+                AlarmModule.emitActiveAlarmId(null)
+            }
+            autoStopHandler?.postDelayed(autoStopRunnable!!, autoStopSeconds * 1000L)
+        }
+    }
+
+    private fun getDefaultAlarmUri(): Uri {
+        // Try to get default alarm sound
+        var uri = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_ALARM)
+        if (uri == null) {
+            uri = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION)
+        }
+        if (uri == null) {
+            uri = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_RINGTONE)
+        }
+        return uri ?: Uri.parse("android.resource://${packageName}/${R.raw.alarm_default}")
+    }
+
+    private fun startVibration() {
+        try {
+            vibrator = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+                val vibratorManager = getSystemService(Context.VIBRATOR_MANAGER_SERVICE) as VibratorManager
+                vibratorManager.defaultVibrator
+            } else {
+                @Suppress("DEPRECATION")
+                getSystemService(Context.VIBRATOR_SERVICE) as Vibrator
+            }
+
+            // Vibration pattern: wait 0ms, vibrate 500ms, wait 500ms, repeat
+            val pattern = longArrayOf(0, 500, 500, 500, 500, 500)
+            
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                val effect = VibrationEffect.createWaveform(pattern, 0) // 0 = repeat from index 0
+                vibrator?.vibrate(effect)
+            } else {
+                @Suppress("DEPRECATION")
+                vibrator?.vibrate(pattern, 0)
+            }
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to start vibration: ${e.message}", e)
+        }
+    }
+
+    private fun stopAlarm() {
+        Log.d(TAG, "Stopping alarm")
+
+        // Stop sound
+        try {
+            mediaPlayer?.stop()
+            mediaPlayer?.release()
+            mediaPlayer = null
+        } catch (e: Exception) {
+            Log.e(TAG, "Error stopping media player: ${e.message}", e)
+        }
+
+        // Stop vibration
+        try {
+            vibrator?.cancel()
+            vibrator = null
+        } catch (e: Exception) {
+            Log.e(TAG, "Error stopping vibration: ${e.message}", e)
+        }
+
+        // Cancel auto-stop
+        autoStopRunnable?.let { autoStopHandler?.removeCallbacks(it) }
+        autoStopHandler = null
+        autoStopRunnable = null
+
+        currentAlarmId = null
+    }
+}

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

@@ -0,0 +1,156 @@
+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.os.Build
+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"
+    }
+
+    override fun onReceive(context: Context, intent: Intent) {
+        val action = intent.action
+        Log.d(TAG, "onReceive: action=$action")
+
+        when (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")
+            }
+        }
+    }
+
+    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)
+
+            val currentTime = System.currentTimeMillis()
+            val validAlarms = JSONArray()
+            var rescheduledCount = 0
+
+            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)
+
+                // 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")
+                }
+            }
+
+            // 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 pendingIntent = PendingIntent.getBroadcast(
+            context,
+            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 for: $id")
+                }
+            } 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 $id: ${e.message}", e)
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to schedule alarm $id: ${e.message}", e)
+        }
+    }
+}

package/android/src/main/res/raw/README.md

@@ -0,0 +1,36 @@
+# Alarm Sound Resources
+
+This directory contains the default alarm sound for the react-native-alarmageddon library.
+
+## Default Alarm Sound
+
+The library looks for `alarm_default.wav` (or `.mp3`, `.ogg`) in this directory as a fallback when:
+1. No custom sound URI is provided
+2. The system's default alarm sound cannot be loaded
+
+## Adding Your Own Default Sound
+
+To include a default alarm sound with the library:
+
+1. Add your audio file to this directory with one of these names:
+   - `alarm_default.wav`
+   - `alarm_default.mp3`
+   - `alarm_default.ogg`
+
+2. The file should be:
+   - A short, loopable alarm sound (5-15 seconds recommended)
+   - Optimized for size
+   - Clear and alerting
+
+## Sound Priority
+
+The library uses sounds in this order:
+1. Custom `soundUri` provided in `scheduleAlarm()` params
+2. Android system's default alarm sound (`RingtoneManager.TYPE_ALARM`)
+3. Android system's default notification sound
+4. Android system's default ringtone
+5. The `alarm_default` file from this directory (if exists)
+
+## Note
+
+Since the system default alarm sound is usually available on all Android devices, you may not need to include a custom sound file. The library will gracefully fall back to system sounds.

package/ios/AlarmModule.swift

@@ -0,0 +1,79 @@
+import Foundation
+import React
+
+@objc(AlarmModule)
+class AlarmModule: RCTEventEmitter {
+    
+    private var hasListeners = false
+    
+    override init() {
+        super.init()
+    }
+    
+    @objc override static func requiresMainQueueSetup() -> Bool {
+        return false
+    }
+    
+    override func supportedEvents() -> [String]! {
+        return ["activeAlarmId"]
+    }
+    
+    override func startObserving() {
+        hasListeners = true
+    }
+    
+    override func stopObserving() {
+        hasListeners = false
+    }
+    
+    @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)
+    }
+    
+    @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)
+    }
+    
+    @objc func listAlarms(_ resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
+        // iOS stub - return empty array
+        resolve([])
+    }
+    
+    @objc func requestPermissions(_ resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
+        // iOS stub - would request notification permissions
+        resolve(["granted": true, "exactAlarmGranted": true])
+    }
+    
+    @objc func checkExactAlarmPermission(_ resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
+        // iOS doesn't have exact alarm permission concept
+        resolve(true)
+    }
+    
+    @objc func openExactAlarmSettings(_ resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
+        // iOS stub - no equivalent
+        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 func stopCurrentAlarm(_ alarmId: String, resolver resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
+        // iOS stub
+        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)
+    }
+    
+    @objc func getCurrentAlarmPlaying(_ resolve: @escaping RCTPromiseResolveBlock, rejecter reject: @escaping RCTPromiseRejectBlock) {
+        // iOS stub - no alarm playing
+        resolve(nil)
+    }
+}

package/ios/RNAlarmModule-Bridging-Header.h

@@ -0,0 +1,3 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+#import <React/RCTUtils.h>

package/ios/RNAlarmModule.m

@@ -0,0 +1,48 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+
+@interface RCT_EXTERN_MODULE(AlarmModule, RCTEventEmitter)
+
+RCT_EXTERN_METHOD(scheduleAlarm:(NSDictionary *)alarm
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(cancelAlarm:(NSString *)alarmId
+                  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
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(stopCurrentAlarm:(NSString *)alarmId
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(snoozeCurrentAlarm:(NSString *)alarmId
+                  minutes:(nonnull NSNumber *)minutes
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(getCurrentAlarmPlaying:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
++ (BOOL)requiresMainQueueSetup
+{
+  return NO;
+}
+
+@end