tessl/npm-react-native-firebase--messaging

React Native Firebase integration for Firebase Cloud Messaging (FCM) providing cross-platform push notification capabilities

—

Pending

Overview

Eval results

Files

Permissions & Registration

Name: tessl/npm-react-native-firebase--messaging
Author: tessl

Permission management and device registration for receiving push notifications. These features are primarily iOS-focused, as Android handles permissions differently.

Capabilities

Request Permissions

Requests notification permissions from the user. Required on iOS before receiving notifications. Android permissions are handled at install time.

/**
 * Request notification permissions (iOS primarily)
 * @param permissions - Optional iOS permission configuration
 * @returns Promise resolving to AuthorizationStatus
 */
function requestPermission(permissions?: IOSPermissions): Promise<AuthorizationStatus>;

interface IOSPermissions {
  /** Request permission to display alerts (default: true) */
  alert?: boolean;
  /** Request permission for Siri to read notifications over AirPods (default: false, iOS 13+) */
  announcement?: boolean;
  /** Request permission to update the application badge (default: true) */
  badge?: boolean;
  /** Request permission for critical alerts (default: false) */
  criticalAlert?: boolean;
  /** Request permission to display notifications in CarPlay (default: true) */
  carPlay?: boolean;
  /** Request provisional authorization for quiet notifications (default: false, iOS 12+) */
  provisional?: boolean;
  /** Request permission to play sounds (default: true) */
  sound?: boolean;
  /** Request permission to display notification settings button (default: false, iOS 12+) */
  providesAppNotificationSettings?: boolean;
}

enum AuthorizationStatus {
  /** User has not yet chosen whether to allow notifications (iOS) */
  NOT_DETERMINED = -1,
  /** App is not authorized to create notifications */
  DENIED = 0,
  /** App is authorized to create notifications */
  AUTHORIZED = 1,
  /** App is authorized for provisional notifications (iOS 12+) */
  PROVISIONAL = 2,
  /** App is authorized for limited time (iOS 14+, App Clips) */
  EPHEMERAL = 3,
}

Usage Examples:

import messaging from '@react-native-firebase/messaging';

// Request default permissions
const authStatus = await messaging().requestPermission();

if (authStatus === messaging.AuthorizationStatus.AUTHORIZED) {
  console.log('Authorization status:', authStatus);
} else if (authStatus === messaging.AuthorizationStatus.PROVISIONAL) {
  console.log('Provisional authorization granted');
} else {
  console.log('Permission denied');
}

// Request specific permissions (iOS)
const customAuthStatus = await messaging().requestPermission({
  alert: true,
  badge: true,
  sound: true,
  provisional: false,
  criticalAlert: false,
  carPlay: true,
  announcement: false,
  providesAppNotificationSettings: true,
});

// Modular API
import { getMessaging, requestPermission } from '@react-native-firebase/messaging';
const messagingInstance = getMessaging();
const authStatus = await requestPermission(messagingInstance, {
  alert: true,
  badge: true,
  sound: true,
});

Check Permission Status

Checks the current notification permission status without requesting new permissions.

/**
 * Returns current authorization status for notifications
 * @returns Promise resolving to current AuthorizationStatus
 */
function hasPermission(): Promise<AuthorizationStatus>;

Usage Examples:

import messaging from '@react-native-firebase/messaging';

// Check current permission status
const authStatus = await messaging().hasPermission();

switch (authStatus) {
  case messaging.AuthorizationStatus.AUTHORIZED:
    console.log('User has authorized notifications');
    break;
  case messaging.AuthorizationStatus.DENIED:
    console.log('User has denied notifications');
    break;
  case messaging.AuthorizationStatus.NOT_DETERMINED:
    console.log('Permission not requested yet');
    // Request permission
    await messaging().requestPermission();
    break;
  case messaging.AuthorizationStatus.PROVISIONAL:
    console.log('User has provisional authorization');
    break;
}

// Modular API
import { getMessaging, hasPermission } from '@react-native-firebase/messaging';
const messagingInstance = getMessaging();
const authStatus = await hasPermission(messagingInstance);

Device Registration for Remote Messages

Explicitly register the device for remote notifications. Only needed on iOS when auto-registration is disabled.

/**
 * Register device for remote notifications (iOS only)
 * @returns Promise that resolves when registration is complete
 */
function registerDeviceForRemoteMessages(): Promise<void>;

/**
 * Check if device is registered for remote notifications
 * @returns Boolean indicating registration status (iOS only, Android always returns true)
 */
readonly isDeviceRegisteredForRemoteMessages: boolean;

/**
 * Unregister device from remote notifications (iOS only)
 * @returns Promise that resolves when unregistration is complete
 */
function unregisterDeviceForRemoteMessages(): Promise<void>;

Usage Examples:

import messaging from '@react-native-firebase/messaging';

// Check if already registered
if (!messaging().isDeviceRegisteredForRemoteMessages) {
  // Register for remote notifications
  await messaging().registerDeviceForRemoteMessages();
  console.log('Device registered for remote messages');
}

// Unregister when user opts out
await messaging().unregisterDeviceForRemoteMessages();
console.log('Device unregistered from remote messages');

// Modular API
import { 
  getMessaging, 
  isDeviceRegisteredForRemoteMessages,
  registerDeviceForRemoteMessages,
  unregisterDeviceForRemoteMessages 
} from '@react-native-firebase/messaging';

const messagingInstance = getMessaging();

if (!isDeviceRegisteredForRemoteMessages(messagingInstance)) {
  await registerDeviceForRemoteMessages(messagingInstance);
}

await unregisterDeviceForRemoteMessages(messagingInstance);

Utility Functions

Additional utilities for checking messaging support and configuration.

/**
 * Check if messaging is supported on current platform
 * @returns Promise resolving to boolean indicating support
 */
function isSupported(): Promise<boolean>;

Usage Examples:

import messaging from '@react-native-firebase/messaging';

// Check if messaging is supported
const supported = await messaging().isSupported();

if (supported) {
  console.log('Messaging is supported');
  // Proceed with messaging setup
  await messaging().requestPermission();
} else {
  console.log('Messaging not supported on this platform');
  // Handle unsupported scenario
}

// Modular API
import { getMessaging, isSupported } from '@react-native-firebase/messaging';
const messagingInstance = getMessaging();
const supported = await isSupported(messagingInstance);

Permission Workflow

iOS Permission Flow

Check Status: Use hasPermission() to check current state
Request Permission: Call requestPermission() if needed
Handle Response: Process the authorization status
Register Device: Call registerDeviceForRemoteMessages() if auto-registration disabled
Get Token: Retrieve FCM token once permissions granted

Android Permission Flow

Automatic: Permissions granted at install time for target SDK < 33
Runtime: For target SDK 33+, use standard Android permission request
Always Authorized: requestPermission() always returns AUTHORIZED

Permission Best Practices

Check Before Request: Always check current status before requesting
Explain Purpose: Show UI explaining why notifications are needed
Handle Denial: Provide fallback experience when permissions denied
Respect Preferences: Don't repeatedly ask after denial
Guide to Settings: Direct users to system settings if needed

Common Permission Scenarios

import messaging from '@react-native-firebase/messaging';

async function setupMessaging() {
  // Check if messaging is supported
  const supported = await messaging().isSupported();
  if (!supported) {
    console.log('Messaging not supported');
    return;
  }

  // Check current permission status
  let authStatus = await messaging().hasPermission();
  
  if (authStatus === messaging.AuthorizationStatus.NOT_DETERMINED) {
    // Request permission
    authStatus = await messaging().requestPermission({
      alert: true,
      badge: true,
      sound: true,
      provisional: false,
    });
  }

  if (authStatus === messaging.AuthorizationStatus.AUTHORIZED || 
      authStatus === messaging.AuthorizationStatus.PROVISIONAL) {
    
    // Ensure device is registered (iOS)
    if (!messaging().isDeviceRegisteredForRemoteMessages) {
      await messaging().registerDeviceForRemoteMessages();
    }
    
    // Get FCM token
    const token = await messaging().getToken();
    console.log('FCM Token:', token);
    
    return token;
  } else {
    console.log('Permission denied');
    return null;
  }
}

Install with Tessl CLI

npx tessl i tessl/npm-react-native-firebase--messaging

docs

permissions-registration.md

token-management.md

topic-management.md

tile.json

tessl/npm-react-native-firebase--messaging