managarten/apps-archived/memoro/apps/mobile/features/notifications/NotificationService.native.ts

import notifee, { AndroidImportance, AuthorizationStatus } from '@notifee/react-native';
import {
	NotificationChannel,
	UpdateableNotification,
	UpdateableNotificationOptions,
} from './types';

interface NotificationInstance {
	lastUpdateTime: number;
}

class NotificationService {
	private static notificationInstances = new Map<string, NotificationInstance>();

	public static async requestNotificationPermission(): Promise<boolean> {
		const settings = await notifee.requestPermission();
		return settings.authorizationStatus === AuthorizationStatus.AUTHORIZED;
	}

	public async showNotification(
		title: string,
		body: string,
		channelType: NotificationChannel = NotificationChannel.DEFAULT,
		asForegroundService = false
	): Promise<void> {
		try {
			const hasPermission = await NotificationService.requestNotificationPermission();
			if (!hasPermission) return;

			const channelId = await notifee.createChannel({
				id: channelType,
				name: channelType,
				importance: asForegroundService ? AndroidImportance.HIGH : AndroidImportance.DEFAULT,
			});

			await notifee.displayNotification({
				title,
				body,
				android: {
					channelId,
					importance: asForegroundService ? AndroidImportance.HIGH : AndroidImportance.DEFAULT,
					ongoing: asForegroundService,
					asForegroundService,
					pressAction: {
						id: 'default',
					},
				},
				ios: {
					// iOS specific options
					foregroundPresentationOptions: {
						badge: true,
						sound: true,
						banner: true,
						list: true,
					},
				},
			});
		} catch (error) {
			console.error('Fehler beim Anzeigen der Benachrichtigung:', error);
		}
	}

	public async stopForegroundService(): Promise<void> {
		try {
			await notifee.stopForegroundService();
		} catch (error) {
			console.error('Fehler beim Stoppen des Foreground-Services:', error);
		}
	}

	public createUpdateableNotification(instanceId: string): UpdateableNotification {
		if (!NotificationService.notificationInstances.has(instanceId)) {
			NotificationService.notificationInstances.set(instanceId, {
				lastUpdateTime: 0,
			});
		}

		const update = async (
			title: string,
			message: string,
			options: UpdateableNotificationOptions = {}
		): Promise<void> => {
			const { minUpdateInterval = 1000, requireInteraction = true, silent = true } = options;

			try {
				const hasPermission = await NotificationService.requestNotificationPermission();
				if (!hasPermission) return;

				const instance = NotificationService.notificationInstances.get(instanceId)!;
				const now = Date.now();

				if (now - instance.lastUpdateTime >= minUpdateInterval) {
					const channelId = await notifee.createChannel({
						id: instanceId,
						name: 'Default Channel',
						importance: AndroidImportance.DEFAULT,
					});

					await notifee.displayNotification({
						id: instanceId,
						title,
						body: message,
						android: {
							channelId,
							importance: AndroidImportance.DEFAULT,
							ongoing: requireInteraction,
							pressAction: {
								id: 'default',
							},
						},
						ios: {
							// iOS specific options
							foregroundPresentationOptions: {
								badge: !silent,
								sound: !silent,
								banner: true,
								list: true,
							},
						},
					});

					instance.lastUpdateTime = now;
				}
			} catch (error) {
				console.error('Fehler beim Aktualisieren der Benachrichtigung:', error);
			}
		};

		const finish = async (title: string, message: string): Promise<void> => {
			NotificationService.notificationInstances.delete(instanceId);
			await notifee.cancelNotification(instanceId);
			const channelId = await notifee.createChannel({
				id: 'default',
				name: 'Default Channel',
				importance: AndroidImportance.DEFAULT,
			});
			await notifee.displayNotification({
				title,
				body: message,
				android: {
					channelId,
					importance: AndroidImportance.DEFAULT,
				},
				ios: {
					foregroundPresentationOptions: {
						badge: true,
						sound: true,
						banner: true,
						list: true,
					},
				},
			});
		};

		const error = async (title: string, message: string): Promise<void> => {
			NotificationService.notificationInstances.delete(instanceId);
			await notifee.cancelNotification(instanceId);
			const channelId = await notifee.createChannel({
				id: 'default',
				name: 'Default Channel',
				importance: AndroidImportance.HIGH,
			});
			await notifee.displayNotification({
				title,
				body: message,
				android: {
					channelId,
					importance: AndroidImportance.HIGH,
				},
				ios: {
					foregroundPresentationOptions: {
						badge: true,
						sound: true,
						banner: true,
						list: true,
					},
				},
			});
		};

		return {
			update,
			finish,
			error,
		};
	}
}

// Standard-Export der Instanz
export default new NotificationService();

// Benannter Export der statischen Methode
export const { requestNotificationPermission } = NotificationService;