react-native-alarmageddon 1.1.1 → 2.1.0

package/src/index.ts

@@ -1,9 +1,8 @@
 import {
   NativeModules,
   NativeEventEmitter,
-  PermissionsAndroid,
   Platform,
-  EmitterSubscription,
+  PermissionsAndroid,
 } from 'react-native';
 
 /**
@@ -12,47 +11,29 @@ import {
 export type AlarmParams = {
   /** Unique identifier for the alarm */
   id: string;
-  /** ISO 8601 datetime string for when the alarm should trigger */
+  /** ISO 8601 timestamp for when the alarm should trigger (e.g., "2025-11-10T08:30:00") */
   datetimeISO: string;
-  /** Title shown in the notification */
+  /** Title to display in the notification */
   title?: string;
-  /** Body text shown in the notification */
+  /** Body text to display in the notification */
   body?: string;
-  /** URI of the sound to play (uses default alarm sound if not provided) */
-  soundUri?: string;
-  /** Whether to vibrate when alarm triggers (default: true) */
-  vibrate?: boolean;
-  /** Number of minutes for snooze (default: 5) */
-  snoozeMinutes?: number;
-  /** Number of seconds before alarm auto-stops (default: 60) */
-  autoStopSeconds?: number;
+  /** Whether snoozing is enabled for this alarm */
+  snoozeEnabled?: boolean;
+  /** Interval in minutes for snoozing */
+  snoozeInterval?: number;
 };
 
 /**
- * Stored alarm data returned from listAlarms
- */
-export type StoredAlarm = {
-  id: string;
-  datetimeISO: string;
-  title: string;
-  body: string;
-  vibrate: boolean;
-  snoozeMinutes: number;
-  autoStopSeconds: number;
-};
-
-/**
- * Permission request result
+ * Result of permission request
  */
 export type PermissionResult = {
   granted: boolean;
-  exactAlarmGranted?: boolean;
 };
 
 /**
- * Active alarm info
+ * Active alarm state
  */
-export type ActiveAlarmInfo = {
+export type ActiveAlarmState = {
   activeAlarmId: string;
 } | null;
 
@@ -62,256 +43,172 @@ export type ActiveAlarmInfo = {
 interface AlarmModuleInterface {
   scheduleAlarm(alarm: AlarmParams): Promise<void>;
   cancelAlarm(id: string): Promise<void>;
-  listAlarms(): Promise<StoredAlarm[]>;
+  listAlarms(): Promise<AlarmParams[]>;
   requestPermissions(): Promise<PermissionResult>;
-  checkExactAlarmPermission(): Promise<boolean>;
-  openExactAlarmSettings(): Promise<void>;
   snoozeAlarm(id: string, minutes: number): Promise<void>;
   stopCurrentAlarm(id: string): Promise<void>;
   snoozeCurrentAlarm(id: string, minutes: number): Promise<void>;
-  getCurrentAlarmPlaying(): Promise<ActiveAlarmInfo>;
-  addListener(eventName: string): void;
-  removeListeners(count: number): void;
-}
-
-const { AlarmModule } = NativeModules as { AlarmModule: AlarmModuleInterface };
-
-// Validate module exists
-if (!AlarmModule) {
-  throw new Error(
-    'react-native-alarmageddon: NativeModule is null. ' +
-      'Ensure you have linked the native module correctly. ' +
-      'On Android, run `npx react-native run-android` to rebuild.'
-  );
-}
+  getCurrentAlarmPlaying(): Promise<ActiveAlarmState>;
+}
+
+const LINKING_ERROR =
+  `The package 'react-native-alarmageddon' doesn't seem to be linked. Make sure: \n\n` +
+  Platform.select({ ios: "- You have run 'pod install'\n", default: '' }) +
+  '- You rebuilt the app after installing the package\n' +
+  '- You are not using Expo Go (Expo managed workflow is not supported)\n';
+
+const AlarmModule: AlarmModuleInterface = NativeModules.AlarmModule
+  ? NativeModules.AlarmModule
+  : new Proxy(
+      {},
+      {
+        get() {
+          throw new Error(LINKING_ERROR);
+        },
+      }
+    );
 
 const eventEmitter = new NativeEventEmitter(NativeModules.AlarmModule);
 
 /**
- * Request notification permission (required on Android 13+)
- * @returns Promise resolving to true if permission granted
+ * Subscription type for event listeners
  */
-async function requestNotificationPermission(): Promise<boolean> {
-  if (Platform.OS !== 'android') {
-    return true;
-  }
-
-  try {
-    if (Platform.Version >= 33) {
-      const status = await PermissionsAndroid.request(
-        'android.permission.POST_NOTIFICATIONS' as any
-      );
-      return status === PermissionsAndroid.RESULTS.GRANTED;
-    }
-    return true;
-  } catch (error) {
-    console.warn('Failed to request notification permission:', error);
-    return false;
-  }
-}
+export type AlarmSubscription = {
+  remove: () => void;
+};
 
 /**
- * Request exact alarm permission (required on Android 12+)
- * Opens system settings if not granted
- * @returns Promise resolving to permission result
+ * Callback type for alarm state changes
  */
-async function requestExactAlarmPermission(): Promise<PermissionResult> {
-  if (Platform.OS !== 'android') {
-    return { granted: true, exactAlarmGranted: true };
-  }
-
-  return AlarmModule.requestPermissions();
-}
+export type AlarmStateCallback = (alarmId: string | null) => void;
 
 /**
- * Check if exact alarm permission is granted
- * @returns Promise resolving to true if permission granted
+ * Ensures notification permissions are granted.
+ * On Android 13+, this will request POST_NOTIFICATIONS permission.
+ * @returns Promise resolving to true if permissions are granted
  */
-async function checkExactAlarmPermission(): Promise<boolean> {
+async function ensurePermissions(): Promise<boolean> {
   if (Platform.OS !== 'android') {
+    // iOS implementation pending
     return true;
   }
 
-  return AlarmModule.checkExactAlarmPermission();
-}
+  try {
+    const status = await AlarmModule.requestPermissions();
+    if (status.granted) {
+      return true;
+    }
 
-/**
- * Open system settings for exact alarm permission
- */
-async function openExactAlarmSettings(): Promise<void> {
-  if (Platform.OS === 'android') {
-    return AlarmModule.openExactAlarmSettings();
-  }
-}
+    // Android 13+ requires explicit POST_NOTIFICATIONS permission
+    if (Platform.Version >= 33) {
+      const result = await PermissionsAndroid.request(
+        'android.permission.POST_NOTIFICATIONS' as any
+      );
+      return result === PermissionsAndroid.RESULTS.GRANTED;
+    }
 
-/**
- * Ensure all required permissions are granted
- * Requests both notification and exact alarm permissions
- * @returns Promise resolving to true if all permissions granted
- */
-async function ensurePermissions(): Promise<boolean> {
-  if (Platform.OS !== 'android') {
     return true;
+  } catch (error) {
+    console.warn('react-native-alarmageddon: Failed to request permissions', error);
+    return false;
   }
-
-  const [notificationGranted, exactAlarmResult] = await Promise.all([
-    requestNotificationPermission(),
-    requestExactAlarmPermission(),
-  ]);
-
-  return notificationGranted && exactAlarmResult.granted;
 }
 
 /**
- * Schedule an alarm
- * @param alarm - Alarm parameters
+ * Schedule an alarm to trigger at a specific time.
+ * The alarm will persist through device reboots.
+ * @param alarm - Alarm parameters including id, datetime, title, and body
  */
 async function scheduleAlarm(alarm: AlarmParams): Promise<void> {
-  if (!alarm.id) {
-    throw new Error('Alarm ID is required');
-  }
-  if (!alarm.datetimeISO) {
-    throw new Error('datetimeISO is required');
-  }
-
   return AlarmModule.scheduleAlarm(alarm);
 }
 
 /**
- * Cancel a scheduled alarm
- * @param id - Alarm ID to cancel
+ * Cancel a scheduled alarm by its ID.
+ * @param id - The unique identifier of the alarm to cancel
  */
 async function cancelAlarm(id: string): Promise<void> {
-  if (!id) {
-    throw new Error('Alarm ID is required');
-  }
   return AlarmModule.cancelAlarm(id);
 }
 
 /**
- * List all scheduled alarms
- * @returns Promise resolving to array of stored alarms
+ * List all currently scheduled alarms.
+ * @returns Promise resolving to an array of alarm parameters
  */
-async function listAlarms(): Promise<StoredAlarm[]> {
+async function listAlarms(): Promise<AlarmParams[]> {
   return AlarmModule.listAlarms();
 }
 
 /**
- * Snooze an alarm for a specified number of minutes
- * @param id - Alarm ID to snooze
- * @param minutes - Number of minutes to snooze (default: 5)
+ * Request alarm and notification permissions.
+ * @returns Promise resolving to permission result
  */
-async function snoozeAlarm(id: string, minutes: number = 5): Promise<void> {
-  if (!id) {
-    throw new Error('Alarm ID is required');
-  }
+async function requestPermissions(): Promise<PermissionResult> {
+  return AlarmModule.requestPermissions();
+}
+
+/**
+ * Snooze an alarm by scheduling a new one for the specified minutes.
+ * @param id - The alarm ID (used for the new snoozed alarm)
+ * @param minutes - Number of minutes to snooze
+ */
+async function snoozeAlarm(id: string, minutes: number): Promise<void> {
   return AlarmModule.snoozeAlarm(id, minutes);
 }
 
 /**
- * Stop the currently playing alarm
- * @param id - Alarm ID to stop
+ * Stop the currently ringing alarm.
+ * @param id - The ID of the alarm to stop
  */
 async function stopCurrentAlarm(id: string): Promise<void> {
-  if (!id) {
-    throw new Error('Alarm ID is required');
-  }
   return AlarmModule.stopCurrentAlarm(id);
 }
 
 /**
- * Snooze the currently playing alarm
- * @param id - Alarm ID to snooze
- * @param minutes - Number of minutes to snooze (default: 5)
+ * Snooze the currently ringing alarm.
+ * @param id - The ID of the alarm to snooze
+ * @param minutes - Number of minutes to snooze
  */
-async function snoozeCurrentAlarm(id: string, minutes: number = 5): Promise<void> {
-  if (!id) {
-    throw new Error('Alarm ID is required');
-  }
+async function snoozeCurrentAlarm(id: string, minutes: number): Promise<void> {
   return AlarmModule.snoozeCurrentAlarm(id, minutes);
 }
 
 /**
- * Get the currently playing alarm (if any)
- * @returns Promise resolving to active alarm info or null
+ * Get the currently playing alarm, if any.
+ * @returns Promise resolving to the active alarm state or null
  */
-async function getCurrentAlarmPlaying(): Promise<ActiveAlarmInfo> {
+async function getCurrentAlarmPlaying(): Promise<ActiveAlarmState> {
   return AlarmModule.getCurrentAlarmPlaying();
 }
 
 /**
- * Subscribe to alarm state changes
- * Callback receives the alarm ID when an alarm starts, or null when stopped
- * @param callback - Function called when alarm state changes
- * @returns Cleanup function to remove the subscription
- */
-function onAlarmStateChange(
-  callback: (alarmId: string | null) => void
-): () => void {
-  const subscription: EmitterSubscription = eventEmitter.addListener(
-    'activeAlarmId',
-    callback
-  );
-  return () => subscription.remove();
-}
-
-/**
- * Add event listener for alarm state changes
- * @param event - Event name ('activeAlarmId')
- * @param callback - Callback function
- * @returns EmitterSubscription for removal
+ * Subscribe to alarm state changes.
+ * The callback will be invoked when an alarm starts or stops ringing.
+ * @param callback - Function called with the alarm ID (or null when stopped)
+ * @returns Subscription object with remove() method to unsubscribe
  */
-function addEventListener(
-  event: 'activeAlarmId',
-  callback: (alarmId: string | null) => void
-): EmitterSubscription {
-  return eventEmitter.addListener(event, callback);
+function onAlarmStateChange(callback: AlarmStateCallback): AlarmSubscription {
+  const subscription = eventEmitter.addListener('activeAlarmId', callback);
+  return {
+    remove: () => subscription.remove(),
+  };
 }
 
 /**
- * Main module export with all alarm functions
+ * React Native Alarmageddon - Native exact alarm scheduling
  */
 const RNAlarmModule = {
-  // Permissions
   ensurePermissions,
-  requestNotificationPermission,
-  requestExactAlarmPermission,
-  checkExactAlarmPermission,
-  openExactAlarmSettings,
-
-  // Alarm management
   scheduleAlarm,
   cancelAlarm,
   listAlarms,
+  requestPermissions,
   snoozeAlarm,
-
-  // Active alarm control
   stopCurrentAlarm,
   snoozeCurrentAlarm,
   getCurrentAlarmPlaying,
-
-  // Event handling
   onAlarmStateChange,
-  addEventListener,
 };
 
 export default RNAlarmModule;
-export { RNAlarmModule };
-
-// Export individual functions for tree-shaking
-export {
-  ensurePermissions,
-  requestNotificationPermission,
-  requestExactAlarmPermission,
-  checkExactAlarmPermission,
-  openExactAlarmSettings,
-  scheduleAlarm,
-  cancelAlarm,
-  listAlarms,
-  snoozeAlarm,
-  stopCurrentAlarm,
-  snoozeCurrentAlarm,
-  getCurrentAlarmPlaying,
-  onAlarmStateChange,
-  addEventListener,
-};
+export { RNAlarmModule };

package/android/gradle.properties

@@ -1,13 +0,0 @@
-# React Native Alarmageddon Android Build Configuration
-
-# Version of Kotlin to use
-AlarmModule_kotlinVersion=1.9.22
-
-# Android SDK versions
-AlarmModule_compileSdkVersion=34
-AlarmModule_minSdkVersion=21
-AlarmModule_targetSdkVersion=34
-
-# Build configuration
-android.useAndroidX=true
-android.enableJetifier=true

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

@@ -1,79 +0,0 @@
-package com.rnalarmmodule
-
-import android.app.Activity
-import android.app.KeyguardManager
-import android.content.Context
-import android.os.Build
-import android.os.Bundle
-import android.util.Log
-import android.view.WindowManager
-
-class AlarmActivity : Activity() {
-
-    companion object {
-        private const val TAG = "AlarmActivity"
-    }
-
-    override fun onCreate(savedInstanceState: Bundle?) {
-        super.onCreate(savedInstanceState)
-        
-        Log.d(TAG, "onCreate - waking up screen for alarm")
-
-        // Enable showing on lock screen and turning screen on
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O_MR1) {
-            setShowWhenLocked(true)
-            setTurnScreenOn(true)
-            
-            val keyguardManager = getSystemService(Context.KEYGUARD_SERVICE) as KeyguardManager
-            keyguardManager.requestDismissKeyguard(this, null)
-        } else {
-            @Suppress("DEPRECATION")
-            window.addFlags(
-                WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED or
-                WindowManager.LayoutParams.FLAG_DISMISS_KEYGUARD or
-                WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON or
-                WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON
-            )
-        }
-
-        // Keep screen on while alarm is active
-        window.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON)
-
-        // Get alarm details from intent
-        val alarmId = intent.getStringExtra("alarmId")
-        val title = intent.getStringExtra("title") ?: "Alarm"
-        val body = intent.getStringExtra("body") ?: ""
-        val snoozeMinutes = intent.getIntExtra("snoozeMinutes", 5)
-
-        Log.d(TAG, "Alarm triggered: id=$alarmId, title=$title")
-
-        // Try to launch the main app
-        launchMainApp(alarmId)
-    }
-
-    private fun launchMainApp(alarmId: String?) {
-        try {
-            val launchIntent = packageManager.getLaunchIntentForPackage(packageName)
-            if (launchIntent != null) {
-                launchIntent.addFlags(
-                    android.content.Intent.FLAG_ACTIVITY_NEW_TASK or
-                    android.content.Intent.FLAG_ACTIVITY_CLEAR_TOP or
-                    android.content.Intent.FLAG_ACTIVITY_SINGLE_TOP
-                )
-                launchIntent.putExtra("alarmId", alarmId)
-                launchIntent.putExtra("fromAlarm", true)
-                startActivity(launchIntent)
-            }
-        } catch (e: Exception) {
-            Log.e(TAG, "Failed to launch main app: ${e.message}", e)
-        }
-
-        // Finish this transparent activity
-        finish()
-    }
-
-    override fun onDestroy() {
-        super.onDestroy()
-        Log.d(TAG, "onDestroy")
-    }
-}