RE1-T123 Modern notification sounds

.gitignore

@@ -41,3 +41,4 @@ expo-env.d.ts
 .mcp.json
 opencode.json
 /.dual-graph-pro
+.DS_Store

plugins/withNotificationSounds.js

@@ -26,6 +26,27 @@ const soundFiles = [
   'assets/audio/unitstatusupdated.wav',
   'assets/audio/upcomingshift.wav',
   'assets/audio/upcomingtraining.wav',
+  // Modern notification sound set
+  'assets/audio/modernnotification.wav',
+  'assets/audio/modernavailabilityalert.wav',
+  'assets/audio/moderncalendar.wav',
+  'assets/audio/moderncallclosed.wav',
+  'assets/audio/moderncallemergency.wav',
+  'assets/audio/moderncallhigh.wav',
+  'assets/audio/moderncalllow.wav',
+  'assets/audio/moderncallmedium.wav',
+  'assets/audio/moderncallupdated.wav',
+  'assets/audio/modernchat.wav',
+  'assets/audio/modernmessage.wav',
+  'assets/audio/modernpersonnelstatus.wav',
+  'assets/audio/modernresourceorder.wav',
+  'assets/audio/modernshift.wav',
+  'assets/audio/modernstaffing.wav',
+  'assets/audio/moderntraining.wav',
+  'assets/audio/moderntroublealert.wav',
+  'assets/audio/modernunitnotice.wav',
+  'assets/audio/modernunitstatus.wav',
+  'assets/audio/modernweatheralert.wav',
   'assets/audio/custom/c1.wav',
   'assets/audio/custom/c2.wav',
   'assets/audio/custom/c3.wav',

src/app/(app)/settings.tsx

@@ -10,6 +10,7 @@ import { Item } from '@/components/settings/item';
 import { KeepAliveItem } from '@/components/settings/keep-alive-item';
 import { LanguageItem } from '@/components/settings/language-item';
 import { LoginInfoBottomSheet } from '@/components/settings/login-info-bottom-sheet';
+import { ModernNotificationSoundsItem } from '@/components/settings/modern-notification-sounds-item';
 import { ServerUrlBottomSheet } from '@/components/settings/server-url-bottom-sheet';
 import { ThemeItem } from '@/components/settings/theme-item';
 import { ToggleItem } from '@/components/settings/toggle-item';
@@ -131,6 +132,7 @@ export default function Settings() {
               <ThemeItem />
               <LanguageItem />
               <KeepAliveItem />
+              <ModernNotificationSoundsItem />
               <BackgroundGeolocationItem />
               <BluetoothDeviceItem />
             </VStack>

src/components/settings/__tests__/modern-notification-sounds-item.test.tsx

@@ -0,0 +1,77 @@
+import { describe, expect, it, jest, beforeEach } from '@jest/globals';
+import { fireEvent, render, screen } from '@testing-library/react-native';
+import React from 'react';
+
+import { ModernNotificationSoundsItem } from '../modern-notification-sounds-item';
+
+// Mock the translation hook
+jest.mock('react-i18next', () => ({
+  useTranslation: () => ({
+    t: (key: string) => {
+      const translations: Record<string, string> = {
+        'settings.modern_notification_sounds': 'Modern Notification Sounds',
+        'settings.modern_notification_sounds_description': 'Use the new modern sound set for push notifications.',
+      };
+      return translations[key] || key;
+    },
+  }),
+}));
+
+// Control the platform per test (component is Android-only).
+let mockIsAndroid = true;
+jest.mock('@/lib/platform', () => ({
+  get isAndroid() {
+    return mockIsAndroid;
+  },
+}));
+
+// Control the preference hook.
+const mockSetModernSoundsEnabled = jest.fn();
+let mockIsModernSoundsEnabled = true;
+jest.mock('@/lib/hooks/use-modern-notification-sounds', () => ({
+  useModernNotificationSounds: () => ({
+    isModernSoundsEnabled: mockIsModernSoundsEnabled,
+    setModernSoundsEnabled: mockSetModernSoundsEnabled,
+  }),
+}));
+
+describe('ModernNotificationSoundsItem', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockIsAndroid = true;
+    mockIsModernSoundsEnabled = true;
+  });
+
+  it('renders the label and description on Android', () => {
+    render(<ModernNotificationSoundsItem />);
+
+    expect(screen.getByText('Modern Notification Sounds')).toBeTruthy();
+    expect(screen.getByText('Use the new modern sound set for push notifications.')).toBeTruthy();
+  });
+
+  it('renders nothing on non-Android platforms', () => {
+    mockIsAndroid = false;
+
+    render(<ModernNotificationSoundsItem />);
+
+    expect(screen.queryByText('Modern Notification Sounds')).toBeNull();
+  });
+
+  it('reflects the enabled state on the switch', () => {
+    mockIsModernSoundsEnabled = true;
+
+    render(<ModernNotificationSoundsItem />);
+
+    expect(screen.getByRole('switch').props.value).toBe(true);
+  });
+
+  it('calls the setter when toggled off', () => {
+    mockIsModernSoundsEnabled = true;
+
+    render(<ModernNotificationSoundsItem />);
+
+    fireEvent(screen.getByRole('switch'), 'valueChange', false);
+
+    expect(mockSetModernSoundsEnabled).toHaveBeenCalledWith(false);
+  });
+});

src/components/settings/modern-notification-sounds-item.tsx

@@ -0,0 +1,45 @@
+import { useColorScheme } from 'nativewind';
+import React from 'react';
+import { useTranslation } from 'react-i18next';
+
+import { useModernNotificationSounds } from '@/lib/hooks/use-modern-notification-sounds';
+import { isAndroid } from '@/lib/platform';
+
+import { Switch } from '../ui/switch';
+import { Text } from '../ui/text';
+import { View } from '../ui/view';
+import { VStack } from '../ui/vstack';
+
+export const ModernNotificationSoundsItem = () => {
+  const { isModernSoundsEnabled, setModernSoundsEnabled } = useModernNotificationSounds();
+  const { t } = useTranslation();
+  const { colorScheme } = useColorScheme();
+
+  const handleToggle = React.useCallback(
+    (value: boolean) => {
+      setModernSoundsEnabled(value);
+    },
+    [setModernSoundsEnabled]
+  );
+
+  // Notification channel sounds are an Android-only concept; hide on other platforms.
+  if (!isAndroid) {
+    return null;
+  }
+
+  return (
+    <VStack space="sm">
+      <View className="flex-1 flex-row items-center justify-between px-4 py-2">
+        <View className="flex-1 flex-row items-center pr-3">
+          <Text>{t('settings.modern_notification_sounds')}</Text>
+        </View>
+        <View className="flex-row items-center">
+          <Switch size="md" value={isModernSoundsEnabled} onValueChange={handleToggle} />
+        </View>
+      </View>
+      <View className="px-4">
+        <Text className={`text-xs ${colorScheme === 'dark' ? 'text-neutral-400' : 'text-neutral-500'}`}>{t('settings.modern_notification_sounds_description')}</Text>
+      </View>
+    </VStack>
+  );
+};

src/lib/hooks/use-modern-notification-sounds.ts

@@ -0,0 +1,33 @@
+import React from 'react';
+import { Platform } from 'react-native';
+import { useMMKVBoolean } from 'react-native-mmkv';
+
+import { storage } from '@/lib/storage';
+import { MODERN_NOTIFICATION_SOUNDS_ENABLED } from '@/lib/storage/notification-prefs';
+import { pushNotificationService } from '@/services/push-notification';
+
+/**
+ * Android-only hook for the "use modern notification sounds" preference.
+ *
+ * Defaults to enabled (modern sounds) and is persisted in MMKV alongside the
+ * other app settings. When toggled on Android, the notification channels are
+ * recreated so the new sound takes effect — a channel's sound is immutable
+ * after it is created, so it must be deleted and recreated to change it.
+ */
+export const useModernNotificationSounds = () => {
+  const [enabled, _setEnabled] = useMMKVBoolean(MODERN_NOTIFICATION_SOUNDS_ENABLED, storage);
+
+  const setModernSoundsEnabled = React.useCallback(
+    async (value: boolean) => {
+      _setEnabled(value);
+      if (Platform.OS === 'android') {
+        await pushNotificationService.refreshAndroidNotificationChannels();
+      }
+    },
+    [_setEnabled]
+  );
+
+  // Default ON when the user has not set a preference.
+  const isModernSoundsEnabled = enabled ?? true;
+  return { isModernSoundsEnabled, setModernSoundsEnabled } as const;
+};

src/lib/storage/notification-prefs.ts

@@ -0,0 +1,36 @@
+import { storage } from '@/lib/storage';
+
+/**
+ * MMKV key for the Android-only "use modern notification sounds" preference.
+ * Defaults to enabled (modern sounds) when the user has not set a preference.
+ */
+export const MODERN_NOTIFICATION_SOUNDS_ENABLED = 'MODERN_NOTIFICATION_SOUNDS_ENABLED';
+
+/**
+ * MMKV key tracking which sound set the Android notification channels were last
+ * created with. Android notification channel sound is immutable after creation,
+ * so this marker lets us detect when channels need to be deleted and recreated.
+ */
+const NOTIFICATION_SOUND_MODE_APPLIED = 'NOTIFICATION_SOUND_MODE_APPLIED';
+
+export type NotificationSoundMode = 'modern' | 'classic';
+
+/**
+ * Whether modern notification sounds are enabled. Defaults to true (modern is
+ * the default) when the user has not made a choice.
+ */
+export const getModernNotificationSoundsEnabled = (): boolean => storage.getBoolean(MODERN_NOTIFICATION_SOUNDS_ENABLED) ?? true;
+
+/**
+ * The sound mode the Android channels were last created with, or undefined if
+ * they have never been created (fresh install or app upgrade).
+ */
+export const getAppliedNotificationSoundMode = (): NotificationSoundMode | undefined => {
+  const mode = storage.getString(NOTIFICATION_SOUND_MODE_APPLIED);
+  return mode === 'modern' || mode === 'classic' ? mode : undefined;
+};
+
+/** Persist the sound mode the Android channels were created with. */
+export const setAppliedNotificationSoundMode = (mode: NotificationSoundMode): void => {
+  storage.set(NOTIFICATION_SOUND_MODE_APPLIED, mode);
+};

src/services/__tests__/push-notification.test.ts

@@ -95,9 +95,21 @@ jest.mock('expo-notifications', () => ({
   AndroidNotificationVisibility: { PUBLIC: 1 },
 }));
 
+// Mock the modern-sounds preference module (controls Android channel sounds)
+const mockGetModernNotificationSoundsEnabled = jest.fn((): boolean => true);
+const mockGetAppliedNotificationSoundMode = jest.fn((): string | undefined => undefined);
+const mockSetAppliedNotificationSoundMode = jest.fn();
+
+jest.mock('@/lib/storage/notification-prefs', () => ({
+  getModernNotificationSoundsEnabled: mockGetModernNotificationSoundsEnabled,
+  getAppliedNotificationSoundMode: mockGetAppliedNotificationSoundMode,
+  setAppliedNotificationSoundMode: mockSetAppliedNotificationSoundMode,
+}));
+
 // Mock Notifee (channels, categories, foreground/background events, check-in)
 const mockNotifeeForegroundUnsubscribe = jest.fn();
 const mockCreateChannel = jest.fn(() => Promise.resolve());
+const mockDeleteChannel = jest.fn(() => Promise.resolve());
 const mockSetNotificationCategories = jest.fn(() => Promise.resolve());
 const mockNotifeeRequestPermission = jest.fn(() =>
   Promise.resolve({
@@ -112,6 +124,7 @@ jest.mock('@notifee/react-native', () => ({
   __esModule: true,
   default: {
     createChannel: mockCreateChannel,
+    deleteChannel: mockDeleteChannel,
     setNotificationCategories: mockSetNotificationCategories,
     requestPermission: mockNotifeeRequestPermission,
     displayNotification: mockDisplayNotification,
@@ -554,5 +567,85 @@ describe('Push Notification Service Integration', () => {
       // Total: 32 channels
       expect(mockCreateChannel).toHaveBeenCalledTimes(32);
     });
+
+    it('should use modern sounds for the standard channels by default', async () => {
+      mockGetModernNotificationSoundsEnabled.mockReturnValue(true);
+
+      await pushNotificationService.initialize();
+
+      expect(mockCreateChannel).toHaveBeenCalledWith(expect.objectContaining({ id: 'calls', sound: 'modernnotification' }));
+      expect(mockCreateChannel).toHaveBeenCalledWith(expect.objectContaining({ id: '0', sound: 'moderncallemergency' }));
+      expect(mockCreateChannel).toHaveBeenCalledWith(expect.objectContaining({ id: '1', sound: 'moderncallhigh' }));
+      expect(mockCreateChannel).toHaveBeenCalledWith(expect.objectContaining({ id: '2', sound: 'moderncallmedium' }));
+      expect(mockCreateChannel).toHaveBeenCalledWith(expect.objectContaining({ id: '3', sound: 'moderncalllow' }));
+      expect(mockCreateChannel).toHaveBeenCalledWith(expect.objectContaining({ id: 'notif', sound: 'modernnotification' }));
+      expect(mockCreateChannel).toHaveBeenCalledWith(expect.objectContaining({ id: 'message', sound: 'modernmessage' }));
+    });
+
+    it('should use classic sounds when modern sounds are disabled', async () => {
+      mockGetModernNotificationSoundsEnabled.mockReturnValue(false);
+
+      await pushNotificationService.initialize();
+
+      expect(mockCreateChannel).toHaveBeenCalledWith(expect.objectContaining({ id: 'calls', sound: 'notification' }));
+      expect(mockCreateChannel).toHaveBeenCalledWith(expect.objectContaining({ id: '0', sound: 'callemergency' }));
+      expect(mockCreateChannel).toHaveBeenCalledWith(expect.objectContaining({ id: 'notif', sound: 'notification' }));
+      expect(mockCreateChannel).toHaveBeenCalledWith(expect.objectContaining({ id: 'message', sound: 'newmessage' }));
+      // Never falls back to a modern sound when disabled.
+      expect(mockCreateChannel).not.toHaveBeenCalledWith(expect.objectContaining({ sound: 'moderncallemergency' }));
+    });
+
+    it('should leave custom call channels (c1-c25) unaffected by the setting', async () => {
+      mockGetModernNotificationSoundsEnabled.mockReturnValue(true);
+
+      await pushNotificationService.initialize();
+
+      expect(mockCreateChannel).toHaveBeenCalledWith(expect.objectContaining({ id: 'c1', sound: 'c1' }));
+      expect(mockCreateChannel).toHaveBeenCalledWith(expect.objectContaining({ id: 'c25', sound: 'c25' }));
+    });
+
+    it('should delete the standard sound channels before recreating them when the mode changes', async () => {
+      mockGetModernNotificationSoundsEnabled.mockReturnValue(true);
+      mockGetAppliedNotificationSoundMode.mockReturnValue('classic');
+
+      await pushNotificationService.initialize();
+
+      // The 7 standard sound channels are deleted so they can be recreated with the new sound.
+      expect(mockDeleteChannel).toHaveBeenCalledTimes(7);
+      expect(mockDeleteChannel).toHaveBeenCalledWith('0');
+      expect(mockDeleteChannel).toHaveBeenCalledWith('notif');
+      expect(mockDeleteChannel).not.toHaveBeenCalledWith('c1');
+    });
+
+    it('should not delete channels when the sound mode is unchanged', async () => {
+      mockGetModernNotificationSoundsEnabled.mockReturnValue(true);
+      mockGetAppliedNotificationSoundMode.mockReturnValue('modern');
+
+      await pushNotificationService.initialize();
+
+      expect(mockDeleteChannel).not.toHaveBeenCalled();
+      expect(mockCreateChannel).toHaveBeenCalledTimes(32);
+    });
+
+    it('should persist the applied sound mode after setup', async () => {
+      mockGetModernNotificationSoundsEnabled.mockReturnValue(true);
+      mockGetAppliedNotificationSoundMode.mockReturnValue('modern');
+
+      await pushNotificationService.initialize();
+
+      expect(mockSetAppliedNotificationSoundMode).toHaveBeenCalledWith('modern');
+    });
+
+    it('refreshAndroidNotificationChannels recreates channels with the current setting', async () => {
+      mockGetModernNotificationSoundsEnabled.mockReturnValue(false);
+      mockGetAppliedNotificationSoundMode.mockReturnValue('modern');
+
+      await pushNotificationService.refreshAndroidNotificationChannels();
+
+      // Mode changed modern -> classic, so the standard channels are deleted and recreated.
+      expect(mockDeleteChannel).toHaveBeenCalledTimes(7);
+      expect(mockCreateChannel).toHaveBeenCalledWith(expect.objectContaining({ id: '0', sound: 'callemergency' }));
+      expect(mockSetAppliedNotificationSoundMode).toHaveBeenCalledWith('classic');
+    });
   });
 });