Berechtigungen für FCM-Push-Benachrichtigungen fordern

[kjahandel]

Hallo zusammen,

ich habe festgestellt, dass beim Start der App keine Berechtigungsanforderungen für iOS- oder Android-Geräte gestellt werden. Ich erwarte jedoch, dass der Nutzer beim Start der App dazu aufgefordert wird, Berechtigungen zu erteilen. Hier ist der relevante Code:

Für weitere Hilfe oder Anregungen, wie ich dieses Problem lösen kann, bin ich sehr dankbar.

---

import React, { useEffect, createContext, useContext, useState } from 'react';
import { PermissionsAndroid, Platform, Alert } from 'react-native';
import AsyncStorage from '@react-native-async-storage/async-storage';
import messaging from '@react-native-firebase/messaging';
import notifee, { EventType, AndroidImportance, AndroidBadgeIconType } from '@notifee/react-native';

// Erstellen des Contexts
const FCMContext = createContext();

// Hook zum Verwenden des FCM-Contexts
export const useFCM = () => useContext(FCMContext);

// Funktion zum Überprüfen und Aktualisieren des Gerätetokens
const checkAndUpdateDeviceToken = async () => {
try {
// Token aus dem AsyncStorage abrufen
const storedToken = await AsyncStorage.getItem('deviceToken');

// Überprüfen der Gültigkeit des gespeicherten Tokens
const isValidToken = storedToken && storedToken.length > 10;

if (!isValidToken) {
  // Token ist ungültig oder nicht vorhanden, neues Token abrufen und speichern
  const newToken = await messaging().getToken();
  await AsyncStorage.setItem('deviceToken', newToken);
  return newToken;
}

return storedToken;

} catch (error) {
console.error('Fehler beim Überprüfen und Aktualisieren des Gerätetokens:', error);
Alert.alert('Fehler', 'Beim Überprüfen und Aktualisieren des Gerätetokens ist ein Fehler aufgetreten.');
return null;
}
};

// Funktion zum Anfordern von Benachrichtigungsberechtigungen
const requestNotificationPermission = async () => {
try {
const permissionGranted = await notifee.requestPermission();

if (permissionGranted) {
  console.log('Benachrichtigungsberechtigung erteilt.');
} else {
  console.log('Benachrichtigungsberechtigung verweigert.');
}

} catch (error) {
console.error('Fehler beim Anfordern der Benachrichtigungsberechtigung:', error);
Alert.alert('Fehler', 'Beim Anfordern der Benachrichtigungsberechtigung ist ein Fehler aufgetreten.');
}
};

// Context-Provider-Komponente
export const FCMProvider = ({ children }) => {
const [deviceToken, setDeviceToken] = useState(null);

// Funktion zum Anzeigen der Benachrichtigung mit Titel und Nachricht
const displayNotification = async (title, message) => {
try {
await notifee.displayNotification({
title: title,
body: message,
android: {
channelId: 'default',
badgeIconType: AndroidBadgeIconType.SMALL,
importance: AndroidImportance.HIGH, // Setze die Wichtigkeit auf hoch
},
});
} catch (error) {
console.error('Fehler beim Anzeigen der Benachrichtigung:', error);
Alert.alert('Fehler', 'Beim Anzeigen der Benachrichtigung ist ein Fehler aufgetreten.');
}
};

useEffect(() => {
// App launched, remove the badge count
notifee.setBadgeCount(0).then(() => console.log('Badge count removed'));

// Handler für Benachrichtigungsereignisse registrieren
const unsubscribeMessage = messaging().onMessage(async remoteMessage => {
  // Benachrichtigung anzeigen
  if (Platform.OS === 'android') {
    // Für Android-Benachrichtigungen
    const { title, body } = remoteMessage.notification;
    // Display the notification with title and message
    await displayNotification(title, body);
  } else if (Platform.OS === 'ios') {
    // Für iOS-Benachrichtigungen
    const { title, body } = remoteMessage.notification;
    try {
      await notifee.displayNotification({
        title: title,
        body: body,
      });

      // Badge-Anzahl erhöhen
      await notifee.incrementBadgeCount();
    } catch (error) {
      console.error('Fehler beim Anzeigen der Benachrichtigung:', error);
      Alert.alert('Fehler', 'Beim Anzeigen der Benachrichtigung ist ein Fehler aufgetreten.');
    }
  }
});

// Hintergrundhandler für Benachrichtigungen registrieren
const backgroundHandler = async (remoteMessage) => {
  try {
    // Benachrichtigung anzeigen
    await notifee.displayNotification(remoteMessage);

    // Badge-Anzahl erhöhen
    await notifee.incrementBadgeCount();
  } catch (error) {
    console.error('Fehler beim Verarbeiten der Hintergrundnachricht:', error);
    Alert.alert('Fehler', 'Beim Verarbeiten der Hintergrundnachricht ist ein Fehler aufgetreten.');
  }
};

messaging().setBackgroundMessageHandler(backgroundHandler);

// Hintergrundereignis-Handler für Notifee festlegen
notifee.onBackgroundEvent(async ({ type, detail }) => {
  const { notification, pressAction } = detail;

  // Check if the user pressed the "Mark as read" action
  if (type === EventType.ACTION_PRESS && pressAction.id === 'mark-as-read') {
    // Decrement the count by 1
    await notifee.decrementBadgeCount();

    // Remove the notification
    await notifee.cancelNotification(notification.id);
  }
});

return () => {
  unsubscribeMessage();
};

}, []);

useEffect(() => {
Alert.alert('requestPermissions aufgerufen!');
const requestPermissions = async () => {
try {
// Berechtigungen für iOS anfordern
if (Platform.OS === 'ios') {
const authStatus = await messaging().requestPermission();
const enabled =
authStatus === messaging.AuthorizationStatus.AUTHORIZED ||
authStatus === messaging.AuthorizationStatus.PROVISIONAL;

      if (enabled) {
        console.log('Authorization status:', authStatus);
      }
    }

    // Berechtigungen für Android anfordern
    if (Platform.OS === 'android') {
      try {
        await requestNotificationPermission(); // Benachrichtigungsberechtigungen anfordern
        // await PermissionsAndroid.request(
        //   PermissionsAndroid.PERMISSIONS.NOTIFICATIONS,
        // );
      } catch (error) {
        console.error(error);
        Alert.alert('Fehler', 'Beim Anfordern der Benachrichtigungsberechtigung ist ein Fehler aufgetreten.');
      }
    }

    // Gerätetoken überprüfen und aktualisieren
    const newToken = await checkAndUpdateDeviceToken();
    setDeviceToken(newToken);
  } catch (error) {
    console.error('Fehler beim Anfordern von Berechtigungen:', error);
    Alert.alert('Fehler', 'Beim Anfordern von Berechtigungen ist ein Fehler aufgetreten.');
  }
};

requestPermissions();

}, []);

return (
<FCMContext.Provider value={{ deviceToken }}>
{children}
</FCMContext.Provider>
);
};