Understanding Local and Remote Notifications in React Native

Course: React Native Training

Topic: Understanding Local and Remote Notifications

Course Link: React Native Training at JustAcademy

Demo Link: Register for a Course Demo

JustAcademy Website: Visit JustAcademy

1. Introduction to Notifications in React Native

Notifications are messages displayed by mobile applications to inform users about important events, reminders, updates, messages, and activities. They help applications communicate with users even when the application is not actively open on the screen.

In React Native, developers can implement notifications for Android and iOS using notification libraries, native platform APIs, and cloud messaging services. The two main types are local notifications and remote notifications.

For example, a fitness application may schedule a local notification reminding a user to exercise at 6:00 PM. A shopping application may send a remote notification when an order is shipped.

1.1 What Are Local Notifications?

Local notifications are created or scheduled by the application on the user's device. They do not require a remote server to initiate each notification.

Examples include daily reminders, alarms, medication reminders, calendar alerts, and notifications for locally scheduled tasks.

1.2 What Are Remote Notifications?

Remote notifications, commonly called push notifications, are initiated by a remote server or notification service and delivered to a device through platform push infrastructure.

Examples include new chat messages, order status updates, breaking news alerts, promotional announcements, and account security notifications.

1.3 Why Are Notifications Important?

• Keep users informed about important events.
• Provide reminders for scheduled activities.
• Communicate changes in order, booking, or delivery status.
• Help users return to an application when relevant information is available.
• Improve communication between users and application services.
• Support time-sensitive updates and workflow notifications.

2. Learning Objectives

After studying this topic, learners should be able to:

• Understand the difference between local and remote notifications.
• Explain how notification delivery works on Android and iOS.
• Implement local notifications using React Native notification libraries.
• Schedule immediate, delayed, and repeating notifications.
• Understand push notification tokens and cloud messaging services.
• Configure notification permissions and Android notification channels.
• Handle notification reception and user interactions.
• Navigate to the appropriate application screen when a notification is tapped.
• Test notifications in foreground, background, and terminated application states.
• Apply notification security, privacy, and battery-efficiency best practices.

3. Understanding Local Notifications

A local notification is generated or scheduled by the application on the device. Once a notification is scheduled successfully, the operating system may present it at the configured time even when the application is not open, subject to permissions, system settings, and platform restrictions.

3.1 Examples of Local Notifications

• Daily reminders: Remind users to complete a daily activity.
• Task reminders: Notify users before a task deadline.
• Fitness reminders: Remind users to walk or exercise.
• Calendar alerts: Notify users about upcoming events.
• Offline reminders: Schedule a notification without requiring a server to send it at the notification time.
• Study reminders: Remind learners to attend a class or revise a topic.

3.2 How Local Notifications Work

1. The user performs an action, such as creating a reminder.
2. The application prepares the notification title, message, and optional data.
3. The application requests permission when required.
4. The notification is presented immediately or scheduled for a future time.
5. The operating system manages presentation and delivery according to its rules.
6. The user can tap the notification to open the application or perform an associated action.

3.3 Advantages of Local Notifications

• They can be scheduled directly from the application.
• They are useful for reminders that do not depend on server events.
• They can support offline reminder scenarios once scheduled.
• They can reduce the need for a backend service for simple reminders.
• They can be scheduled for a specific date or recurring time where supported.

3.4 Limitations of Local Notifications

• They cannot independently know about new events on a remote server.
• Users can deny notification permissions or disable notifications in system settings.
• Operating-system scheduling policies may affect exact delivery times.
• Application data removal, reinstallation, or other system events may affect scheduled notifications.
• Recurring schedules and exact-alarm behavior differ across platforms and operating-system versions.

4. Implementing Local Notifications with Expo Notifications

One cross-platform option for React Native projects is the expo-notifications library. It provides APIs for presenting, scheduling, receiving, and responding to notifications.

Official documentation: Expo Notifications API Reference.

4.1 Install the Library

For an Expo-based React Native project, install the compatible package using Expo's installation command:

npx expo install expo-notifications

Use the package version compatible with your Expo SDK. If you use a bare React Native project, review the library's native installation and configuration requirements.

4.2 Configure Notification Behavior

When the application is in the foreground, notification presentation may require an explicit handler. Configure the handler at application startup, outside the screen component.

import * as Notifications from 'expo-notifications';

Notifications.setNotificationHandler({
  handleNotification: async () => ({
    shouldShowBanner: true,
    shouldShowList: true,
    shouldPlaySound: false,
    shouldSetBadge: false
  })
});

This example allows notifications to display a banner and appear in the notification list when supported. Sound and badge updates are disabled in this example. You can change these settings according to the application requirements and the installed library version.

4.3 Display an Immediate Local Notification

The following example schedules a notification with no time trigger, so it is requested for immediate presentation.

import React from 'react';
import { View, Button } from 'react-native';
import * as Notifications from 'expo-notifications';

export default function LocalNotificationScreen() {
  const showNotification = async () => {
    await Notifications.scheduleNotificationAsync({
      content: {
        title: 'Welcome!',
        body: 'Your local notification is working.',
        data: {
          screen: 'Home'
        }
      },
      trigger: null
    });
  };

  return (
    <View>
      <Button
        title="Show Notification"
        onPress={showNotification}
      />
    </View>
  );
}

When the user presses the button, the application requests an immediate local notification. On a real device, visible presentation depends on permission, operating-system settings, and foreground notification configuration.

4.4 Request Notification Permission

Mobile operating systems may require users to authorize notification delivery. The permission flow should be clear and should explain the value of notifications before prompting when appropriate.

import * as Notifications from 'expo-notifications';

export async function requestNotificationPermission() {
  const current = await Notifications.getPermissionsAsync();

  if (current.granted) {
    return true;
  }

  const result = await Notifications.requestPermissionsAsync();

  return result.granted;
}

Call this function at an appropriate point in the user journey. For example, a reminder application might request permission after the user creates their first reminder rather than immediately at startup.

Permission behavior varies by operating system and version. On some Android versions, notification permission is not presented in the same way as on iOS. The example checks whether permission is granted, but production applications may also need to inspect the detailed permission status and explain how users can enable notifications in system settings.

5. Scheduling Local Notifications

Scheduling allows an application to request that a notification be presented at a future time. This is useful for reminders, appointments, deadlines, and recurring activities.

5.1 Schedule a Notification After a Delay

import * as Notifications from 'expo-notifications';

export async function scheduleDelayedNotification() {
  const notificationId =
    await Notifications.scheduleNotificationAsync({
      content: {
        title: 'Reminder',
        body: 'Your scheduled activity is coming up.'
      },
      trigger: {
        type: Notifications.SchedulableTriggerInputTypes.TIME_INTERVAL,
        seconds: 60
      }
    });

  return notificationId;
}

This example requests a notification after a 60-second interval. The operating system may not present it at an exact second because delivery is subject to scheduling rules and device settings.

5.2 Schedule a Notification for a Specific Date

import * as Notifications from 'expo-notifications';

export async function scheduleDateNotification() {
  const reminderDate = new Date();
  reminderDate.setMinutes(reminderDate.getMinutes() + 5);

  const notificationId =
    await Notifications.scheduleNotificationAsync({
      content: {
        title: 'Upcoming Event',
        body: 'Your event reminder is ready.'
      },
      trigger: {
        type: Notifications.SchedulableTriggerInputTypes.DATE,
        date: reminderDate
      }
    });

  return notificationId;
}

This example schedules a notification for approximately five minutes in the future. In a production application, validate the chosen date and handle timezone changes and invalid scheduling requests.

5.3 Schedule a Repeating Notification

Repeating notifications are useful for daily reminders or recurring activities. The exact trigger format depends on the installed Expo Notifications version and the desired scheduling behavior.

import * as Notifications from 'expo-notifications';

export async function scheduleDailyReminder() {
  return Notifications.scheduleNotificationAsync({
    content: {
      title: 'Daily Reminder',
      body: 'Take a moment to review your daily goals.'
    },
    trigger: {
      type: Notifications.SchedulableTriggerInputTypes.DAILY,
      hour: 18,
      minute: 0
    }
  });
}

This example requests a daily reminder at 6:00 PM local time where the trigger is supported. Check the current library documentation for exact trigger types and platform-specific behavior.

5.4 Cancel a Scheduled Notification

Users should be able to cancel reminders when they are no longer relevant. Save the notification identifier returned when scheduling a notification.

import * as Notifications from 'expo-notifications';

export async function cancelReminder(notificationId) {
  await Notifications.cancelScheduledNotificationAsync(
    notificationId
  );
}

To cancel all scheduled local notifications, use the appropriate API:

await Notifications.cancelAllScheduledNotificationsAsync();

Use the cancel-all operation carefully because it removes every scheduled notification managed by the library, not just one particular reminder.

6. Understanding Remote Notifications

Remote notifications are initiated by a backend service, cloud messaging platform, or another authorized sender and delivered to a device through the platform's push notification infrastructure.

For example, when an order changes to "Shipped" in an online store, the backend can generate a notification for the customer. The backend determines the event and the push service routes the message to the intended device.

6.1 Common Remote Notification Use Cases

• New chat messages and mentions.
• Order confirmation and delivery updates.
• Appointment confirmations and changes.
• Security alerts and account activity.
• Breaking news and important announcements.
• Relevant product updates and user-requested reminders managed by a server.

6.2 Advantages of Remote Notifications

• Notify users about events that occur on a server.
• Deliver updates even when the application is not currently open, subject to system rules.
• Support communication across multiple user devices.
• Integrate with backend databases and business workflows.
• Support targeted notifications when appropriate consent and privacy requirements are met.

6.3 Limitations of Remote Notifications

• They require push infrastructure and suitable device credentials or tokens.
• Delivery depends on network connectivity and push service availability.
• Users may deny permission or disable notifications.
• Messages may be delayed, collapsed, expired, or not delivered.
• Background execution is limited by operating-system policies.
• Token management, backend security, and platform configuration require maintenance.

7. Local Notifications vs Remote Notifications

8. Push Notification Architecture

A remote notification system usually includes the mobile application, a backend server, a push messaging service, and the operating system.

8.1 Main Components

• React Native application: Requests permissions, obtains a token, and handles notification events.
• Backend server: Determines when notifications should be sent and which users should receive them.
• Push service: Routes messages to the device. Examples include Expo Push Service, Firebase Cloud Messaging (FCM), and Apple Push Notification service (APNs).
• Device operating system: Applies permission and notification settings and manages notification presentation.
• Application navigation: Opens the appropriate screen when the user taps the notification.

8.2 Remote Notification Flow

1. The application requests notification permission when appropriate.
2. The application registers with a push service and obtains a push token.
3. The application sends the token to the backend over a secure connection.
4. An event occurs on the backend, such as an order being shipped.
5. The backend sends a message through the chosen push service.
6. The push infrastructure attempts to deliver the message to the device.
7. The operating system displays the notification when allowed, or the application processes the message according to the platform and message type.
8. The user taps the notification, and the application handles the interaction.

9. Implementing Remote Notifications with Expo

Expo Notifications provides a cross-platform approach for managing notification permissions, tokens, received messages, and user responses.

Official guide: Expo Push Notifications Overview.

9.1 Important Setup Requirements

• Install expo-notifications using the command compatible with the project's Expo SDK.
• Configure the notification plugin and platform credentials as required.
• Set up Android Firebase Cloud Messaging credentials when using the relevant push setup.
• Configure Apple push notification credentials for iOS remote notifications.
• Use a development build for supported push notification workflows that require native configuration.
• Test on a physical device where required and verify the actual build configuration.

Remote push notifications are not fully supported in Expo Go on Android from SDK 53 onward; use a development build for push notification testing. Local notifications remain available in Expo Go. Platform capabilities can change, so consult the documentation for the project's SDK version.

9.2 Obtain an Expo Push Token

import * as Notifications from 'expo-notifications';
import Constants from 'expo-constants';

export async function getExpoPushToken() {
  const permission =
    await Notifications.getPermissionsAsync();

  let granted = permission.granted;

  if (!granted) {
    const requested =
      await Notifications.requestPermissionsAsync();

    granted = requested.granted;
  }

  if (!granted) {
    return null;
  }

  const projectId =
    Constants.expoConfig?.extra?.eas?.projectId ??
    Constants.easConfig?.projectId;

  if (!projectId) {
    throw new Error('Expo project ID is not configured.');
  }

  const tokenResponse =
    await Notifications.getExpoPushTokenAsync({
      projectId
    });

  return tokenResponse.data;
}

This example checks permission and retrieves an Expo push token. Configure the EAS project ID correctly and handle errors, token refreshes, and unsupported device environments in production.

9.3 Register the Token with Your Backend

After obtaining the token, the application can send it to its backend so the server can associate it with the appropriate user or device.

export async function registerPushToken(token, accessToken) {
  const response = await fetch(
    'https://api.example.com/devices/push-token',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        Authorization: `Bearer ${accessToken}`
      },
      body: JSON.stringify({
        token,
        platform: 'mobile'
      })
    }
  );

  if (!response.ok) {
    throw new Error('Failed to register push token.');
  }

  return response.json();
}

Security note: Replace the example API address with your own secure backend. Authenticate the request, validate the token server-side, avoid logging sensitive credentials, and support removing or updating device registrations when users sign out or tokens change.

9.4 Send a Push Notification from a Backend

The backend can send a message through the Expo Push Service API using a registered Expo push token. Keep service credentials and any sensitive business logic on the server rather than embedding them in the mobile application.

const message = {
  to: expoPushToken,
  sound: 'default',
  title: 'Order Shipped',
  body: 'Your order is on its way.',
  data: {
    screen: 'OrderDetails',
    orderId: 'ORDER_123'
  }
};

const response = await fetch(
  'https://exp.host/--/api/v2/push/send',
  {
    method: 'POST',
    headers: {
      Accept: 'application/json',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify(message)
  }
);

const result = await response.json();

This is a simplified server-side example. The token must be valid, and the sending environment must be configured correctly. A successful HTTP response does not necessarily mean that the device displayed the notification. Production systems should process service receipts, errors, invalid tokens, and retryable failures according to the official documentation.

10. Handling Incoming Notifications

An application needs to decide what happens when a notification arrives while the application is open and what happens when the user taps a notification from the notification tray.

10.1 Listen for Received Notifications

The addNotificationReceivedListener API allows an application to react when a notification is received while the app is running.

import { useEffect } from 'react';
import * as Notifications from 'expo-notifications';

export function useNotificationReceived() {
  useEffect(() => {
    const subscription =
      Notifications.addNotificationReceivedListener(
        notification => {
          console.log(
            'Notification received:',
            notification.request.content.title
          );
        }
      );

    return () => subscription.remove();
  }, []);
}

Register listeners at a suitable point in the application lifecycle. Remove subscriptions when they are no longer needed to avoid duplicate listeners and memory-related issues.

10.2 Listen for Notification Responses

The addNotificationResponseReceivedListener API allows an application to respond when a user interacts with a notification, such as tapping it.

import { useEffect } from 'react';
import * as Notifications from 'expo-notifications';

export function useNotificationResponse() {
  useEffect(() => {
    const subscription =
      Notifications.addNotificationResponseReceivedListener(
        response => {
          const data =
            response.notification.request.content.data;

          console.log('Notification tapped:', data);
        }
      );

    return () => subscription.remove();
  }, []);
}

Use the notification's data to decide what screen or action is appropriate. Validate the data before using it, especially when it identifies a user account, order, payment, or other protected resource.

11. Navigating to a Screen from a Notification

Notifications often contain information that should take users directly to a relevant screen. This behavior is commonly called notification navigation or notification deep linking.

11.1 Example Notification Payload

{
  "title": "New Message",
  "body": "You have received a new message.",
  "data": {
    "screen": "Chat",
    "conversationId": "CHAT_456"
  }
}

11.2 Handle Notification Navigation

function handleNotificationNavigation(data, navigation) {
  if (data?.screen === 'Chat' && data?.conversationId) {
    navigation.navigate('Chat', {
      conversationId: data.conversationId
    });
  }

  if (data?.screen === 'OrderDetails' && data?.orderId) {
    navigation.navigate('OrderDetails', {
      orderId: data.orderId
    });
  }
}

This example assumes the relevant routes exist in the navigation configuration. In a real application, wait until the navigation container is ready, handle cold-start notification responses, validate route parameters, and confirm that the current user has permission to access the requested resource.

11.3 Foreground, Background, and Terminated States

Exact behavior varies by message type, operating system, application configuration, and notification library. Background execution is not guaranteed, so avoid relying on every push message to run arbitrary application code.

12. Android Notification Channels

On Android 8.0 and later, notifications are organized into channels. A channel represents a category of notifications, such as messages, reminders, or order updates. Users can manage the behavior of each channel through system settings.

12.1 Why Notification Channels Matter

• Separate different types of notifications.
• Allow users to control notification preferences by category.
• Provide clearer notification management.
• Support different importance levels where allowed by the system.

12.2 Create a Notification Channel

import { Platform } from 'react-native';
import * as Notifications from 'expo-notifications';

export async function configureNotificationChannel() {
  if (Platform.OS === 'android') {
    await Notifications.setNotificationChannelAsync(
      'reminders',
      {
        name: 'Reminders',
        importance:
          Notifications.AndroidImportance.DEFAULT,
        vibrationPattern: [0, 250, 250, 250],
        lightColor: '#175CD3'
      }
    );
  }
}

Call the configuration function during application startup where appropriate. For Android notifications sent through a push service, ensure that the message uses the intended channel and that the channel has been created on the device.

13. Notification Permissions and User Privacy

Notification permission is an important part of the user experience. Applications should explain why notifications are useful and allow users to make an informed choice.

13.1 Permission Best Practices

• Request permission when the user understands the benefit.
• Do not repeatedly prompt users who have already declined.
• Provide an in-app settings screen for managing notification preferences.
• Explain how to enable notifications through system settings if permission is denied.
• Respect operating-system notification and focus settings.
• Provide options to disable optional promotional notifications.

13.2 Protect Sensitive Notification Content

Notifications may appear on a lock screen where other people can see them. Avoid exposing passwords, authentication codes, full payment details, private messages, or sensitive account information unnecessarily.

For sensitive applications, consider generic notification text such as "You have a new account update" and show detailed information only after the user opens the application and passes the required authentication checks.

14. Managing Notification Preferences

Not every user wants every notification. Applications should provide controls that let users choose which types of notifications they receive.

14.1 Example Notification Categories

14.2 Store Preferences

Local preferences can be stored on the device, while account-level notification preferences can be stored on the backend so they can be applied across devices. Ensure that the backend checks those preferences before sending optional remote notifications.

15. Troubleshooting Common Notification Problems

16. Testing Local and Remote Notifications

Notification testing should cover permissions, delivery, presentation, user interactions, and different application states.

16.1 Local Notification Testing

1. Install the application on a supported device or simulator.
2. Request notification permission when required.
3. Trigger an immediate notification.
4. Schedule a notification for a future time.
5. Move the application to the background and test delivery.
6. Test the behavior when the application is not running.
7. Cancel a scheduled notification and confirm it does not appear afterward.
8. Repeat the test with notification permission disabled.

16.2 Remote Notification Testing

1. Configure the required push service and platform credentials.
2. Obtain a valid device or Expo push token.
3. Register the token securely with the backend.
4. Send a test message through the configured service.
5. Test when the application is in the foreground.
6. Test when the application is in the background.
7. Test notification taps when the application is already open.
8. Test notification taps when the application must launch from a terminated state.
9. Verify the data payload and destination screen.
10. Inspect service responses and remove invalid tokens.

16.3 Recommended Testing Tools

• Expo Notifications API documentation
• Firebase Cloud Messaging documentation
• Apple User Notifications documentation
• Android Notifications documentation

17. Notification Security and Reliability Best Practices

1. Keep credentials on the server: Never embed privileged push-service credentials in the React Native application.
2. Validate notification data: Treat notification payloads as untrusted input.
3. Protect user privacy: Avoid exposing sensitive content on lock screens.
4. Manage tokens carefully: Update registrations when tokens change and remove invalid tokens.
5. Handle delivery failures: Inspect service responses and use suitable retry policies.
6. Respect user preferences: Apply notification categories and opt-out settings.
7. Avoid notification overload: Send useful messages and avoid repetitive alerts.
8. Use appropriate priorities: Follow platform rules rather than assigning high priority to every notification.
9. Design for offline states: Ensure that opening a notification can recover gracefully when data is unavailable.
10. Authorize protected content: Verify the user's access rights before displaying private records identified by a notification.

18. Practical Project: Reminder and Order Notification Application

Build a React Native application that demonstrates both local reminders and remote order updates.

18.1 Project Requirements

• Create a screen for scheduling a local reminder.
• Allow the user to set a reminder title and date.
• Request notification permission at an appropriate point.
• Display a local notification when the reminder is due, subject to system settings.
• Allow users to cancel scheduled reminders.
• Configure remote notifications through Expo Push Service or another supported provider.
• Register device tokens with a secure backend.
• Send a remote notification when an order changes status.
• Handle notification taps and navigate to the correct screen.
• Test foreground, background, and terminated application states.

18.2 Example Project Structure

src/
  components/
    NotificationButton.js
    ReminderForm.js
  screens/
    HomeScreen.js
    ReminderScreen.js
    OrderDetailsScreen.js
    NotificationSettingsScreen.js
  services/
    localNotifications.js
    pushNotifications.js
    notificationNavigation.js
  config/
    notificationConfig.js
  App.js

18.3 Suggested Development Steps

1. Initialize the React Native or Expo project.
2. Install and configure the notification library.
3. Build the reminder form and validate its input.
4. Implement local notification scheduling and cancellation.
5. Configure Android notification channels when applicable.
6. Set up push notification credentials for the target platforms.
7. Implement token registration and backend notification sending.
8. Add notification event listeners and navigation handling.
9. Test permissions, notification delivery, and failure scenarios.
10. Document setup steps and platform-specific requirements.

19. Interview Questions and Answers

Q1. What is a local notification?

Answer: A local notification is created or scheduled by an application on the device. It is commonly used for reminders, alarms, and scheduled activities.

Q2. What is a remote notification?

Answer: A remote notification is initiated by a server or push messaging service and delivered to a device through the platform's push infrastructure.

Q3. What is the main difference between local and remote notifications?

Answer: Local notifications are initiated or scheduled on the device, while remote notifications are initiated by a remote system and require suitable push infrastructure.

Q4. What is Expo Notifications?

Answer: Expo Notifications is a React Native library that provides APIs for presenting, scheduling, receiving, and responding to local and remote notifications.

Q5. What is a push notification token?

Answer: A push token identifies an application installation or device endpoint for a push messaging service. The backend uses the appropriate token to address notifications to the intended destination.

Q6. What is Firebase Cloud Messaging?

Answer: Firebase Cloud Messaging, or FCM, is a messaging service used to deliver messages to supported client applications, including React Native applications configured for Android and iOS.

Q7. What is APNs?

Answer: Apple Push Notification service is Apple's infrastructure for delivering remote notifications to Apple devices.

Q8. Why is notification permission important?

Answer: Permission allows users to control whether an application can display notifications. Developers should request authorization appropriately and respect the user's decision.

Q9. Can local notifications work without an internet connection?

Answer: Yes. A local notification that has already been scheduled can generally be delivered without internet access, subject to operating-system rules and device state.

Q10. Can remote notifications arrive when the application is closed?

Answer: They may be displayed while the application is not running, depending on the message type, operating system, permissions, and configuration. Background execution and delivery are not guaranteed.

Q11. What is an Android notification channel?

Answer: A notification channel groups notifications into categories so users can manage their behavior and preferences on supported Android versions.

Q12. How can a notification open a specific screen?

Answer: Include suitable navigation data in the notification payload, listen for the user's response, validate the data, and navigate after the application navigation system is ready.

Q13. How do you cancel a local notification?

Answer: Store the scheduled notification identifier and use the notification library's cancellation API to cancel that notification.

Q14. Why might a push notification not arrive?

Answer: Possible causes include invalid tokens, missing credentials, denied permissions, incorrect channel configuration, network problems, or push service delivery restrictions.

Q15. Why should push credentials not be stored in the app?

Answer: Mobile application packages can be inspected. Privileged credentials must remain on a secure backend to reduce the risk of unauthorized message sending.

20. Practice Exercises

1. Create a button that triggers an immediate local notification.
2. Schedule a reminder for one minute in the future.
3. Implement permission checking and handle denied permissions.
4. Schedule a daily reminder and test it on a physical device.
5. Build a screen that lists and cancels scheduled notifications.
6. Configure an Android notification channel.
7. Obtain an Expo push token and register it with a backend.
8. Send a test remote notification through a configured push service.
9. Add notification data that identifies an application screen.
10. Handle notification responses when the app is foregrounded and when it launches from a notification.
11. Test invalid tokens and notification delivery errors.
12. Create a notification preferences screen with separate categories.

21. Quick Revision Notes

• Local notification: Created or scheduled on the device.
• Remote notification: Initiated by a server and delivered through push infrastructure.
• Expo Notifications: Provides a cross-platform notification API for React Native.
• FCM: Firebase Cloud Messaging, a push messaging service.
• APNs: Apple's push notification service.
• Push token: Identifies the destination for push delivery.
• Notification permission: Controls whether the app can display notifications under the platform's permission model.
• Notification channel: Groups notifications into manageable categories on supported Android versions.
• Notification listener: Handles notification receipt or user responses.
• Deep linking: Opens the relevant screen from a notification interaction.
• Token management: Keeps device registrations valid and removes invalid tokens.
• Security: Protects credentials and sensitive notification data.
• Testing: Covers foreground, background, terminated, permission-denied, and failure scenarios.

22. Conclusion

Local and remote notifications are essential capabilities for many React Native applications. Local notifications are particularly useful for reminders and scheduled tasks, while remote notifications communicate events generated by a backend or another remote system.

By understanding notification permissions, scheduling, push tokens, Android channels, notification listeners, navigation, and platform-specific requirements, developers can build more reliable notification experiences for Android and iOS.

Successful notification implementation requires more than sending a message. Developers must also consider privacy, user preferences, delivery limitations, token management, security, and testing across application states.

23. Additional Learning Resources

• React Native Training at JustAcademy
• Register for a Course Demo
• Visit JustAcademy
• Expo Notifications API Reference
• Expo Push Notifications Overview
• Handling Incoming Notifications in Expo
• Firebase Cloud Messaging Documentation
• Apple User Notifications Documentation
• Android Notifications Documentation