@amazon-devices/expo-notifications 2.0.9000000000-rn-83

package/src/deleteNotificationCategoryAsync.ts

@@ -0,0 +1,23 @@
+import { UnavailabilityError } from 'expo-modules-core';
+
+// @amznmod_react - Changed .native import to one without postfix
+import NotificationCategoriesModule from './NotificationCategoriesModule';
+
+/**
+ * Deletes the category associated with the provided identifier.
+ * @param identifier Identifier initially provided to `setNotificationCategoryAsync` when creating the category.
+ * @return A Promise which resolves to `true` if the category was successfully deleted, or `false` if it was not.
+ * An example of when this method would return `false` is if you try to delete a category that doesn't exist.
+ * @platform android
+ * @platform ios
+ * @header categories
+ */
+export default async function deleteNotificationCategoryAsync(
+  identifier: string
+): Promise<boolean> {
+  if (!NotificationCategoriesModule.deleteNotificationCategoryAsync) {
+    throw new UnavailabilityError('Notifications', 'deleteNotificationCategoryAsync');
+  }
+
+  return await NotificationCategoriesModule.deleteNotificationCategoryAsync(identifier);
+}

package/src/deleteNotificationChannelAsync.android.ts

@@ -0,0 +1,11 @@
+import { UnavailabilityError } from 'expo-modules-core';
+
+import NotificationChannelManager from './NotificationChannelManager';
+
+export default async function deleteNotificationChannelAsync(channelId: string): Promise<void> {
+  if (!NotificationChannelManager.deleteNotificationChannelAsync) {
+    throw new UnavailabilityError('Notifications', 'deleteNotificationChannelAsync');
+  }
+
+  return await NotificationChannelManager.deleteNotificationChannelAsync(channelId);
+}

package/src/deleteNotificationChannelAsync.ts

@@ -0,0 +1,10 @@
+/**
+ * Removes the notification channel.
+ * @param channelId The channel identifier.
+ * @return A Promise which resolving once the channel is removed (or if there was no channel for given identifier).
+ * @platform android
+ * @header channels
+ */
+export default async function deleteNotificationChannelAsync(channelId: string): Promise<void> {
+  console.debug('Notification channels feature is only supported on Android.');
+}

package/src/deleteNotificationChannelGroupAsync.android.ts

@@ -0,0 +1,11 @@
+import { UnavailabilityError } from 'expo-modules-core';
+
+import NotificationChannelGroupManager from './NotificationChannelGroupManager';
+
+export default async function deleteNotificationChannelAsync(groupId: string): Promise<void> {
+  if (!NotificationChannelGroupManager.deleteNotificationChannelGroupAsync) {
+    throw new UnavailabilityError('Notifications', 'deleteNotificationChannelGroupAsync');
+  }
+
+  return await NotificationChannelGroupManager.deleteNotificationChannelGroupAsync(groupId);
+}

package/src/deleteNotificationChannelGroupAsync.ts

@@ -0,0 +1,10 @@
+/**
+ * Removes the notification channel group and all notification channels that belong to it.
+ * @param groupId The channel group identifier.
+ * @return A Promise which resolves once the channel group is removed (or if there was no channel group for given identifier).
+ * @platform android
+ * @header channels
+ */
+export default async function deleteNotificationChannelGroupAsync(groupId: string): Promise<void> {
+  console.debug('Notification channels feature is only supported on Android.');
+}

package/src/dismissAllNotificationsAsync.ts

@@ -0,0 +1,16 @@
+import { UnavailabilityError } from 'expo-modules-core';
+
+import NotificationPresenter from './NotificationPresenterModule';
+
+/**
+ * Removes all application's notifications displayed in the notification tray (Notification Center).
+ * @return A Promise which resolves once the request to dismiss the notifications is successfully dispatched to the notifications manager.
+ * @header dismiss
+ */
+export default async function dismissAllNotificationsAsync(): Promise<void> {
+  if (!NotificationPresenter.dismissAllNotificationsAsync) {
+    throw new UnavailabilityError('Notifications', 'dismissAllNotificationsAsync');
+  }
+
+  return await NotificationPresenter.dismissAllNotificationsAsync();
+}

package/src/dismissNotificationAsync.ts

@@ -0,0 +1,19 @@
+import { UnavailabilityError } from 'expo-modules-core';
+
+import NotificationPresenter from './NotificationPresenterModule';
+
+/**
+ * Removes notification displayed in the notification tray (Notification Center).
+ * @param notificationIdentifier The notification identifier, obtained either via `setNotificationHandler` method or in the listener added with `addNotificationReceivedListener`.
+ * @return A Promise which resolves once the request to dismiss the notification is successfully dispatched to the notifications manager.
+ * @header dismiss
+ */
+export default async function dismissNotificationAsync(
+  notificationIdentifier: string
+): Promise<void> {
+  if (!NotificationPresenter.dismissNotificationAsync) {
+    throw new UnavailabilityError('Notifications', 'dismissNotificationAsync');
+  }
+
+  return await NotificationPresenter.dismissNotificationAsync(notificationIdentifier);
+}

package/src/getAllScheduledNotificationsAsync.ts

@@ -0,0 +1,17 @@
+import { UnavailabilityError } from 'expo-modules-core';
+
+import NotificationScheduler from './NotificationScheduler';
+import { NotificationRequest } from './Notifications.types';
+
+/**
+ * Fetches information about all scheduled notifications.
+ * @return Returns a Promise resolving to an array of objects conforming to the [`Notification`](#notification) interface.
+ * @header schedule
+ */
+export default async function getAllScheduledNotificationsAsync(): Promise<NotificationRequest[]> {
+  if (!NotificationScheduler.getAllScheduledNotificationsAsync) {
+    throw new UnavailabilityError('Notifications', 'getAllScheduledNotificationsAsync');
+  }
+
+  return await NotificationScheduler.getAllScheduledNotificationsAsync();
+}

package/src/getBadgeCountAsync.ts

@@ -0,0 +1,17 @@
+import { UnavailabilityError } from 'expo-modules-core';
+
+import BadgeModule from './BadgeModule';
+
+/**
+ * Fetches the number currently set as the badge of the app icon on device's home screen. A `0` value means that the badge is not displayed.
+ * > **Note:** Not all Android launchers support application badges. If the launcher does not support icon badges, the method will always resolve to `0`.
+ * @return Returns a Promise resolving to a number that represents the current badge of the app icon.
+ * @header badge
+ */
+export default async function getBadgeCountAsync(): Promise<number> {
+  if (!BadgeModule.getBadgeCountAsync) {
+    throw new UnavailabilityError('ExpoNotifications', 'getBadgeCountAsync');
+  }
+
+  return await BadgeModule.getBadgeCountAsync();
+}

package/src/getDevicePushTokenAsync.ts

@@ -0,0 +1,31 @@
+import { UnavailabilityError, Platform } from 'expo-modules-core';
+
+import PushTokenManager from './PushTokenManager';
+import { DevicePushToken } from './Tokens.types';
+
+let nativeTokenPromise: Promise<string> | null = null;
+
+/**
+ * Returns a native FCM, APNs token or a [`PushSubscription` data](https://developer.mozilla.org/en-US/docs/Web/API/PushSubscription)
+ * that can be used with another push notification service.
+ * @header fetch
+ */
+export default async function getDevicePushTokenAsync(): Promise<DevicePushToken> {
+  if (!PushTokenManager.getDevicePushTokenAsync) {
+    throw new UnavailabilityError('ExpoNotifications', 'getDevicePushTokenAsync');
+  }
+
+  let devicePushToken: string | null;
+  if (nativeTokenPromise) {
+    // Reuse existing Promise
+    devicePushToken = await nativeTokenPromise;
+  } else {
+    // Create a new Promise and clear it afterwards
+    nativeTokenPromise = PushTokenManager.getDevicePushTokenAsync();
+    devicePushToken = await nativeTokenPromise;
+    nativeTokenPromise = null;
+  }
+
+  // @ts-ignore: TS thinks Platform.OS could be anything and can't decide what type is it
+  return { type: Platform.OS, data: devicePushToken };
+}

package/src/getDevicePushTokenAsync.web.ts

@@ -0,0 +1,122 @@
+import Constants from '@amazon-devices/expo-constants';
+import { CodedError, Platform, SyntheticPlatformEmitter } from 'expo-modules-core';
+
+import { DevicePushToken } from './Tokens.types';
+
+export default async function getDevicePushTokenAsync(): Promise<DevicePushToken> {
+  const data = await _subscribeDeviceToPushNotificationsAsync();
+  SyntheticPlatformEmitter.emit('onDevicePushToken', { devicePushToken: data });
+  return { type: Platform.OS, data };
+}
+
+function guardPermission() {
+  if (!('Notification' in window)) {
+    throw new CodedError(
+      'ERR_UNAVAILABLE',
+      'The Web Notifications API is not available on this device.'
+    );
+  }
+  if (!navigator.serviceWorker) {
+    throw new CodedError(
+      'ERR_UNAVAILABLE',
+      'Notifications cannot be used because the service worker API is not supported on this device. This might also happen because your web page does not support HTTPS.'
+    );
+  }
+  if (Notification.permission !== 'granted') {
+    throw new CodedError(
+      'ERR_NOTIFICATIONS_PERMISSION_DENIED',
+      `Cannot use web notifications without permissions granted. Request permissions with "expo-permissions".`
+    );
+  }
+}
+
+async function _subscribeDeviceToPushNotificationsAsync(): Promise<DevicePushToken['data']> {
+  // @ts-expect-error: TODO: not on the schema
+  const vapidPublicKey: string | null = Constants.expoConfig?.notification?.vapidPublicKey;
+  if (!vapidPublicKey) {
+    throw new CodedError(
+      'ERR_NOTIFICATIONS_PUSH_WEB_MISSING_CONFIG',
+      'You must provide `notification.vapidPublicKey` in `app.json` to use push notifications on web. Learn more: https://docs.expo.dev/versions/latest/guides/using-vapid/.'
+    );
+  }
+
+  // @ts-expect-error: TODO: not on the schema
+  const serviceWorkerPath = Constants.expoConfig?.notification?.serviceWorkerPath;
+  if (!serviceWorkerPath) {
+    throw new CodedError(
+      'ERR_NOTIFICATIONS_PUSH_MISSING_CONFIGURATION',
+      'You must specify `notification.serviceWorkerPath` in `app.json` to use push notifications on the web. Please provide the path to the service worker that will handle notifications.'
+    );
+  }
+  guardPermission();
+
+  let registration: ServiceWorkerRegistration | null = null;
+  try {
+    registration = await navigator.serviceWorker.register(serviceWorkerPath);
+  } catch (error) {
+    throw new CodedError(
+      'ERR_NOTIFICATIONS_PUSH_REGISTRATION_FAILED',
+      `Could not register this device for push notifications because the service worker (${serviceWorkerPath}) could not be registered: ${error}`
+    );
+  }
+  await navigator.serviceWorker.ready;
+
+  if (!registration.active) {
+    throw new CodedError(
+      'ERR_NOTIFICATIONS_PUSH_REGISTRATION_FAILED',
+      'Could not register this device for push notifications because the service worker is not active.'
+    );
+  }
+
+  const subscribeOptions = {
+    userVisibleOnly: true,
+    applicationServerKey: _urlBase64ToUint8Array(vapidPublicKey),
+  };
+  let pushSubscription: PushSubscription | null = null;
+  try {
+    // @ts-ignore
+    pushSubscription = await registration.pushManager.subscribe(subscribeOptions);
+  } catch (error) {
+    throw new CodedError(
+      'ERR_NOTIFICATIONS_PUSH_REGISTRATION_FAILED',
+      'The device was unable to register for remote notifications with the browser endpoint. (' +
+        error +
+        ')'
+    );
+  }
+  const pushSubscriptionJson = pushSubscription.toJSON();
+
+  const subscriptionObject = {
+    endpoint: pushSubscriptionJson.endpoint,
+    keys: {
+      p256dh: pushSubscriptionJson.keys!.p256dh,
+      auth: pushSubscriptionJson.keys!.auth,
+    },
+  };
+
+  // Store notification icon string in service worker.
+  // This message is received by `/expo-service-worker.js`.
+  // We wrap it with `fromExpoWebClient` to make sure other message
+  // will not override content such as `notificationIcon`.
+  // https://stackoverflow.com/a/35729334/2603230
+  const notificationIcon = (Constants.expoConfig?.notification ?? {}).icon;
+  await registration.active.postMessage(
+    JSON.stringify({ fromExpoWebClient: { notificationIcon } })
+  );
+
+  return subscriptionObject;
+}
+
+// https://github.com/web-push-libs/web-push#using-vapid-key-for-applicationserverkey
+function _urlBase64ToUint8Array(base64String: string): Uint8Array {
+  const padding = '='.repeat((4 - (base64String.length % 4)) % 4);
+  const base64 = (base64String + padding).replace(/-/g, '+').replace(/_/g, '/');
+
+  const rawData = window.atob(base64);
+  const outputArray = new Uint8Array(rawData.length);
+
+  for (let i = 0; i < rawData.length; ++i) {
+    outputArray[i] = rawData.charCodeAt(i);
+  }
+  return outputArray;
+}

package/src/getExpoPushTokenAsync.ts

@@ -0,0 +1,238 @@
+import * as Application from '@amazon-devices/expo-application';
+import Constants from '@amazon-devices/expo-constants';
+import { Platform, CodedError, UnavailabilityError } from 'expo-modules-core';
+
+import { setAutoServerRegistrationEnabledAsync } from './DevicePushTokenAutoRegistration.fx';
+import ServerRegistrationModule from './ServerRegistrationModule';
+import { DevicePushToken, ExpoPushToken, ExpoPushTokenOptions } from './Tokens.types';
+import getDevicePushTokenAsync from './getDevicePushTokenAsync';
+
+const productionBaseUrl = 'https://exp.host/--/api/v2/';
+
+/**
+ * Returns an Expo token that can be used to send a push notification to the device using Expo's push notifications service.
+ *
+ * This method makes requests to the Expo's servers. It can get rejected in cases where the request itself fails
+ * (for example, due to the device being offline, experiencing a network timeout, or other HTTPS request failures).
+ * To provide offline support to your users, you should `try/catch` this method and implement retry logic to attempt
+ * to get the push token later, once the device is back online.
+ *
+ * > For Expo's backend to be able to send notifications to your app, you will need to provide it with push notification keys.
+ * For more information, see [credentials](/push-notifications/push-notifications-setup/#get-credentials-for-development-builds) in the push notifications setup.
+ *
+ * @param options Object allowing you to pass in push notification configuration.
+ * @return Returns a `Promise` that resolves to an object representing acquired push token.
+ * @header fetch
+ *
+ * @example
+ * ```ts
+ * import * as Notifications from '@amazon-devices/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,
+ *     }),
+ *   });
+ * }
+ * ```
+ */
+export default async function getExpoPushTokenAsync(
+  options: ExpoPushTokenOptions = {}
+): Promise<ExpoPushToken> {
+  const devicePushToken = options.devicePushToken || (await getDevicePushTokenAsync());
+
+  const deviceId = options.deviceId || (await getDeviceIdAsync());
+  const projectId = options.projectId || Constants.easConfig?.projectId;
+
+  if (!projectId) {
+    console.warn(
+      'Calling getExpoPushTokenAsync without specifying a projectId is deprecated and will no longer be supported in SDK 49+'
+    );
+  }
+
+  if (!projectId) {
+    throw new CodedError(
+      'ERR_NOTIFICATIONS_NO_EXPERIENCE_ID',
+      "No 'projectId' found. If 'projectId' can't be inferred from the manifest (eg. in bare workflow), you have to pass it in yourself."
+    );
+  }
+
+  const applicationId = options.applicationId || Application.applicationId;
+  if (!applicationId) {
+    throw new CodedError(
+      'ERR_NOTIFICATIONS_NO_APPLICATION_ID',
+      "No applicationId found. If it can't be inferred from native configuration by expo-application, you have to pass it in yourself."
+    );
+  }
+  const type = options.type || getTypeOfToken(devicePushToken);
+  const development = options.development || (await shouldUseDevelopmentNotificationService());
+
+  const baseUrl = options.baseUrl ?? productionBaseUrl;
+  const url = options.url ?? `${baseUrl}push/getExpoPushToken`;
+
+  const body = {
+    type,
+    deviceId: deviceId.toLowerCase(),
+    development,
+    appId: applicationId,
+    deviceToken: getDeviceToken(devicePushToken),
+    projectId,
+  };
+
+  const response = await fetch(url, {
+    method: 'POST',
+    headers: {
+      'content-type': 'application/json',
+    },
+    body: JSON.stringify(body),
+  }).catch((error) => {
+    throw new CodedError(
+      'ERR_NOTIFICATIONS_NETWORK_ERROR',
+      `Error encountered while fetching Expo token: ${error}.`
+    );
+  });
+
+  if (!response.ok) {
+    const statusInfo = response.statusText || response.status;
+    let body: string | undefined = undefined;
+    try {
+      body = await response.text();
+    } catch {
+      // do nothing
+    }
+    throw new CodedError(
+      'ERR_NOTIFICATIONS_SERVER_ERROR',
+      `Error encountered while fetching Expo token, expected an OK response, received: ${statusInfo} (body: "${body}").`
+    );
+  }
+
+  const expoPushToken = getExpoPushToken(await parseResponse(response));
+
+  try {
+    if (options.url || options.baseUrl) {
+      console.debug(
+        `[expo-notifications] Since the URL endpoint to register in has been customized in the options, expo-notifications won't try to auto-update the device push token on the server.`
+      );
+    } else {
+      await setAutoServerRegistrationEnabledAsync(true);
+    }
+  } catch (e) {
+    console.warn(
+      '[expo-notifications] Could not enable automatically registering new device tokens with the Expo notification service',
+      e
+    );
+  }
+
+  return {
+    type: 'expo',
+    data: expoPushToken,
+  };
+}
+
+async function parseResponse(response: Response) {
+  try {
+    return await response.json();
+  } catch {
+    try {
+      throw new CodedError(
+        'ERR_NOTIFICATIONS_SERVER_ERROR',
+        `Expected a JSON response from server when fetching Expo token, received body: ${JSON.stringify(
+          await response.text()
+        )}.`
+      );
+    } catch {
+      throw new CodedError(
+        'ERR_NOTIFICATIONS_SERVER_ERROR',
+        `Expected a JSON response from server when fetching Expo token, received response: ${JSON.stringify(
+          response
+        )}.`
+      );
+    }
+  }
+}
+
+function getExpoPushToken(data: any) {
+  if (
+    !data ||
+    !(typeof data === 'object') ||
+    !data.data ||
+    !(typeof data.data === 'object') ||
+    !data.data.expoPushToken ||
+    !(typeof data.data.expoPushToken === 'string')
+  ) {
+    throw new CodedError(
+      'ERR_NOTIFICATIONS_SERVER_ERROR',
+      `Malformed response from server, expected "{ data: { expoPushToken: string } }", received: ${JSON.stringify(
+        data,
+        null,
+        2
+      )}.`
+    );
+  }
+
+  return data.data.expoPushToken as string;
+}
+
+// Same as in DevicePushTokenAutoRegistration
+async function getDeviceIdAsync() {
+  try {
+    if (!ServerRegistrationModule.getInstallationIdAsync) {
+      throw new UnavailabilityError('ExpoServerRegistrationModule', 'getInstallationIdAsync');
+    }
+
+    return await ServerRegistrationModule.getInstallationIdAsync();
+  } catch (e) {
+    throw new CodedError(
+      'ERR_NOTIF_DEVICE_ID',
+      `Could not have fetched installation ID of the application: ${e}.`
+    );
+  }
+}
+
+function getDeviceToken(devicePushToken: DevicePushToken) {
+  if (typeof devicePushToken.data === 'string') {
+    return devicePushToken.data;
+  }
+
+  return JSON.stringify(devicePushToken.data);
+}
+
+// Same as in DevicePushTokenAutoRegistration
+async function shouldUseDevelopmentNotificationService() {
+  if (Platform.OS === 'ios') {
+    try {
+      const notificationServiceEnvironment =
+        await Application.getIosPushNotificationServiceEnvironmentAsync();
+      if (notificationServiceEnvironment === 'development') {
+        return true;
+      }
+    } catch {
+      // We can't do anything here, we'll fallback to false then.
+    }
+  }
+
+  return false;
+}
+
+// Same as in DevicePushTokenAutoRegistration
+function getTypeOfToken(devicePushToken: DevicePushToken) {
+  switch (devicePushToken.type) {
+    case 'ios':
+      return 'apns';
+    case 'android':
+      return 'fcm';
+    // This probably will error on server, but let's make this function future-safe.
+    default:
+      return devicePushToken.type;
+  }
+}

package/src/getNextTriggerDateAsync.ts

@@ -0,0 +1,38 @@
+import { UnavailabilityError } from 'expo-modules-core';
+
+import NotificationScheduler from './NotificationScheduler';
+import { SchedulableNotificationTriggerInput } from './Notifications.types';
+import { parseTrigger } from './scheduleNotificationAsync';
+
+/**
+ * Allows you to check what will be the next trigger date for given notification trigger input.
+ * @param trigger The schedulable notification trigger you would like to check next trigger date for (of type [`SchedulableNotificationTriggerInput`](#schedulablenotificationtriggerinput)).
+ * @return If the return value is `null`, the notification won't be triggered. Otherwise, the return value is the Unix timestamp in milliseconds
+ * at which the notification will be triggered.
+ * @example Calculate next trigger date for a notification trigger:
+ * ```ts
+ * import * as Notifications from '@amazon-devices/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}`);
+ *   }
+ * }
+ * ```
+ * @header schedule
+ */
+export default async function getNextTriggerDateAsync(
+  trigger: SchedulableNotificationTriggerInput
+): Promise<number | null> {
+  if (!NotificationScheduler.getNextTriggerDateAsync) {
+    throw new UnavailabilityError('ExpoNotifications', 'getNextTriggerDateAsync');
+  }
+
+  return await NotificationScheduler.getNextTriggerDateAsync(parseTrigger(trigger));
+}

package/src/getNotificationCategoriesAsync.ts

@@ -0,0 +1,21 @@
+import { UnavailabilityError } from 'expo-modules-core';
+
+// @amznmod_react - Changed .native import to one without postfix
+import NotificationCategoriesModule from './NotificationCategoriesModule';
+import { NotificationCategory } from './Notifications.types';
+
+/**
+ * Fetches information about all known notification categories.
+ * @return A Promise which resolves to an array of `NotificationCategory`s. On platforms that do not support notification channels,
+ * it will always resolve to an empty array.
+ * @platform android
+ * @platform ios
+ * @header categories
+ */
+export default async function getNotificationCategoriesAsync(): Promise<NotificationCategory[]> {
+  if (!NotificationCategoriesModule.getNotificationCategoriesAsync) {
+    throw new UnavailabilityError('Notifications', 'getNotificationCategoriesAsync');
+  }
+
+  return await NotificationCategoriesModule.getNotificationCategoriesAsync();
+}

package/src/getNotificationChannelAsync.android.ts

@@ -0,0 +1,13 @@
+import { UnavailabilityError } from 'expo-modules-core';
+
+import NotificationChannelManager from './NotificationChannelManager';
+import { NotificationChannel } from './NotificationChannelManager.types';
+
+export default async function getNotificationChannelAsync(
+  channelId: string
+): Promise<NotificationChannel | null> {
+  if (!NotificationChannelManager.getNotificationChannelAsync) {
+    throw new UnavailabilityError('Notifications', 'getNotificationChannelAsync');
+  }
+  return await NotificationChannelManager.getNotificationChannelAsync(channelId);
+}

package/src/getNotificationChannelAsync.ts

@@ -0,0 +1,16 @@
+import { NotificationChannel } from './NotificationChannelManager.types';
+
+/**
+ * Fetches information about a single notification channel.
+ * @param channelId The channel's identifier.
+ * @return A Promise which resolves to the channel object (of type [`NotificationChannel`](#notificationchannel)) or to `null`
+ * if there was no channel found for this identifier. On platforms that do not support notification channels, it will always resolve to `null`.
+ * @platform android
+ * @header channels
+ */
+export default async function getNotificationChannelAsync(
+  channelId: string
+): Promise<NotificationChannel | null> {
+  console.debug('Notification channels feature is only supported on Android.');
+  return null;
+}

package/src/getNotificationChannelGroupAsync.android.ts

@@ -0,0 +1,14 @@
+import { UnavailabilityError } from 'expo-modules-core';
+
+import NotificationChannelGroupManager from './NotificationChannelGroupManager';
+import { NotificationChannelGroup } from './NotificationChannelGroupManager.types';
+
+export default async function getNotificationChannelGroupAsync(
+  groupId: string
+): Promise<NotificationChannelGroup | null> {
+  if (!NotificationChannelGroupManager.getNotificationChannelGroupAsync) {
+    throw new UnavailabilityError('Notifications', 'getNotificationChannelGroupAsync');
+  }
+
+  return await NotificationChannelGroupManager.getNotificationChannelGroupAsync(groupId);
+}

package/src/getNotificationChannelGroupAsync.ts

@@ -0,0 +1,17 @@
+import { NotificationChannelGroup } from './NotificationChannelGroupManager.types';
+
+/**
+ * Fetches information about a single notification channel group.
+ * @param groupId The channel group's identifier.
+ * @return A Promise which resolves to the channel group object (of type [`NotificationChannelGroup`](#notificationchannelgroup))
+ * or to `null` if there was no channel group found for this identifier. On platforms that do not support notification channels,
+ * it will always resolve to `null`.
+ * @platform android
+ * @header channels
+ */
+export default async function getNotificationChannelGroupAsync(
+  groupId: string
+): Promise<NotificationChannelGroup | null> {
+  console.debug('Notification channels feature is only supported on Android.');
+  return null;
+}