Expo 通知

一个库，提供 API 来获取推送通知令牌并渲染、安排、接收和响应通知。

expo-notifications 提供了一个 API 来获取推送通知令牌并渲染、安排、接收和响应通知。

¥expo-notifications provides an API to fetch push notification tokens and to present, schedule, receive and respond to notifications.

从 SDK 53 开始，expo-notifications 提供的推送通知（远程通知）功能将在 Expo Go 中不可用。需要 开发构建 才能使用推送通知。本地通知（应用内通知）将在 Expo Go 中保持可用。

特性

¥Features

• 安排在特定日期或从现在起的某个时间发出一次性通知

  ¥Schedule a one-off notification for a specific date or some time from now

• 安排通知在某个时间间隔内重复（或 iOS 上的日历日期匹配）

  ¥Schedule a notification repeating in some time interval (or a calendar date match on iOS)

• 获取和设置应用徽章图标编号

  ¥Get and set the application badge icon number

• 获取原生设备推送令牌，以便你可以使用 FCM（适用于 Android）和 APNs（适用于 iOS）发送推送通知

  ¥Obtain a native device push token, so you can send push notifications with FCM (for Android) and APNs (for iOS)

• 获取 Expo 推送令牌，以便你可以使用 Expo 推送服务 发送推送通知

  ¥Obtain an Expo push token, so you can send push notifications with Expo Push Service

• 在前台和后台收听传入的通知

  ¥Listen to incoming notifications in the foreground and background

• 聆听与通知的交互

  ¥Listen to interactions with notifications

• 当应用位于前台时处理通知

  ¥Handle notifications when the app is in the foreground

• 强制关闭通知中心/托盘中的通知

  ¥Imperatively dismiss notifications from Notification Center/tray

• 创建、更新和删除 Android 通知渠道

  ¥Create, update, and delete Android notification channels

• 在 Android 上设置通知的自定义图标和颜色

  ¥Set custom icon and color for notifications on Android

安装

¥Installation

If you are installing this in an existing React Native app, start by installing expo in your project. Then, follow the additional instructions as mentioned by the library's README under "Installation in bare React Native projects" section.

用法

¥Usage

查看下面的示例 Snack 以了解通知的实际效果，请确保使用物理设备进行测试。推送通知不适用于模拟器/模拟器。

¥Check out the example Snack below to see Notifications in action, make sure to use a physical device to test it. Push notifications don't work on emulators/simulators.

import { useState, useEffect, useRef } from 'react';
import { Text, View, Button, Platform } from 'react-native';
import * as Device from 'expo-device';
import * as Notifications from 'expo-notifications';
import Constants from 'expo-constants';

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

export default function App() {
const [expoPushToken, setExpoPushToken] = useState('');
const [channels, setChannels] = useState<Notifications.NotificationChannel[]>([]);
const [notification, setNotification] = useState<Notifications.Notification | undefined>(
  undefined
);
const notificationListener = useRef<Notifications.EventSubscription>();
const responseListener = useRef<Notifications.EventSubscription>();

useEffect(() => {
  registerForPushNotificationsAsync().then(token => token && setExpoPushToken(token));

  if (Platform.OS === 'android') {
    Notifications.getNotificationChannelsAsync().then(value => setChannels(value ?? []));
  }
  notificationListener.current = Notifications.addNotificationReceivedListener(notification => {
    setNotification(notification);
  });

  responseListener.current = Notifications.addNotificationResponseReceivedListener(response => {
    console.log(response);
  });

  return () => {
    notificationListener.current &&
      Notifications.removeNotificationSubscription(notificationListener.current);
    responseListener.current &&
      Notifications.removeNotificationSubscription(responseListener.current);
  };
}, []);

return (
  <View
    style={{
      flex: 1,
      alignItems: 'center',
      justifyContent: 'space-around',
    }}>
    <Text>Your expo push token: {expoPushToken}</Text>
    <Text>{`Channels: ${JSON.stringify(
      channels.map(c => c.id),
      null,
      2
    )}`}</Text>
    <View style={{ alignItems: 'center', justifyContent: 'center' }}>
      <Text>Title: {notification && notification.request.content.title} </Text>
      <Text>Body: {notification && notification.request.content.body}</Text>
      <Text>Data: {notification && JSON.stringify(notification.request.content.data)}</Text>
    </View>
    <Button
      title="Press to schedule a notification"
      onPress={async () => {
        await schedulePushNotification();
      }}
    />
  </View>
);
}

async function schedulePushNotification() {
await Notifications.scheduleNotificationAsync({
  content: {
    title: "You've got mail! 📬",
    body: 'Here is the notification body',
    data: { data: 'goes here', test: { test1: 'more data' } },
  },
  trigger: {
    type: SchedulableTriggerInputTypes.TIME_INTERVAL,
    seconds: 2,
  },
});
}

async function registerForPushNotificationsAsync() {
let token;

if (Platform.OS === 'android') {
  await Notifications.setNotificationChannelAsync('myNotificationChannel', {
    name: 'A channel is needed for the permissions prompt to appear',
    importance: Notifications.AndroidImportance.MAX,
    vibrationPattern: [0, 250, 250, 250],
    lightColor: '#FF231F7C',
  });
}

if (Device.isDevice) {
  const { status: existingStatus } = await Notifications.getPermissionsAsync();
  let finalStatus = existingStatus;
  if (existingStatus !== 'granted') {
    const { status } = await Notifications.requestPermissionsAsync();
    finalStatus = status;
  }
  if (finalStatus !== 'granted') {
    alert('Failed to get push token for push notification!');
    return;
  }
  // Learn more about projectId:
  // https://expo.nodejs.cn/push-notifications/push-notifications-setup/#configure-projectid
  // EAS projectId is used here.
  try {
    const projectId =
      Constants?.expoConfig?.extra?.eas?.projectId ?? Constants?.easConfig?.projectId;
    if (!projectId) {
      throw new Error('Project ID not found');
    }
    token = (
      await Notifications.getExpoPushTokenAsync({
        projectId,
      })
    ).data;
    console.log(token);
  } catch (e) {
    token = `${e}`;
  }
} else {
  alert('Must use physical device for Push Notifications');
}

return token;
}

向用户显示本地（应用内）通知

¥Present a local (in-app) notification to the user

import * as Notifications from 'expo-notifications';

// First, set the handler that will cause the notification
// to show the alert
Notifications.setNotificationHandler({
  handleNotification: async () => ({
    shouldShowAlert: true,
    shouldPlaySound: false,
    shouldSetBadge: false,
  }),
});

// Second, call scheduleNotificationAsync()
Notifications.scheduleNotificationAsync({
  content: {
    title: 'Look at that notification',
    body: "I'm so proud of myself!",
  },
  trigger: null,
});

通过导航处理推送通知

¥Handle push notifications with navigation

如果你想在收到推送通知时深层链接到应用中的特定屏幕，你可以配置 Expo 的任一导航系统来执行此操作。

¥If you'd like to deep link to a specific screen in your app when you receive a push notification, you can configure either of Expo's navigation systems to do that.

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

function useNotificationObserver() {
  useEffect(() => {
    let isMounted = true;

    function redirect(notification: Notifications.Notification) {
      const url = notification.request.content.data?.url;
      if (url) {
        router.push(url);
      }
    }

    Notifications.getLastNotificationResponseAsync()
      .then(response => {
        if (!isMounted || !response?.notification) {
          return;
        }
        redirect(response?.notification);
      });

    const subscription = Notifications.addNotificationResponseReceivedListener(response => {
      redirect(response.notification);
    });

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

export default function Layout() {
  useNotificationObserver();

  return <Slot />;
}

import React from 'react';
import { Linking } from 'react-native';
import * as Notifications from 'expo-notifications';
import { NavigationContainer } from '@react-navigation/native';

export default function App() {
  return (
    <NavigationContainer
      linking={{
        config: {
          // Configuration for linking
        },
        async getInitialURL() {
          // First, you may want to do the default deep link handling
          // Check if app was opened from a deep link
          const url = await Linking.getInitialURL();

          if (url != null) {
            return url;
          }

          // Handle URL from expo push notifications
          const response = await Notifications.getLastNotificationResponseAsync();

          return response?.notification.request.content.data.url;
        },
        subscribe(listener) {
          const onReceiveURL = ({ url }: { url: string }) => listener(url);

          // Listen to incoming links from deep linking
          const eventListenerSubscription = Linking.addEventListener('url', onReceiveURL);

          // Listen to expo push notifications
          const subscription = Notifications.addNotificationResponseReceivedListener(response => {
            const url = response.notification.request.content.data.url;

            // Any custom logic to see whether the URL needs to be handled
            //...

            // Let React Navigation handle the URL
            listener(url);
          });

          return () => {
            // Clean up the event listeners
            eventListenerSubscription.remove();
            subscription.remove();
          };
        },
      }}>
      {/* Your app content */}
    </NavigationContainer>
  );
}

配置

¥Configuration

证书

¥Credentials

安卓

¥Android

所有 Android 应用都需要 Firebase Cloud Messaging 凭据才能在应用中接收推送通知（在 Expo Go 中进行测试时除外）。有关更多信息，请参阅如何为你的应用获取 FCM 资质。

¥Firebase Cloud Messaging credentials are required for all Android apps to receive push notifications in your app (except when testing in Expo Go). For more information, see how to get FCM credentials for your app.

iOS 系统

¥iOS

要注册你的 iOS 设备并自动为你的 EAS 版本启用推送通知，请参阅 推送通知设置。

¥To register your iOS device and automatically enable push notifications for your EAS Build, see push notification setup.

应用配置

¥App config

要配置 expo-notifications，请在 EAS 构建 或 npx expo run:[android|ios] 的应用配置（app.json 或 app.config.js）中使用内置 配置插件。该插件允许你配置以下无法在运行时设置并需要构建新的应用二进制文件才能生效的属性：

¥To configure expo-notifications, use the built-in config plugin in the app config (app.json or app.config.js) for EAS Build or with npx expo run:[android|ios]. The plugin allows you to configure the following properties that cannot be set at runtime and require building a new app binary to take effect:

Configurable properties

以下是在应用配置文件中使用配置插件的示例：

¥Here is an example of using the config plugin in the app config file:

{
  "expo": {
    "plugins": [
      [
        "expo-notifications",
        {
          "icon": "./local/assets/notification_icon.png",
          "color": "#ffffff",
          "defaultChannel": "default",
          "sounds": [
            "./local/assets/notification_sound.wav",
            "./local/assets/notification_sound_other.wav"
          ],
          "enableBackgroundRemoteNotifications": false
        }
      ]
    ]
  }
}

iOS APNs 权利始终设置为 'development'。Xcode 在存档期间自动将其更改为 'production'。了解更多。

¥The iOS APNs entitlement is always set to 'development'. Xcode automatically changes this to 'production' during the archive. Learn more.

权限

¥Permissions

安卓

¥Android

• 在 Android 上，此模块需要订阅设备启动的权限。它用于在设备（重新）启动时设置预定的通知。RECEIVE_BOOT_COMPLETED 权限通过库的 AndroidManifest.xml 自动添加。

  ¥On Android, this module requires permission to subscribe to the device boot. It's used to set up scheduled notifications when the device (re)starts. The RECEIVE_BOOT_COMPLETED permission is added automatically through the library's AndroidManifest.xml.

• 从 Android 12（API 级别 31）开始，要安排在准确时间触发的通知，你需要将 <uses-permission android:name="android.permission.SCHEDULE_EXACT_ALARM"/> 添加到 AndroidManifest.xml。阅读有关 准确的报警权限 的更多信息。

  ¥Starting from Android 12 (API level 31), to schedule a notification that triggers at an exact time, you need to add <uses-permission android:name="android.permission.SCHEDULE_EXACT_ALARM"/> to AndroidManifest.xml. Read more about the exact alarm permission.

• 在 Android 13 上，应用用户必须选择通过操作系统自动触发的权限提示来接收通知。至少创建一个通知通道后，才会出现此提示。必须在 getDevicePushTokenAsync 或 getExpoPushTokenAsync 之前调用 setNotificationChannelAsync 才能获取推送令牌。你可以在 官方文档 中详细了解 Android 13 的新通知权限行为。

  ¥On Android 13, app users must opt-in to receive notifications via a permissions prompt automatically triggered by the operating system. This prompt will not appear until at least one notification channel is created. The setNotificationChannelAsync must be called before getDevicePushTokenAsync or getExpoPushTokenAsync to obtain a push token. You can read more about the new notification permission behavior for Android 13 in the official documentation.

iOS 系统

¥iOS

无需使用说明，参见 通知相关权限。

¥No usage description is required, see notification-related permissions.

解释 iOS 权限响应

¥Interpret the iOS permissions response

在 iOS 上，发送通知的权限比 Android 上的更细化。这就是你应该依赖 NotificationPermissionsStatus 的 ios.status 字段而不是根 status 字段的原因。

¥On iOS, permissions for sending notifications are a little more granular than they are on Android. This is why you should rely on the NotificationPermissionsStatus's ios.status field, instead of the root status field.

该值将是以下值之一，可在 Notifications.IosAuthorizationStatus 下访问：

¥This value will be one of the following, accessible under Notifications.IosAuthorizationStatus:

• NOT_DETERMINED：用户尚未选择是否允许应用安排通知

  ¥NOT_DETERMINED: The user hasn't yet made a choice about whether the app is allowed to schedule notifications

• DENIED：该应用无权安排或接收通知

  ¥DENIED: The app isn't authorized to schedule or receive notifications

• AUTHORIZED：该应用被授权安排或接收通知

  ¥AUTHORIZED: The app is authorized to schedule or receive notifications

• PROVISIONAL：该应用被临时授权发布非中断性用户通知

  ¥PROVISIONAL: The app is provisionally authorized to post noninterruptive user notifications

• EPHEMERAL：该应用被授权在有限的时间内安排或接收通知

  ¥EPHEMERAL: The app is authorized to schedule or receive notifications for a limited amount of time

通知事件监听器

¥Notification events listeners

通知事件包括传入通知、用户与通知执行的交互（这可以是点击通知，或通过 通知类别 与其交互），以及通知可能被删除的极少数情况。

¥Notification events include incoming notifications, interactions your users perform with notifications (this can be tapping on a notification, or interacting with it via notification categories), and rare occasions when your notifications may be dropped.

推送通知行为 部分公开并记录了几个监听器。

¥Several listeners are exposed and documented in the Push notification behaviors section.

无头（后台）通知

¥Headless (Background) notifications

请参阅 你需要了解的内容 指南中的无头背景通知的 definition。

¥See the definition of Headless Background Notifications in the What you need to know guide.

要在应用处于后台或未运行时处理通知，你需要执行以下操作：

¥To handle notifications while the app is in the background or not running, you need to do the following:

• 将 expo-task-manager 包添加到你的项目。

  ¥Add expo-task-manager package to your project.

• 配置后台通知。

  ¥Configure background notifications.

• 在你的应用代码中，设置一个 后台任务 在收到通知时运行。

  ¥In your application code, set up a background task to run when the notification is received.

• 你必须使用 开发构建 来使用后台通知，因为 Expo Go 不支持它们。

  ¥You must use a development build to use background notifications since they are not supported in Expo Go.

然后发送推送通知：

¥Then send a push notification which:

• 仅包含 data 键（无 title、body）

  ¥Contains only the data key (no title, body)

• 已为 iOS 设置 _contentAvailable: true — 请参阅 Expo 推送通知服务有效负载格式

  ¥Has _contentAvailable: true set for iOS — see the Expo push notification service payload format

后台通知配置

¥Background notification configuration

为了能够在 iOS 上使用后台推送通知，remote-notification 值需要存在于应用的 Info.plist 文件中的 UIBackgroundModes 数组中。

¥To be able to use background push notifications on iOS, the remote-notification value needs to be present in the UIBackgroundModes array in your app's Info.plist file.

如果你使用 CNG，请将配置插件的 enableBackgroundRemoteNotifications 属性 设置为 true，正确的配置将由预构建自动应用。

¥If you're using CNG, set the enableBackgroundRemoteNotifications property of the config plugin to true, and the correct configuration will be applied automatically by prebuild.

<key>UIBackgroundModes</key>
<array>
  <string>remote-notification</string>
</array>
</key>

附加信息

¥Additional information

设置自定义通知声音

¥Set custom notification sounds

要将自定义推送通知声音添加到你的应用，请将 expo-notifications 插件添加到你的 app.json 文件，然后在 sounds 键下，提供可用作自定义通知声音的声音文件的本地路径数组。这些本地路径是你项目的本地路径。

¥To add custom push notification sounds to your app, add the expo-notifications plugin to your app.json file and then under the sounds key, provide an array of local paths to sound files that can be used as custom notification sounds. These local paths are local to your project.

{
  "expo": {
    "plugins": [
      [
        "expo-notifications",
        {
          "sounds": ["local/path/to/mySoundFile.wav"]
        }
      ]
    ]
  }
}

构建应用后，文件数组将可在 NotificationContentInput 和 NotificationChannelInput 中使用。你只需提供基本文件名。这是使用上面配置的示例：

¥After building your app, the array of files will be available for use in both NotificationContentInput and NotificationChannelInput. You only need to provide the base filename. Here's an example using the config above:

await Notifications.setNotificationChannelAsync('new_emails', {
  name: 'E-mail notifications',
  importance: Notifications.AndroidImportance.HIGH,
  sound: 'mySoundFile.wav', // Provide ONLY the base filename
});

await Notifications.scheduleNotificationAsync({
  content: {
    title: "You've got mail! 📬",
    sound: 'mySoundFile.wav', // Provide ONLY the base filename
  },
  trigger: {
    seconds: 2,
    channelId: 'new_emails',
  },
});

如果你愿意，还可以手动将通知文件添加到 Android 和 iOS 项目中：

¥You can also manually add notification files to your Android and iOS projects if you prefer:

// Prepare the notification channel
await Notifications.setNotificationChannelAsync('new_emails', {
  name: 'E-mail notifications',
  importance: Notifications.AndroidImportance.HIGH,
  sound: 'email_sound.wav', // <- for Android 8.0+, see channelId property below
});

// Eg. schedule the notification
await Notifications.scheduleNotificationAsync({
  content: {
    title: "You've got mail! 📬",
    body: 'Open the notification to read them all',
    sound: 'email_sound.wav', // <- for Android below 8.0
  },
  trigger: {
    seconds: 2,
    channelId: 'new_emails', // <- for Android 8.0+, see definition above
  },
});

Manually adding notification sounds on iOS

在 iOS 上，所需要做的就是将声音文件放入 Xcode 项目中（请参见下面的屏幕截图），然后在 NotificationContentInput 中指定声音文件，如下所示：

¥On iOS, all that's needed is to place your sound file in your Xcode project (see the screenshot below), and then specify the sound file in your NotificationContentInput, like this:

await Notifications.scheduleNotificationAsync({
  content: {
    title: "You've got mail! 📬",
    body: 'Open the notification to read them all',
    sound: 'notification.wav',
  },
  trigger: {
    // ...
  },
});

快速获胜

¥Push notification payload specification

参见 消息请求格式。

¥See Message request format.

管理交互式通知的通知类别

¥Manage notification categories for interactive notifications

通知类别允许你创建交互式推送通知，以便用户可以通过按钮或文本响应直接响应传入的通知。类别定义用户可以执行的一组操作，然后通过在 NotificationContent 中指定 categoryIdentifier 将这些操作应用于通知。

¥Notification categories allow you to create interactive push notifications, so that a user can respond directly to the incoming notification either via buttons or a text response. A category defines the set of actions a user can take, and then those actions are applied to a notification by specifying the categoryIdentifier in the NotificationContent.

在 iOS 上，通知类别还允许你进一步自定义通知。对于每个类别，你不仅可以设置用户可以执行的交互操作，还可以配置诸如当用户禁用应用的通知预览时显示的占位符文本之类的内容。

¥On iOS, notification categories also allow you to customize your notifications further. With each category, not only can you set interactive actions a user can take, but you can also configure things like the placeholder text to display when the user disables notification previews for your app.

平台特定指南

¥Platform-specific guides

处理通知渠道

¥Handling notification channels

从 Android 8.0（API 级别 26）开始，所有通知都必须分配给一个通道。对于每个通道，你可以设置应用于该通道中所有通知的视觉和听觉行为。然后，用户可以更改这些设置并决定应用中的哪些通知渠道应该是侵入性的或完全可见的，如 Android 开发者文档 所述。

¥Starting in Android 8.0 (API level 26), all notifications must be assigned to a channel. For each channel, you can set the visual and auditory behavior that is applied to all notifications in that channel. Then, users can change these settings and decide which notification channels from your app should be intrusive or visible at all, as Android developer docs states.

如果你不指定通知渠道，expo-notifications 将为你创建一个后备渠道，名为 Miscellaneous。我们鼓励你始终确保为应用设置具有信息名称的适当渠道，并始终向这些渠道发送通知。

¥If you do not specify a notification channel, expo-notifications will create a fallback channel for you, named Miscellaneous. We encourage you to always ensure appropriate channels with informative names are set up for the application and to always send notifications to these channels.

对于不支持此功能的平台（Android 版本 8.0 (26) 以下和 iOS），调用这些方法是无操作的。

¥Calling these methods is a no-op for platforms that do not support this feature (Android below version 8.0 (26) and iOS).

自定义通知图标和颜色

¥Custom notification icon and colors

如果你使用 Expo 预建 或使用 直接 expo-notifications 配置插件，则可以在项目的 app.json 中配置 notification.icon 和 notification.color 键。这些是构建时设置，因此你需要使用 eas build -p android 或 npx expo run:android 重新编译原生 Android 应用才能看到更改。

¥You can configure the notification.icon and notification.color keys in the project's app.json if you are using Expo Prebuild or by using the expo-notifications config plugin directly. These are build-time settings, so you'll need to recompile your native Android app with eas build -p android or npx expo run:android to see the changes.

对于你的通知图标，请确保遵循 Google 的设计指南（图标必须是全白透明背景），否则可能无法按预期显示。

¥For your notification icon, make sure you follow Google's design guidelines (the icon must be all white with a transparent background) or else it may not be displayed as intended.

你还可以直接在 NotificationContentInput 中的 color 属性下设置每个通知的自定义通知颜色。

¥You can also set a custom notification color per-notification directly in your NotificationContentInput under the color attribute.

API

import * as Notifications from 'expo-notifications';

Fetch tokens for push notifications

import React from 'react';
import * as Notifications from 'expo-notifications';

import { registerDevicePushTokenAsync } from '../api';

export default function App() {
  React.useEffect(() => {
    const subscription = Notifications.addPushTokenListener(registerDevicePushTokenAsync);
    return () => subscription.remove();
  }, []);

  return (
    // Your app content
  );
}

import * as Notifications from 'expo-notifications';

export async function registerForPushNotificationsAsync(userId: string) {
  const expoPushToken = await Notifications.getExpoPushTokenAsync({
   projectId: 'your-project-id',
  });

  await fetch('https://example.com/', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      userId,
      expoPushToken,
    }),
  });
}

Listen to notification events

import React from 'react';
import * as Notifications from 'expo-notifications';

export default function App() {
  React.useEffect(() => {
    const subscription = Notifications.addNotificationReceivedListener(notification => {
      console.log(notification);
    });
    return () => subscription.remove();
  }, []);

  return (
    // Your app content
  );
}

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

export default function Container() {
  React.useEffect(() => {
    const subscription = Notifications.addNotificationResponseReceivedListener(response => {
      const url = response.notification.request.content.data.url;
      Linking.openURL(url);
    });
    return () => subscription.remove();
  }, []);

  return (
    // Your app content
  );
}

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

export default function App() {
  const lastNotificationResponse = Notifications.useLastNotificationResponse();
  React.useEffect(() => {
    if (
      lastNotificationResponse &&
      lastNotificationResponse.notification.request.content.data.url &&
      lastNotificationResponse.actionIdentifier === Notifications.DEFAULT_ACTION_IDENTIFIER
    ) {
      Linking.openURL(lastNotificationResponse.notification.request.content.data.url);
    }
  }, [lastNotificationResponse]);
  return (
    // Your app content
  );
}

Present incoming notifications when the app is running

import * as Notifications from 'expo-notifications';

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

Run JavaScript in response to incoming notifications

import * as TaskManager from 'expo-task-manager';
import * as Notifications from 'expo-notifications';

const BACKGROUND_NOTIFICATION_TASK = 'BACKGROUND-NOTIFICATION-TASK';

TaskManager.defineTask(BACKGROUND_NOTIFICATION_TASK, ({ data, error, executionInfo }) => {
  console.log('Received a notification in the background!');
  // Do something with the notification data
});

Notifications.registerTaskAsync(BACKGROUND_NOTIFICATION_TASK);

Fetch information about notifications-related permissions

import * as Notifications from 'expo-notifications';

export async function allowsNotificationsAsync() {
  const settings = await Notifications.getPermissionsAsync();
  return (
    settings.granted || settings.ios?.status === Notifications.IosAuthorizationStatus.PROVISIONAL
  );
}

import * as Notifications from 'expo-notifications';

export function requestPermissionsAsync() {
  return await Notifications.requestPermissionsAsync({
    ios: {
      allowAlert: true,
      allowBadge: true,
      allowSound: true,
    },
  });
}

Manage application badge icon

Schedule notifications

import * as Notifications from 'expo-notifications';

async function scheduleAndCancel() {
  const identifier = await Notifications.scheduleNotificationAsync({
    content: {
      title: 'Hey!',
    },
    trigger: { seconds: 60, repeats: true },
  });
  await Notifications.cancelScheduledNotificationAsync(identifier);
}

import * as Notifications from 'expo-notifications';

async function logNextTriggerDate() {
  try {
    const nextTriggerDate = await Notifications.getNextTriggerDateAsync({
      hour: 9,
      minute: 0,
    });
    console.log(nextTriggerDate === null ? 'No next trigger date' : new Date(nextTriggerDate));
  } catch (e) {
    console.warn(`Couldn't have calculated next trigger date: ${e}`);
  }
}

import * as Notifications from 'expo-notifications';

Notifications.scheduleNotificationAsync({
  content: {
    title: "Time's up!",
    body: 'Change sides!',
  },
  trigger: {
    type: SchedulableTriggerInputTypes.TIME_INTERVAL,
    seconds: 60,
  },
});

import * as Notifications from 'expo-notifications';

Notifications.scheduleNotificationAsync({
  content: {
    title: 'Remember to drink water!',
  },
  trigger: {
    type: SchedulableTriggerInputTypes.TIME_INTERVAL,
    seconds: 60 * 20,
    repeats: true,
  },
});

import * as Notifications from 'expo-notifications';

const trigger = new Date(Date.now() + 60 * 60 * 1000);
trigger.setMinutes(0);
trigger.setSeconds(0);

Notifications.scheduleNotificationAsync({
  content: {
    title: 'Happy new hour!',
  },
  trigger,
});

Dismiss notifications

Manage notification channels (Android-specific)

Manage notification categories (interactive notifications)

Constants

Methods

Interfaces