@umituz/react-native-notifications 1.0.5 → 1.1.0

package/src/infrastructure/services/NotificationManager.ts

@@ -1,42 +1,24 @@
 /**
- * NotificationManager
+ * NotificationManager - Core Notification Operations
  *
  * Offline-first notification system using expo-notifications.
  * Works in ALL apps (offline, online, hybrid) - no backend required.
- *
- * Features:
- * - Schedule notifications for specific dates/times
- * - Repeating notifications (daily, weekly, monthly)
- * - Android notification channels
- * - Permission handling
- * - Cancel individual or all notifications
- * - Works completely offline
- *
- * Use Cases:
- * - Reminders (bills, tasks, appointments)
- * - Habit tracking (daily streaks)
- * - Medication reminders
- * - Any app needing local notifications
- *
- * @module NotificationManager
  */
 
 import * as Notifications from 'expo-notifications';
 import * as Device from 'expo-device';
 import { Platform } from 'react-native';
+import { NotificationPermissions } from './NotificationPermissions';
+import { NotificationScheduler } from './NotificationScheduler';
+import { NotificationBadgeManager } from './NotificationBadgeManager';
+import { devLog, devError } from '../utils/dev';
 
-/**
- * Trigger types for notifications
- */
 export type NotificationTrigger =
   | { type: 'date'; date: Date }
   | { type: 'daily'; hour: number; minute: number }
   | { type: 'weekly'; weekday: number; hour: number; minute: number }
   | { type: 'monthly'; day: number; hour: number; minute: number };
 
-/**
- * Options for scheduling a notification
- */
 export interface ScheduleNotificationOptions {
   title: string;
   body: string;
@@ -47,9 +29,6 @@ export interface ScheduleNotificationOptions {
   categoryIdentifier?: string;
 }
 
-/**
- * Scheduled notification details
- */
 export interface ScheduledNotification {
   identifier: string;
   content: {
@@ -60,16 +39,17 @@ export interface ScheduledNotification {
   trigger: any;
 }
 
-/**
- * NotificationManager
- *
- * Handles all notification operations using expo-notifications.
- * Works completely offline - no backend, no user IDs, just device-local notifications.
- */
 export class NotificationManager {
-  /**
-   * Configure notification handler (how notifications appear when app is in foreground)
-   */
+  private permissions: NotificationPermissions;
+  private scheduler: NotificationScheduler;
+  private badgeManager: NotificationBadgeManager;
+
+  constructor() {
+    this.permissions = new NotificationPermissions();
+    this.scheduler = new NotificationScheduler();
+    this.badgeManager = new NotificationBadgeManager();
+  }
+
   static configure() {
     Notifications.setNotificationHandler({
       handleNotification: async () => ({
@@ -78,250 +58,104 @@ export class NotificationManager {
         shouldSetBadge: true,
       }),
     });
+
+    devLog('[NotificationManager] Configured notification handler');
   }
 
-  /**
-   * Request notification permissions
-   * iOS: Shows system permission dialog
-   * Android: Permissions granted by default (Android 13+ requires runtime permission)
-   */
   async requestPermissions(): Promise<boolean> {
     try {
-      if (!Device.isDevice) {
-        console.warn('[NotificationManager] Notifications only work on physical devices');
-        return false;
-      }
-
-      const permissionsResponse = await Notifications.getPermissionsAsync();
-      const existingStatus = (permissionsResponse as any).status || ((permissionsResponse as any).granted ? 'granted' : 'denied');
-      let finalStatus = existingStatus;
-
-      if (existingStatus !== 'granted') {
-        const requestResponse = await Notifications.requestPermissionsAsync();
-        finalStatus = (requestResponse as any).status || ((requestResponse as any).granted ? 'granted' : 'denied');
-      }
-
-      if (Platform.OS === 'android') {
-        await this.createAndroidChannels();
-      }
-
-      return finalStatus === 'granted';
+      const result = await this.permissions.requestPermissions();
+      
+      devLog('[NotificationManager] Permissions requested:', result);
+      
+      return result;
     } catch (error) {
-      console.error('[NotificationManager] Permission request failed:', error);
+      devError('[NotificationManager] Permission request failed:', error);
       return false;
     }
   }
 
-  /**
-   * Check if notification permissions are granted
-   */
   async hasPermissions(): Promise<boolean> {
     try {
-      if (!Device.isDevice) return false;
-      const permissionsResponse = await Notifications.getPermissionsAsync();
-      return (permissionsResponse as any).status === 'granted' || (permissionsResponse as any).granted === true;
+      return await this.permissions.hasPermissions();
     } catch (error) {
-      console.error('[NotificationManager] Permission check failed:', error);
+      devError('[NotificationManager] Permission check failed:', error);
       return false;
     }
   }
 
-  /**
-   * Create Android notification channels (required for Android 8+)
-   */
-  private async createAndroidChannels(): Promise<void> {
-    if (Platform.OS !== 'android') return;
-
-    try {
-      await Notifications.setNotificationChannelAsync('default', {
-        name: 'Default',
-        importance: Notifications.AndroidImportance.DEFAULT,
-        vibrationPattern: [0, 250, 250, 250],
-        sound: 'default',
-        lightColor: '#3B82F6',
-      });
-
-      await Notifications.setNotificationChannelAsync('reminders', {
-        name: 'Reminders',
-        importance: Notifications.AndroidImportance.HIGH,
-        vibrationPattern: [0, 250, 250, 250],
-        sound: 'default',
-        lightColor: '#3B82F6',
-        enableVibrate: true,
-      });
-
-      await Notifications.setNotificationChannelAsync('urgent', {
-        name: 'Urgent',
-        importance: Notifications.AndroidImportance.MAX,
-        vibrationPattern: [0, 500, 250, 500],
-        sound: 'default',
-        lightColor: '#EF4444',
-        enableVibrate: true,
-      });
-    } catch (error) {
-      console.error('[NotificationManager] Android channel creation failed:', error);
-    }
-  }
-
-  /**
-   * Schedule a notification
-   *
-   * @example
-   * // Specific date
-   * const id = await manager.scheduleNotification({
-   *   title: 'Bill Reminder',
-   *   body: 'Electricity bill due today',
-   *   trigger: { type: 'date', date: new Date('2025-01-15T09:00:00') }
-   * });
-   *
-   * @example
-   * // Daily reminder
-   * const id = await manager.scheduleNotification({
-   *   title: 'Daily Workout',
-   *   body: 'Time for your morning workout!',
-   *   trigger: { type: 'daily', hour: 7, minute: 0 }
-   * });
-   */
   async scheduleNotification(options: ScheduleNotificationOptions): Promise<string> {
     try {
-      const { title, body, data = {}, trigger, sound = true, badge, categoryIdentifier } = options;
-
-      let notificationTrigger: any;
-
-      if (trigger.type === 'date') {
-        notificationTrigger = {
-          date: trigger.date,
-          channelId: categoryIdentifier || 'default',
-        };
-      } else if (trigger.type === 'daily') {
-        notificationTrigger = {
-          hour: trigger.hour,
-          minute: trigger.minute,
-          repeats: true,
-          channelId: categoryIdentifier || 'reminders',
-        };
-      } else if (trigger.type === 'weekly') {
-        notificationTrigger = {
-          weekday: trigger.weekday,
-          hour: trigger.hour,
-          minute: trigger.minute,
-          repeats: true,
-          channelId: categoryIdentifier || 'reminders',
-        };
-      } else if (trigger.type === 'monthly') {
-        notificationTrigger = {
-          day: trigger.day,
-          hour: trigger.hour,
-          minute: trigger.minute,
-          repeats: true,
-          channelId: categoryIdentifier || 'reminders',
-        };
-      }
-
-      const notificationId = await Notifications.scheduleNotificationAsync({
-        content: {
-          title,
-          body,
-          data,
-          sound: sound === true ? 'default' : sound || undefined,
-          badge,
-          categoryIdentifier,
-          priority: Notifications.AndroidNotificationPriority.HIGH,
-          vibrate: [0, 250, 250, 250],
-        },
-        trigger: notificationTrigger,
-      });
-
-      return notificationId;
+      const id = await this.scheduler.scheduleNotification(options);
+      
+      devLog('[NotificationManager] Notification scheduled:', id);
+      
+      return id;
     } catch (error) {
-      console.error('[NotificationManager] Schedule notification failed:', error);
+      devError('[NotificationManager] Schedule notification failed:', error);
       throw error;
     }
   }
 
-  /**
-   * Cancel a scheduled notification
-   */
   async cancelNotification(notificationId: string): Promise<void> {
     try {
-      await Notifications.cancelScheduledNotificationAsync(notificationId);
+      await this.scheduler.cancelNotification(notificationId);
+      
+      devLog('[NotificationManager] Notification cancelled:', notificationId);
     } catch (error) {
-      console.error('[NotificationManager] Cancel notification failed:', error);
+      devError('[NotificationManager] Cancel notification failed:', error);
       throw error;
     }
   }
 
-  /**
-   * Cancel all scheduled notifications
-   */
   async cancelAllNotifications(): Promise<void> {
     try {
-      await Notifications.cancelAllScheduledNotificationsAsync();
+      await this.scheduler.cancelAllNotifications();
+      
+      devLog('[NotificationManager] All notifications cancelled');
     } catch (error) {
-      console.error('[NotificationManager] Cancel all notifications failed:', error);
+      devError('[NotificationManager] Cancel all notifications failed:', error);
       throw error;
     }
   }
 
-  /**
-   * Get all scheduled notifications
-   */
   async getScheduledNotifications(): Promise<ScheduledNotification[]> {
     try {
-      const notifications = await Notifications.getAllScheduledNotificationsAsync();
-      return notifications.map(notification => ({
-        identifier: notification.identifier,
-        content: {
-          title: notification.content.title || '',
-          body: notification.content.body || '',
-          data: notification.content.data as Record<string, any>,
-        },
-        trigger: notification.trigger,
-      }));
+      return await this.scheduler.getScheduledNotifications();
     } catch (error) {
-      console.error('[NotificationManager] Get scheduled notifications failed:', error);
+      devError('[NotificationManager] Get scheduled notifications failed:', error);
       return [];
     }
   }
 
-  /**
-   * Dismiss all delivered notifications (clear from notification center)
-   */
   async dismissAllNotifications(): Promise<void> {
     try {
       await Notifications.dismissAllNotificationsAsync();
+      
+      devLog('[NotificationManager] All notifications dismissed');
     } catch (error) {
-      console.error('[NotificationManager] Dismiss all notifications failed:', error);
+      devError('[NotificationManager] Dismiss all notifications failed:', error);
       throw error;
     }
   }
 
-  /**
-   * Get notification badge count (iOS only)
-   */
   async getBadgeCount(): Promise<number> {
     try {
-      if (Platform.OS === 'ios') {
-        return await Notifications.getBadgeCountAsync();
-      }
-      return 0;
+      return await this.badgeManager.getBadgeCount();
     } catch (error) {
-      console.error('[NotificationManager] Get badge count failed:', error);
+      devError('[NotificationManager] Get badge count failed:', error);
       return 0;
     }
   }
 
-  /**
-   * Set notification badge count (iOS only)
-   */
   async setBadgeCount(count: number): Promise<void> {
     try {
-      if (Platform.OS === 'ios') {
-        await Notifications.setBadgeCountAsync(count);
-      }
+      await this.badgeManager.setBadgeCount(count);
+      
+      devLog('[NotificationManager] Badge count set:', count);
     } catch (error) {
-      console.error('[NotificationManager] Set badge count failed:', error);
+      devError('[NotificationManager] Set badge count failed:', error);
       throw error;
     }
   }
-}
+}

package/src/infrastructure/services/NotificationPermissions.ts

@@ -0,0 +1,80 @@
+import * as Notifications from 'expo-notifications';
+import * as Device from 'expo-device';
+import { Platform } from 'react-native';
+import { devWarn, devError, devLog } from '../utils/dev';
+
+export class NotificationPermissions {
+  async requestPermissions(): Promise<boolean> {
+    try {
+      if (!Device.isDevice) {
+        devWarn('[NotificationPermissions] Notifications only work on physical devices');
+        return false;
+      }
+
+      const permissionsResponse = await Notifications.getPermissionsAsync();
+      const existingStatus = (permissionsResponse as any).status || ((permissionsResponse as any).granted ? 'granted' : 'denied');
+      let finalStatus = existingStatus;
+
+      if (existingStatus !== 'granted') {
+        const requestResponse = await Notifications.requestPermissionsAsync();
+        finalStatus = (requestResponse as any).status || ((requestResponse as any).granted ? 'granted' : 'denied');
+      }
+
+      if (Platform.OS === 'android') {
+        await this.createAndroidChannels();
+      }
+
+      return finalStatus === 'granted';
+    } catch (error) {
+      devError('[NotificationPermissions] Permission request failed:', error);
+      return false;
+    }
+  }
+
+  async hasPermissions(): Promise<boolean> {
+    try {
+      if (!Device.isDevice) return false;
+      const permissionsResponse = await Notifications.getPermissionsAsync();
+      return (permissionsResponse as any).status === 'granted' || (permissionsResponse as any).granted === true;
+    } catch (error) {
+      devError('[NotificationPermissions] Permission check failed:', error);
+      return false;
+    }
+  }
+
+  private async createAndroidChannels(): Promise<void> {
+    if (Platform.OS !== 'android') return;
+
+    try {
+      await Notifications.setNotificationChannelAsync('default', {
+        name: 'Default',
+        importance: Notifications.AndroidImportance.DEFAULT,
+        vibrationPattern: [0, 250, 250, 250],
+        sound: 'default',
+        lightColor: '#3B82F6',
+      });
+
+      await Notifications.setNotificationChannelAsync('reminders', {
+        name: 'Reminders',
+        importance: Notifications.AndroidImportance.HIGH,
+        vibrationPattern: [0, 250, 250, 250],
+        sound: 'default',
+        lightColor: '#3B82F6',
+        enableVibrate: true,
+      });
+
+      await Notifications.setNotificationChannelAsync('urgent', {
+        name: 'Urgent',
+        importance: Notifications.AndroidImportance.MAX,
+        vibrationPattern: [0, 500, 250, 500],
+        sound: 'default',
+        lightColor: '#EF4444',
+        enableVibrate: true,
+      });
+
+      devLog('[NotificationPermissions] Android channels created');
+    } catch (error) {
+      devError('[NotificationPermissions] Android channel creation failed:', error);
+    }
+  }
+}

package/src/infrastructure/services/NotificationScheduler.ts

@@ -0,0 +1,77 @@
+import * as Notifications from 'expo-notifications';
+import type { NotificationTrigger, ScheduleNotificationOptions, ScheduledNotification } from './NotificationManager';
+
+export class NotificationScheduler {
+  async scheduleNotification(options: ScheduleNotificationOptions): Promise<string> {
+    const { title, body, data = {}, trigger, sound = true, badge, categoryIdentifier } = options;
+
+    let notificationTrigger: any;
+
+    if (trigger.type === 'date') {
+      notificationTrigger = {
+        date: trigger.date,
+        channelId: categoryIdentifier || 'default',
+      };
+    } else if (trigger.type === 'daily') {
+      notificationTrigger = {
+        hour: trigger.hour,
+        minute: trigger.minute,
+        repeats: true,
+        channelId: categoryIdentifier || 'reminders',
+      };
+    } else if (trigger.type === 'weekly') {
+      notificationTrigger = {
+        weekday: trigger.weekday,
+        hour: trigger.hour,
+        minute: trigger.minute,
+        repeats: true,
+        channelId: categoryIdentifier || 'reminders',
+      };
+    } else if (trigger.type === 'monthly') {
+      notificationTrigger = {
+        day: trigger.day,
+        hour: trigger.hour,
+        minute: trigger.minute,
+        repeats: true,
+        channelId: categoryIdentifier || 'reminders',
+      };
+    }
+
+    const notificationId = await Notifications.scheduleNotificationAsync({
+      content: {
+        title,
+        body,
+        data,
+        sound: sound === true ? 'default' : sound || undefined,
+        badge,
+        categoryIdentifier,
+        priority: Notifications.AndroidNotificationPriority.HIGH,
+        vibrate: [0, 250, 250, 250],
+      },
+      trigger: notificationTrigger,
+    });
+
+    return notificationId;
+  }
+
+  async cancelNotification(notificationId: string): Promise<void> {
+    await Notifications.cancelScheduledNotificationAsync(notificationId);
+  }
+
+  async cancelAllNotifications(): Promise<void> {
+    await Notifications.cancelAllScheduledNotificationsAsync();
+  }
+
+  async getScheduledNotifications(): Promise<ScheduledNotification[]> {
+    const notifications = await Notifications.getAllScheduledNotificationsAsync();
+    return notifications.map(notification => ({
+      identifier: notification.identifier,
+      content: {
+        title: notification.content.title || '',
+        body: notification.content.body || '',
+        data: notification.content.data as Record<string, any>,
+      },
+      trigger: notification.trigger,
+    }));
+  }
+}

package/src/infrastructure/services/delivery/NotificationDelivery.ts

@@ -1,21 +1,13 @@
 import * as Notifications from 'expo-notifications';
 import AsyncStorage from '@react-native-async-storage/async-storage';
 import type { Notification } from '../types';
+import { devLog, devError } from '../../utils/dev';
 
-/**
- * NotificationDelivery - Offline Local Notification Delivery
- *
- * Uses expo-notifications for local push notifications only.
- * All data stored in AsyncStorage (offline-capable).
- *
- * NO backend, NO email/SMS - pure offline local notifications.
- */
 export class NotificationDelivery {
   private static STORAGE_KEY = '@notifications:delivered';
 
   async deliver(notification: Notification): Promise<void> {
     try {
-      // Schedule local notification using expo-notifications
       await Notifications.scheduleNotificationAsync({
         content: {
           title: notification.title,
@@ -24,14 +16,17 @@ export class NotificationDelivery {
         },
         trigger: notification.scheduled_for
           ? { date: new Date(notification.scheduled_for) }
-          : null, // null = immediate delivery
+          : null,
       });
 
-      // Update status in AsyncStorage (offline storage)
       await this.updateStatus(notification.id, 'delivered');
+
+      devLog('[NotificationDelivery] Notification delivered:', notification.id);
     } catch (error) {
-      // Silent failure - update status to failed
       await this.updateStatus(notification.id, 'failed');
+      
+      devError('[NotificationDelivery] Delivery failed:', notification.id, error);
+      throw error;
     }
   }
 
@@ -49,8 +44,10 @@ export class NotificationDelivery {
         NotificationDelivery.STORAGE_KEY,
         JSON.stringify(delivered)
       );
+
+      devLog('[NotificationDelivery] Status updated:', notificationId, status);
     } catch (error) {
-      // Silent failure
+      devError('[NotificationDelivery] Status update failed:', notificationId, error);
     }
   }
 
@@ -59,7 +56,28 @@ export class NotificationDelivery {
       const data = await AsyncStorage.getItem(NotificationDelivery.STORAGE_KEY);
       return data ? JSON.parse(data) : {};
     } catch (error) {
+      devError('[NotificationDelivery] Failed to get delivered notifications:', error);
       return {};
     }
   }
-}
+
+  async getDeliveryStatus(notificationId: string): Promise<string | null> {
+    try {
+      const delivered = await this.getDelivered();
+      return delivered[notificationId]?.status || null;
+    } catch (error) {
+      devError('[NotificationDelivery] Failed to get delivery status:', notificationId, error);
+      return null;
+    }
+  }
+
+  async clearDeliveryHistory(): Promise<void> {
+    try {
+      await AsyncStorage.removeItem(NotificationDelivery.STORAGE_KEY);
+      
+      devLog('[NotificationDelivery] Delivery history cleared');
+    } catch (error) {
+      devError('[NotificationDelivery] Failed to clear delivery history:', error);
+    }
+  }
+}

package/src/infrastructure/storage/NotificationsStore.ts

@@ -28,7 +28,8 @@ export const useNotificationsStore = create<NotificationsStore>((set) => ({
  * Hook for accessing notifications state
  */
 export const useNotifications = () => {
-  const { hasPermissions, isInitialized, setPermissions, setInitialized } = useNotificationsStore();
+  const store = useNotificationsStore();
+  const { hasPermissions, isInitialized, setPermissions, setInitialized } = store;
 
   return {
     hasPermissions,
@@ -36,4 +37,4 @@ export const useNotifications = () => {
     setPermissions,
     setInitialized,
   };
-};
+};

package/src/infrastructure/utils/dev.ts

@@ -0,0 +1,25 @@
+export const isDev = () => {
+  try {
+    return typeof __DEV__ !== 'undefined' && __DEV__;
+  } catch {
+    return false;
+  }
+};
+
+export const devLog = (message: string, ...args: any[]) => {
+  if (isDev()) {
+    console.log(message, ...args);
+  }
+};
+
+export const devError = (message: string, ...args: any[]) => {
+  if (isDev()) {
+    console.error(message, ...args);
+  }
+};
+
+export const devWarn = (message: string, ...args: any[]) => {
+  if (isDev()) {
+    console.warn(message, ...args);
+  }
+};