@umituz/react-native-settings 4.21.11 → 4.21.13

package/src/domains/notifications/infrastructure/services/NotificationManager.ts

@@ -0,0 +1,138 @@
+/**
+ * NotificationManager - Core Notification Operations
+ *
+ * Offline-first notification system using expo-notifications.
+ * Works in ALL apps (offline, online, hybrid) - no backend required.
+ */
+
+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';
+import type { NotificationTrigger, ScheduleNotificationOptions, ScheduledNotification } from './types';
+
+export class NotificationManager {
+  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 () => ({
+        shouldShowAlert: true,
+        shouldPlaySound: true,
+        shouldSetBadge: true,
+        shouldShowBanner: true,
+        shouldShowList: true,
+      }),
+    });
+
+    devLog('[NotificationManager] Configured notification handler');
+  }
+
+  async requestPermissions(): Promise<boolean> {
+    try {
+      const result = await this.permissions.requestPermissions();
+      
+      devLog('[NotificationManager] Permissions requested:', result);
+      
+      return result;
+    } catch (error) {
+      devError('[NotificationManager] Permission request failed:', error);
+      return false;
+    }
+  }
+
+  async hasPermissions(): Promise<boolean> {
+    try {
+      return await this.permissions.hasPermissions();
+    } catch (error) {
+      devError('[NotificationManager] Permission check failed:', error);
+      return false;
+    }
+  }
+
+  async scheduleNotification(options: ScheduleNotificationOptions): Promise<string> {
+    try {
+      const id = await this.scheduler.scheduleNotification(options);
+      
+      devLog('[NotificationManager] Notification scheduled:', id);
+      
+      return id;
+    } catch (error) {
+      devError('[NotificationManager] Schedule notification failed:', error);
+      throw error;
+    }
+  }
+
+  async cancelNotification(notificationId: string): Promise<void> {
+    try {
+      await this.scheduler.cancelNotification(notificationId);
+      
+      devLog('[NotificationManager] Notification cancelled:', notificationId);
+    } catch (error) {
+      devError('[NotificationManager] Cancel notification failed:', error);
+      throw error;
+    }
+  }
+
+  async cancelAllNotifications(): Promise<void> {
+    try {
+      await this.scheduler.cancelAllNotifications();
+      
+      devLog('[NotificationManager] All notifications cancelled');
+    } catch (error) {
+      devError('[NotificationManager] Cancel all notifications failed:', error);
+      throw error;
+    }
+  }
+
+  async getScheduledNotifications(): Promise<ScheduledNotification[]> {
+    try {
+      return await this.scheduler.getScheduledNotifications();
+    } catch (error) {
+      devError('[NotificationManager] Get scheduled notifications failed:', error);
+      return [];
+    }
+  }
+
+  async dismissAllNotifications(): Promise<void> {
+    try {
+      await Notifications.dismissAllNotificationsAsync();
+      
+      devLog('[NotificationManager] All notifications dismissed');
+    } catch (error) {
+      devError('[NotificationManager] Dismiss all notifications failed:', error);
+      throw error;
+    }
+  }
+
+  async getBadgeCount(): Promise<number> {
+    try {
+      return await this.badgeManager.getBadgeCount();
+    } catch (error) {
+      devError('[NotificationManager] Get badge count failed:', error);
+      return 0;
+    }
+  }
+
+  async setBadgeCount(count: number): Promise<void> {
+    try {
+      await this.badgeManager.setBadgeCount(count);
+      
+      devLog('[NotificationManager] Badge count set:', count);
+    } catch (error) {
+      devError('[NotificationManager] Set badge count failed:', error);
+      throw error;
+    }
+  }
+}

package/src/domains/notifications/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/domains/notifications/infrastructure/services/NotificationScheduler.ts

@@ -0,0 +1,77 @@
+import * as Notifications from 'expo-notifications';
+import type { NotificationTrigger, ScheduleNotificationOptions, ScheduledNotification } from './types';
+
+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/domains/notifications/infrastructure/services/NotificationService.ts

@@ -0,0 +1,50 @@
+/**
+ * NotificationService
+ *
+ * Simple facade for offline notification system.
+ * Works in ALL apps - offline, online, hybrid - no backend required.
+ *
+ * @module NotificationService
+ */
+
+import { NotificationManager } from './NotificationManager';
+
+export * from './types';
+
+/**
+ * Notification service singleton
+ * Provides simple access to notification manager
+ */
+export class NotificationService {
+  private static instance: NotificationService;
+
+  readonly notifications = new NotificationManager();
+
+  private constructor() {
+    // Configure notification handler on initialization
+    NotificationManager.configure();
+  }
+
+  static getInstance(): NotificationService {
+    if (!NotificationService.instance) {
+      NotificationService.instance = new NotificationService();
+    }
+    return NotificationService.instance;
+  }
+
+  /**
+   * Request notification permissions
+   */
+  async requestPermissions(): Promise<boolean> {
+    return await this.notifications.requestPermissions();
+  }
+
+  /**
+   * Check if permissions are granted
+   */
+  async hasPermissions(): Promise<boolean> {
+    return await this.notifications.hasPermissions();
+  }
+}
+
+export const notificationService = NotificationService.getInstance();

package/src/domains/notifications/infrastructure/services/types.ts

@@ -0,0 +1,176 @@
+/**
+ * Offline-First Notification Types
+ * Uses expo-notifications for local device notifications
+ */
+
+import * as Notifications from 'expo-notifications';
+
+// ============================================================================
+// NOTIFICATION CHANNEL TYPES
+// ============================================================================
+
+export interface NotificationChannel {
+  id: string;
+  channel_type: 'push' | 'in_app';
+  channel_address: string;
+  preferences: Record<string, unknown>;
+  is_verified: boolean;
+  is_active: boolean;
+  created_at: string;
+}
+
+// ============================================================================
+// NOTIFICATION TRIGGER TYPES
+// ============================================================================
+
+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 };
+
+export interface ScheduleNotificationOptions {
+  title: string;
+  body: string;
+  data?: Record<string, unknown>;
+  trigger: NotificationTrigger;
+  sound?: boolean | string;
+  badge?: number;
+  categoryIdentifier?: string;
+}
+
+export interface ScheduledNotification {
+  identifier: string;
+  content: {
+    title: string;
+    body: string;
+    data: Record<string, unknown>;
+  };
+  trigger: Notifications.NotificationTrigger;
+}
+
+// ============================================================================
+// TIME PRESET TYPES
+// ============================================================================
+
+export interface TimePreset {
+  id: string;
+  hour: number;
+  minute: number;
+  labelKey: string;
+  iconName: string;
+}
+
+// ============================================================================
+// REMINDER TYPES
+// ============================================================================
+
+export type ReminderFrequency = 'once' | 'daily' | 'weekly' | 'monthly';
+
+export interface Reminder {
+  id: string;
+  title: string;
+  body: string;
+  frequency: ReminderFrequency;
+  timePresetId?: string;
+  hour: number;
+  minute: number;
+  weekday?: number;
+  dayOfMonth?: number;
+  enabled: boolean;
+  notificationId?: string;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface CreateReminderInput {
+  title: string;
+  body: string;
+  frequency: ReminderFrequency;
+  timePresetId?: string;
+  hour: number;
+  minute: number;
+  weekday?: number;
+  dayOfMonth?: number;
+}
+
+export interface UpdateReminderInput {
+  title?: string;
+  body?: string;
+  frequency?: ReminderFrequency;
+  timePresetId?: string;
+  hour?: number;
+  minute?: number;
+  weekday?: number;
+  dayOfMonth?: number;
+  enabled?: boolean;
+}
+
+// ============================================================================
+// QUIET HOURS TYPES
+// ============================================================================
+
+export interface QuietHoursConfig {
+  enabled: boolean;
+  startHour: number;
+  startMinute: number;
+  endHour: number;
+  endMinute: number;
+}
+
+// ============================================================================
+// NOTIFICATION PREFERENCES
+// ============================================================================
+
+export interface NotificationPreferences {
+  enabled: boolean;
+  sound: boolean;
+  vibration: boolean;
+  quietHours: QuietHoursConfig;
+}
+
+// ============================================================================
+// SCREEN CONFIGURATION TYPES
+// ============================================================================
+
+export interface ReminderTranslations {
+  screenTitle: string;
+  emptyTitle: string;
+  emptyDescription: string;
+  addButtonLabel: string;
+  editButtonLabel: string;
+  deleteButtonLabel: string;
+  enabledLabel: string;
+  disabledLabel: string;
+  frequencyOnce: string;
+  frequencyDaily: string;
+  frequencyWeekly: string;
+  frequencyMonthly: string;
+  timeLabel: string;
+  titlePlaceholder: string;
+  bodyPlaceholder: string;
+  saveButtonLabel: string;
+  cancelButtonLabel: string;
+}
+
+export interface QuietHoursTranslations {
+  title: string;
+  description: string;
+  startTimeLabel: string;
+  endTimeLabel: string;
+  enabledLabel: string;
+}
+
+export interface NotificationSettingsTranslations {
+  screenTitle: string;
+  masterToggleTitle: string;
+  masterToggleDescription: string;
+  soundTitle: string;
+  soundDescription: string;
+  vibrationTitle: string;
+  vibrationDescription: string;
+  remindersTitle: string;
+  remindersDescription: string;
+  quietHoursTitle: string;
+  quietHoursDescription: string;
+}

package/src/domains/notifications/infrastructure/storage/NotificationsStore.ts

@@ -0,0 +1,45 @@
+/**
+ * Notifications Store - Zustand State Management
+ * Simple offline-first notification state
+ * NO backend, NO user IDs, NO notification history
+ */
+
+import { createStore } from '@umituz/react-native-storage';
+
+interface NotificationsState {
+  hasPermissions: boolean;
+  isInitialized: boolean;
+}
+
+interface NotificationsActions {
+  setPermissions: (granted: boolean) => void;
+  setInitialized: (initialized: boolean) => void;
+}
+
+export const useNotificationsStore = createStore<NotificationsState, NotificationsActions>({
+  name: 'notifications-store',
+  initialState: {
+    hasPermissions: false,
+    isInitialized: false,
+  },
+  persist: false,
+  actions: (set) => ({
+    setPermissions: (granted) => set({ hasPermissions: granted }),
+    setInitialized: (initialized) => set({ isInitialized: initialized }),
+  }),
+});
+
+/**
+ * Hook for accessing notifications state
+ */
+export const useNotifications = () => {
+  const store = useNotificationsStore();
+  const { hasPermissions, isInitialized, setPermissions, setInitialized } = store;
+
+  return {
+    hasPermissions,
+    isInitialized,
+    setPermissions,
+    setInitialized,
+  };
+};

package/src/domains/notifications/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);
+  }
+};

package/src/domains/notifications/infrastructure/utils/idGenerator.ts

@@ -0,0 +1,14 @@
+/**
+ * ID Generator Utility
+ * Generates unique IDs for entities
+ */
+
+export const generateId = (prefix: string = 'id'): string => {
+  const timestamp = Date.now();
+  const random = Math.random().toString(36).substring(2, 11);
+  return `${prefix}_${timestamp}_${random}`;
+};
+
+export const generateReminderId = (): string => {
+  return generateId('reminder');
+};

package/src/domains/notifications/infrastructure/utils/triggerBuilder.ts

@@ -0,0 +1,45 @@
+/**
+ * Trigger Builder Utility
+ * Builds notification triggers from reminder data
+ */
+
+import type { NotificationTrigger, Reminder } from '../services/types';
+
+export const buildTrigger = (reminder: Reminder): NotificationTrigger => {
+  const { frequency, hour, minute, weekday, dayOfMonth } = reminder;
+
+  switch (frequency) {
+    case 'once': {
+      const date = new Date();
+      date.setHours(hour, minute, 0, 0);
+
+      if (date <= new Date()) {
+        date.setDate(date.getDate() + 1);
+      }
+
+      return { type: 'date', date };
+    }
+
+    case 'daily':
+      return { type: 'daily', hour, minute };
+
+    case 'weekly':
+      return {
+        type: 'weekly',
+        weekday: weekday || 1,
+        hour,
+        minute,
+      };
+
+    case 'monthly':
+      return {
+        type: 'monthly',
+        day: dayOfMonth || 1,
+        hour,
+        minute,
+      };
+
+    default:
+      return { type: 'daily', hour, minute };
+  }
+};