react-native-alarmageddon 1.1.1 → 2.1.0

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

@@ -1,183 +1,354 @@
 package com.rnalarmmodule
 
+import com.facebook.react.modules.core.DeviceEventManagerModule.RCTDeviceEventEmitter
+
+import android.app.*
 import android.content.BroadcastReceiver
 import android.content.Context
 import android.content.Intent
+import android.media.*
 import android.os.Build
 import android.os.PowerManager
+import android.widget.Toast
+import androidx.core.app.NotificationCompat
 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"
+        const val ACTION_STOP = "com.rnalarmmodule.ACTION_STOP_ALARM"
+        const val ACTION_SNOOZE = "com.rnalarmmodule.ACTION_SNOOZE_ALARM"
+        private const val CHANNEL_ID = "rn_alarm_module_channel"
+        private const val RAW_RES = "alarm_default"
+        private const val SNOOZE_MINUTES = 5
+        private const val AUTO_STOP_SECONDS = 60
+
+        @Volatile
+        private var player: MediaPlayer? = null
+
+        @Volatile
+        private var audioManager: AudioManager? = null
+
+        @Volatile
+        private var originalVolume: Int = 0
+
+        @Volatile
+        var activeAlarmId: String? = null
+
+        @Volatile
+        private var wakeLock: PowerManager.WakeLock? = null
     }
 
-    override fun onReceive(context: Context, intent: Intent) {
-        Log.d(TAG, "onReceive: action=${intent.action}")
+    override fun onReceive(context: Context, intent: Intent?) {
+        intent ?: return
+        val action = intent.action
+        val id = intent.getStringExtra("id") ?: return
 
-        // 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
+        Log.d(TAG, "onReceive: action=$action id=$id")
 
-        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}")
-                }
+        when (action) {
+            ACTION_STOP -> {
+                stopAlarm(context, id)
+                return
             }
-        } catch (e: Exception) {
-            Log.e(TAG, "Error handling alarm: ${e.message}", e)
-        } finally {
-            if (wakeLock.isHeld) {
-                wakeLock.release()
+
+            ACTION_SNOOZE -> {
+                stopAlarm(context, id)
+                scheduleSnooze(context, intent)
+                return
             }
         }
-    }
 
-    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)
+        val snoozeEnabled = intent.getBooleanExtra("snoozeEnabled", true)
+        val snoozeInterval = intent.getIntExtra("snoozeInterval", SNOOZE_MINUTES)
+        activeAlarmId = id
 
-        Log.d(TAG, "Alarm triggered: id=$alarmId, title=$title")
+        emitActiveAlarmId(activeAlarmId)
 
-        // 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()
+        acquireWakeLock(context)
+        setupAudio(context)
+        playAlarm(context, id)
+        showNotificationWithActions(context, id, title, body, snoozeEnabled, snoozeInterval)
+    }
 
-        // 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)
+    private fun acquireWakeLock(context: Context) {
+        if (wakeLock?.isHeld == true) return
+        val pm = context.getSystemService(Context.POWER_SERVICE) as PowerManager
+        wakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "rnalarmmodule:AlarmWakeLock").apply {
+            setReferenceCounted(false)
+            // Acquire for a bounded time (65s) – alarm auto-stops at 60s.
+            acquire((AUTO_STOP_SECONDS + 5) * 1000L)
         }
+    }
 
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-            context.startForegroundService(serviceIntent)
-        } else {
-            context.startService(serviceIntent)
+    private fun releaseWakeLock() {
+        try {
+            if (wakeLock?.isHeld == true) wakeLock?.release()
+        } catch (_: Exception) {
+        }
+        wakeLock = null
+    }
+
+    private fun setupAudio(context: Context) {
+        if (audioManager == null) {
+            audioManager = context.getSystemService(Context.AUDIO_SERVICE) as AudioManager
         }
+        audioManager?.let { am ->
+            originalVolume = am.getStreamVolume(AudioManager.STREAM_ALARM)
+            val maxVolume = am.getStreamMaxVolume(AudioManager.STREAM_ALARM)
+            am.setStreamVolume(
+                AudioManager.STREAM_ALARM,
+                maxVolume,
+                AudioManager.FLAG_SHOW_UI or AudioManager.FLAG_PLAY_SOUND
+            )
 
-        // Try to emit event to React Native
-        AlarmModule.emitActiveAlarmId(alarmId)
+            val attributes = AudioAttributes.Builder()
+                .setUsage(AudioAttributes.USAGE_ALARM)
+                .setContentType(AudioAttributes.CONTENT_TYPE_SONIFICATION)
+                .build()
 
-        // Launch full-screen activity to wake up screen
-        launchAlarmActivity(context, alarmId, title, body, snoozeMinutes)
-    }
+            val focusRequest = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                AudioFocusRequest.Builder(AudioManager.AUDIOFOCUS_GAIN_TRANSIENT)
+                    .setAudioAttributes(attributes)
+                    .setOnAudioFocusChangeListener {}
+                    .build()
+            } else null
 
-    private fun handleAlarmStop(context: Context, intent: Intent) {
-        val alarmId = intent.getStringExtra("alarmId") ?: return
-        Log.d(TAG, "Stopping alarm: id=$alarmId")
+            @Suppress("DEPRECATION")
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                am.requestAudioFocus(focusRequest!!)
+            } else {
+                am.requestAudioFocus(null, AudioManager.STREAM_ALARM, AudioManager.AUDIOFOCUS_GAIN_TRANSIENT)
+            }
+        }
+    }
 
-        // Stop the alarm service
-        val serviceIntent = Intent(context, AlarmService::class.java).apply {
-            action = AlarmService.ACTION_STOP
-            putExtra("alarmId", alarmId)
+    private fun playAlarm(context: Context, id: String) {
+        player?.let {
+            try {
+                if (it.isPlaying) it.stop()
+            } catch (_: Exception) {
+            }
+            it.release()
         }
-        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()
+        player = MediaPlayer().apply {
+            try {
+                // Try to use custom alarm sound from host app's res/raw folder
+                val resId = context.resources.getIdentifier(RAW_RES, "raw", context.packageName)
+                if (resId != 0) {
+                    setDataSource(
+                        context,
+                        android.net.Uri.parse("android.resource://${context.packageName}/raw/$RAW_RES")
+                    )
+                } else {
+                    // Fallback to default alarm sound
+                    val alarmUri = android.media.RingtoneManager.getDefaultUri(android.media.RingtoneManager.TYPE_ALARM)
+                        ?: android.media.RingtoneManager.getDefaultUri(android.media.RingtoneManager.TYPE_NOTIFICATION)
+                    setDataSource(context, alarmUri)
+                }
+                
+                setAudioAttributes(
+                    AudioAttributes.Builder()
+                        .setUsage(AudioAttributes.USAGE_ALARM)
+                        .setContentType(AudioAttributes.CONTENT_TYPE_SONIFICATION)
+                        .build()
+                )
+                @Suppress("DEPRECATION")
+                setAudioStreamType(AudioManager.STREAM_ALARM)
+                isLooping = true
+                prepare()
+                start()
+                Log.d(TAG, "Alarm sound started for id=$id")
+            } catch (e: Exception) {
+                Log.e(TAG, "Failed to play alarm sound: ${e.message}")
+                e.printStackTrace()
+            }
+        }
 
-        // Emit null to indicate alarm stopped
-        AlarmModule.emitActiveAlarmId(null)
+        // Auto-stop after configured time
+        Thread {
+            try {
+                Thread.sleep(AUTO_STOP_SECONDS * 1000L)
+            } catch (_: InterruptedException) {
+            } finally {
+                if (activeAlarmId == id) {
+                    Log.d(TAG, "Auto-stopping alarm id=$id after ${AUTO_STOP_SECONDS}s")
+                    stopAlarm(context, id)
+                }
+            }
+        }.start()
     }
 
-    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")
+    private fun showNotificationWithActions(context: Context, id: String, title: String, body: String, snoozeEnabled: Boolean = true, snoozeInterval: Int = SNOOZE_MINUTES) {
+        val nm = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
 
-        // Stop current alarm
-        handleAlarmStop(context, intent)
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            val channel = NotificationChannel(
+                CHANNEL_ID, "Alarms", NotificationManager.IMPORTANCE_HIGH
+            ).apply { 
+                setSound(null, null)
+                description = "Alarm notifications"
+            }
+            nm.createNotificationChannel(channel)
+        }
 
-        // 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 stopIntent = Intent(context, AlarmReceiver::class.java).apply {
+            action = ACTION_STOP
+            putExtra("id", id)
+        }
+        val stopPendingIntent = PendingIntent.getBroadcast(
+            context, id.hashCode() + 1, stopIntent,
+            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
         )
 
-        val alarmManager = context.getSystemService(Context.ALARM_SERVICE) as android.app.AlarmManager
+        val snoozePendingIntent = if (snoozeEnabled) {
+            val snoozeIntent = Intent(context, AlarmReceiver::class.java).apply {
+                action = ACTION_SNOOZE
+                putExtra("id", id)
+                putExtra("title", title)
+                putExtra("body", "$body (Snoozed)")
+                putExtra("snoozeMinutes", snoozeInterval)
+                putExtra("snoozeEnabled", snoozeEnabled)
+                putExtra("snoozeInterval", snoozeInterval)
+            }
+            PendingIntent.getBroadcast(
+                context, id.hashCode() + 2, snoozeIntent,
+                PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
+            )
+        } else null
+
+        // Try to get the host app's launcher activity
+        val launchIntent = context.packageManager.getLaunchIntentForPackage(context.packageName)?.apply {
+            flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TASK
+            putExtra("alarm_id", id)
+        }
         
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
-            if (alarmManager.canScheduleExactAlarms()) {
-                alarmManager.setAlarmClock(
-                    android.app.AlarmManager.AlarmClockInfo(snoozeTime, pendingIntent),
-                    pendingIntent
-                )
+        val fullScreenPendingIntent = if (launchIntent != null) {
+            PendingIntent.getActivity(
+                context, 0, launchIntent,
+                PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
+            )
+        } else null
+
+        val builder = NotificationCompat.Builder(context, CHANNEL_ID)
+            .setSmallIcon(android.R.drawable.ic_lock_idle_alarm)
+            .setContentTitle(title)
+            .setContentText(body)
+            .setPriority(NotificationCompat.PRIORITY_HIGH)
+            .setCategory(NotificationCompat.CATEGORY_ALARM)
+            .addAction(android.R.drawable.ic_menu_close_clear_cancel, "Stop", stopPendingIntent)
+            .setOngoing(true)
+            .setSound(null)
+            .setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
+
+        // Only add snooze action if snooze is enabled
+        if (snoozeEnabled && snoozePendingIntent != null) {
+            builder.addAction(android.R.drawable.ic_menu_recent_history, "Snooze", snoozePendingIntent)
+        }
+
+        if (fullScreenPendingIntent != null) {
+            builder.setFullScreenIntent(fullScreenPendingIntent, true)
+            builder.setContentIntent(fullScreenPendingIntent)
+        }
+
+        val notification = builder.build().apply { 
+            flags = flags or Notification.FLAG_NO_CLEAR 
+        }
+
+        nm.notify(id.hashCode(), notification)
+        Log.d(TAG, "Notification shown for alarm id=$id")
+    }
+
+    private fun stopAlarm(context: Context, id: String?) {
+        Log.d(TAG, "Stopping alarm id=$id")
+        
+        player?.apply {
+            try {
+                if (isPlaying) stop()
+            } catch (_: Exception) {
+            }
+            release()
+        }
+        player = null
+
+        audioManager?.let { am ->
+            try {
+                am.setStreamVolume(AudioManager.STREAM_ALARM, originalVolume, 0)
+            } catch (_: Exception) {
+            }
+            @Suppress("DEPRECATION")
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                try {
+                    am.abandonAudioFocusRequest(
+                        AudioFocusRequest.Builder(AudioManager.AUDIOFOCUS_GAIN_TRANSIENT).build()
+                    )
+                } catch (_: Exception) {
+                }
             } else {
-                alarmManager.setAndAllowWhileIdle(
-                    android.app.AlarmManager.RTC_WAKEUP,
-                    snoozeTime,
-                    pendingIntent
-                )
+                am.abandonAudioFocus(null)
             }
-        } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
-            alarmManager.setAlarmClock(
-                android.app.AlarmManager.AlarmClockInfo(snoozeTime, pendingIntent),
-                pendingIntent
-            )
+        }
+
+        releaseWakeLock()
+
+        val nm = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+        id?.let { nm.cancel(it.hashCode()) }
+
+        if (activeAlarmId == id) {
+            activeAlarmId = null
+            emitActiveAlarmId(null)
+        }
+    }
+
+    private fun scheduleSnooze(context: Context, originalIntent: Intent) {
+        val alarmManager = context.getSystemService(Context.ALARM_SERVICE) as AlarmManager
+        val id = originalIntent.getStringExtra("id") ?: return
+        val title = originalIntent.getStringExtra("title") ?: "Alarm"
+        val body = originalIntent.getStringExtra("body") ?: ""
+        val minutes = originalIntent.getIntExtra("snoozeMinutes", SNOOZE_MINUTES)
+
+        val snoozeIntent = Intent(context, AlarmReceiver::class.java).apply {
+            putExtra("id", id)
+            putExtra("title", title)
+            putExtra("body", body)
+        }
+
+        val pendingIntent = PendingIntent.getBroadcast(
+            context, id.hashCode(), snoozeIntent,
+            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
+        )
+
+        val triggerTime = System.currentTimeMillis() + minutes * 60 * 1000
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+            alarmManager.setExactAndAllowWhileIdle(AlarmManager.RTC_WAKEUP, triggerTime, pendingIntent)
         } else {
-            alarmManager.setExact(
-                android.app.AlarmManager.RTC_WAKEUP,
-                snoozeTime,
-                pendingIntent
-            )
+            alarmManager.setExact(AlarmManager.RTC_WAKEUP, triggerTime, pendingIntent)
         }
 
-        Log.d(TAG, "Alarm snoozed and rescheduled for: $snoozeTime")
+        Toast.makeText(context, "Snoozed for $minutes minutes", Toast.LENGTH_SHORT).show()
+        Log.d(TAG, "Alarm $id snoozed for $minutes minutes")
     }
 
-    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)
+    private fun emitActiveAlarmId(id: String?) {
+        // Use AlarmModule's static context reference instead of MainApplication
+        val reactContext = AlarmModule.getReactContext()
+
+        if (reactContext != null && reactContext.hasActiveCatalystInstance()) {
+            try {
+                reactContext
+                    .getJSModule(RCTDeviceEventEmitter::class.java)
+                    .emit("activeAlarmId", id)
+                Log.d(TAG, "Emitted activeAlarmId event: $id")
+            } catch (e: Exception) {
+                Log.e(TAG, "Failed to emit activeAlarmId event: ${e.message}")
             }
-            context.startActivity(activityIntent)
-        } catch (e: Exception) {
-            Log.e(TAG, "Failed to launch alarm activity: ${e.message}", e)
+        } else {
+            Log.w(TAG, "Cannot emit event: ReactContext not available")
         }
     }
 }