Are there problems with background handler at Messaging v7.9.0 iOS ?

[game8149]

Hi guys,

I was working with "@react-native-firebase/app": "^8.4.1" and "@react-native-firebase/messaging": "^7.8.4", few days ago and everything was fine, except for setBackgroundHandler that never was called when app is closed.

Yesterday, I updated my dependencies searching some solution to handler problem but now I'm stunned: setBackgroundHandler doesn't work at any case. No when app is on background and less when it is killed.

Today, I've made a new cleaning project with only RNFB dependencies, but this problem persists. Maybe, I'm on the wrong way. Please check my files.

index.js

import React from 'react' 
import {AppRegistry} from 'react-native';
import App from './App';
import {name as appName} from './app.json';
import messaging from '@react-native-firebase/messaging'; 
 
messaging().setBackgroundMessageHandler(async (remoteMessage) => { 
    console.log('let me know'); 
});

function HeadlessCheck({ isHeadless }){
    console.log(isHeadless);
    if (isHeadless) { 
        return null;
    } 
    return <App/>;
} 
AppRegistry.registerComponent(appName, ()=> HeadlessCheck);  

App.tsx

import React, {
  useEffect,
  useState
} from 'react';
import { AppState,View } from 'react-native'   
import ServiceFCM from './src/functions/FCM.service';    

let onLoad = false;

const App: React.FC = () => {
  const [onNotificationRecieved, setNofiticationRecieved] = useState(
    false,
  );
  const [notificationBehaviour, setNotificationBehaviour] = useState(
    '',
  );

  const [permissions, setPermissions] = useState({});

  useEffect(() => {
    onLoad = false;
    async function init() {  
      ServiceFCM.requestOnlyUserPermission().then(async (auth) => { 
        await ServiceFCM.registerDeviceAPNS(auth);
        await ServiceFCM.registerFCM(onRegister, onNoti, onOpenNoti);
      });

      function onRegister(token) {
      }

      function onNoti(remoteMessage) { 
        console.log(remoteMessage, 'llegadaNoti', AppState.currentState);  
      }

      async function onOpenNoti(noti) { 
        console.log(noti, 'abierto'); 
      }

      return;
    }

    if (!onLoad) {
      onLoad = true;
      init().then((x) => {
      }).catch((err) => {  
      }).finally(() => { 
      });
    }

    return () => { 
    };
  }, [notificationBehaviour]);

  return (
    <> 
        <View /> 
    </>
  );
};

export default App;

FCM.service.ts

import messaging from '@react-native-firebase/messaging';
import { Platform } from 'react-native';   
import { callFunction } from './UtilNet.service';

class ServiceFCM { 
    registerDeviceAPNS = async (auth) => {
        if (Platform.OS === 'ios') {
            try {
                let atl = await messaging().registerDeviceForRemoteMessages();
                console.log('Register APNS Success', auth ? auth.toString() : '(Re requerired)');
                await messaging().setAutoInitEnabled(true);

                let response = await callFunction('APN Token', {
                    actioner: async () => {
                        return await messaging().getAPNSToken();
                    },
                    successCondition: (resp) => {
                        return resp !== null;
                    },
                    attemps: 4
                });
            }
            catch (err) { 
                console.log('Register APNS / Error Message ', err.message); 
            }
        }
    };

    registerFCM = async (
        onRegister,
        onNotification,
        onOpenNotification
    ) => {
        await this.checkPermission(onRegister);
 
        messaging().onTokenRefresh(async (fcmToken) => { 
            console.log('token invalidado');
        });

        messaging().onNotificationOpenedApp(async (remoteMessage) => {
            // writeDebug('Abierto Noti', remoteMessage);
            await onOpenNotification(remoteMessage); 
        });

        messaging()
            .getInitialNotification()
            .then((remoteMessage) => {
                if (remoteMessage) { 
                }
            });

        messaging().onMessage((remoteMessage) => { 
            if (remoteMessage) {
                onNotification(remoteMessage);
            }
        });
    };

    refreshToken = async () => {
        await messaging().deleteToken();
        await this.requestUserPermission();
    };

    requestUserPermission = async (onRegister?) => {
        let userPermission = await messaging().requestPermission();
        console.log('Permiso cedido', userPermission);
        if (userPermission == messaging.AuthorizationStatus.AUTHORIZED || userPermission == messaging.AuthorizationStatus.PROVISIONAL)
            await this.getFcmToken(onRegister); 

    };

    requestOnlyUserPermission = async () => {
        return messaging().requestPermission();
    };

    getFcmToken = async (onRegister) => {
        let fcmToken = null;
        try {
            fcmToken = await messaging().getToken();
        }
        catch (err) { 
            console.log('Get Token FCM / Error Message ', err.message); 
        }
        if (fcmToken) { 
            console.log('Token en Memoria', fcmToken); 
        } else {
            console.log('Token FCM', 'No token received');
        }
    };

    getCurrentToken = async () => {
        let token = await messaging().getAPNSToken();
        return token;
    }

    checkPermission = async (onRegister) => {
        try {
            let enabled = await messaging().hasPermission();
            console.log('Tiene Permiso Noti', enabled);
            if (enabled == messaging.AuthorizationStatus.AUTHORIZED || enabled == messaging.AuthorizationStatus.PROVISIONAL) {
                await this.getFcmToken(onRegister);
            } else {
                await this.requestUserPermission(onRegister);
            }
        } catch (err) { 
            console.log('Permission/ Error Message ', err.message); 
        }
    };
}

export default new ServiceFCM();

UtilNet.services.ts

let TIME_OUT = 60000;

type ConfigCallFunction = {
  actioner: any,
  successCondition: any,
  attemps?: number
}


export const callFunction = async function (name: string, config: ConfigCallFunction) {
  if (!(config.attemps > 0))
      config.attemps = 1;
  let currentAttemp = 0;
  let response = null;
  let formatAttemp = () => {
      return config.attemps > 1 ? `Att. ${currentAttemp + 1}` : '';
  }

  let start = null, finish = null;
  let callFunctions = async () => {
      try { 
          start = Date.now();
          response = await config.actioner();
          finish = Date.now() - start; 
      }
      catch (err) {
          if (!finish)
              finish = Date.now() - start;  
      }
      return response;
  }

  while (currentAttemp < config.attemps) {
      if (config.successCondition(await callFunctions()))
          break;
      currentAttemp++;
  }

  return response;
}

[mikehardy]

This ignores large chunks of the template which are interesting. Like, what platform, and the native files involved in platform initialization etc

[mikehardy]

"the template" - it's present on bug reports. This is a bug report, not a discussion. Can you open a new bug report following the template?

[game8149]

ok, I'll post there

[mikehardy]

final note from me on this: I am fully up to date and just successfully sent 3 data-only messages which were handled in foreground, background, and headless in my project (mmm on android - I note you mention iOS - I'll test there but make sure you use a real device only, simulators are invalid for messaging testing)

Something is wrong with your usage I think

    "@react-native-firebase/analytics": "^7.6.7",
    "@react-native-firebase/app": "^8.4.5",
    "@react-native-firebase/auth": "^9.3.0",
    "@react-native-firebase/crashlytics": "^8.4.9",
    "@react-native-firebase/dynamic-links": "^7.5.9",
    "@react-native-firebase/firestore": "^7.8.6",
    "@react-native-firebase/functions": "^7.4.8",
    "@react-native-firebase/iid": "^7.4.8",
    "@react-native-firebase/in-app-messaging": "^7.5.6",
    "@react-native-firebase/messaging": "^7.9.0",
    "@react-native-firebase/perf": "^7.4.8",
    "@react-native-firebase/remote-config": "^9.0.10",
    "@react-native-firebase/storage": "^7.4.9",