react-native-alarmageddon 1.1.1 → 2.1.0

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

@@ -1,290 +0,0 @@
-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/res/raw/README.md

@@ -1,36 +0,0 @@
-# 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.