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

package/src/BadgeModule.kepler.ts

@@ -0,0 +1,8 @@
+/*
+ * Copyright (c) 2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * Use is subject to license terms.
+ */
+export default {};

package/src/BadgeModule.native.ts

@@ -0,0 +1,15 @@
+import { requireNativeModule } from 'expo-modules-core';
+
+import { BadgeModule } from './BadgeModule.types';
+
+const nativeModule = requireNativeModule('ExpoBadgeModule');
+
+export default {
+  ...nativeModule,
+  // We overwrite setBadgeCountAsync to omit
+  // an obsolete options argument when calling
+  // the native function.
+  setBadgeCountAsync: async (badgeCount, options) => {
+    return await nativeModule.setBadgeCountAsync(badgeCount);
+  },
+} as BadgeModule;

package/src/BadgeModule.ts

@@ -0,0 +1,6 @@
+import { BadgeModule } from './BadgeModule.types';
+
+export default {
+  addListener: () => {},
+  removeListeners: () => {},
+} as BadgeModule;

package/src/BadgeModule.types.ts

@@ -0,0 +1,11 @@
+import { Options as BadginOptions } from 'badgin';
+import { ProxyNativeModule } from 'expo-modules-core';
+
+export type WebSetBadgeCountOptions = BadginOptions;
+type SetBadgeCountOptions = WebSetBadgeCountOptions | undefined;
+
+export interface BadgeModule extends ProxyNativeModule {
+  getBadgeCountAsync?: () => Promise<number>;
+  // @amznmod_react - Made options optional
+  setBadgeCountAsync?: (badgeCount: number, options?: SetBadgeCountOptions) => Promise<boolean>;
+}

package/src/BadgeModule.web.ts

@@ -0,0 +1,28 @@
+import { BadgeModule } from './BadgeModule.types';
+
+let lastSetBadgeCount = 0;
+
+const badgeModule: BadgeModule = {
+  addListener: () => {},
+  removeListeners: () => {},
+  getBadgeCountAsync: async () => {
+    return lastSetBadgeCount;
+  },
+  setBadgeCountAsync: async (badgeCount, options) => {
+    // If this module is loaded in SSR (NextJS), we can't modify the badge.
+    // It also can't load the badgin module, that instantly invokes methods on window.
+    if (typeof window === 'undefined') {
+      return false;
+    }
+    const badgin = require('badgin');
+    if (badgeCount > 0) {
+      badgin.set(badgeCount, options);
+    } else {
+      badgin.clear();
+    }
+    lastSetBadgeCount = badgeCount;
+    return true;
+  },
+};
+
+export default badgeModule;

package/src/DevicePushTokenAutoRegistration.fx.ts

@@ -0,0 +1,119 @@
+import 'abort-controller/polyfill';
+import { UnavailabilityError } from 'expo-modules-core';
+
+import ServerRegistrationModule from './ServerRegistrationModule';
+import { addPushTokenListener } from './TokenEmitter';
+import { DevicePushToken } from './Tokens.types';
+import getDevicePushTokenAsync from './getDevicePushTokenAsync';
+import { updateDevicePushTokenAsync as updateDevicePushTokenAsyncWithSignal } from './utils/updateDevicePushTokenAsync';
+
+let lastAbortController: AbortController | null = null;
+async function updatePushTokenAsync(token: DevicePushToken) {
+  // Abort current update process
+  lastAbortController?.abort();
+  lastAbortController = new AbortController();
+  return await updateDevicePushTokenAsyncWithSignal(lastAbortController.signal, token);
+}
+
+/**
+ * Encapsulates device server registration data
+ */
+export type DevicePushTokenRegistration = {
+  isEnabled: boolean;
+};
+
+/**
+ * Sets the registration information so that the device push token gets pushed
+ * to the given registration endpoint
+ * @param enabled
+ */
+export async function setAutoServerRegistrationEnabledAsync(enabled: boolean) {
+  // We are overwriting registration, so we shouldn't let
+  // any pending request complete.
+  lastAbortController?.abort();
+
+  if (!ServerRegistrationModule.setRegistrationInfoAsync) {
+    throw new UnavailabilityError('ServerRegistrationModule', 'setRegistrationInfoAsync');
+  }
+
+  await ServerRegistrationModule.setRegistrationInfoAsync(
+    enabled ? JSON.stringify({ isEnabled: enabled }) : null
+  );
+}
+
+// note(Chmiela): This function is exported only for testing purposes.
+export async function __handlePersistedRegistrationInfoAsync(
+  registrationInfo: string | null | undefined
+) {
+  if (!registrationInfo) {
+    // No registration info, nothing to do
+    return;
+  }
+
+  let registration: DevicePushTokenRegistration | null = null;
+  try {
+    registration = JSON.parse(registrationInfo);
+  } catch (e) {
+    console.warn(
+      '[expo-notifications] Error encountered while fetching registration information for auto token updates.',
+      e
+    );
+  }
+
+  if (!registration?.isEnabled) {
+    // Registration is invalid or not enabled, nothing more to do
+    return;
+  }
+
+  try {
+    // Since the registration is enabled, fetching a "new" device token
+    // shouldn't be a problem.
+    const latestDevicePushToken = await getDevicePushTokenAsync();
+    await updatePushTokenAsync(latestDevicePushToken);
+  } catch (e) {
+    console.warn(
+      '[expo-notifications] Error encountered while updating server registration with latest device push token.',
+      e
+    );
+  }
+}
+
+if (ServerRegistrationModule.getRegistrationInfoAsync) {
+  // A global scope (to get all the updates) device push token
+  // subscription, never cleared.
+  addPushTokenListener(async (token) => {
+    try {
+      // Before updating the push token on server we always check if we should
+      // Since modules can't change their method availability while running, we
+      // can assert it's defined.
+      const registrationInfo = await ServerRegistrationModule.getRegistrationInfoAsync!();
+
+      if (!registrationInfo) {
+        // Registration is not enabled
+        return;
+      }
+
+      const registration: DevicePushTokenRegistration | null = JSON.parse(registrationInfo);
+      if (registration?.isEnabled) {
+        // Dispatch an abortable task to update
+        // registration with new token.
+        await updatePushTokenAsync(token);
+      }
+    } catch (e) {
+      console.warn(
+        '[expo-notifications] Error encountered while updating server registration with latest device push token.',
+        e
+      );
+    }
+  });
+
+  // Verify if persisted registration
+  // has successfully uploaded last known
+  // device push token. If not, retry.
+  ServerRegistrationModule.getRegistrationInfoAsync().then(__handlePersistedRegistrationInfoAsync);
+} else {
+  console.warn(
+    `[expo-notifications] Error encountered while fetching auto-registration state, new tokens will not be automatically registered on server.`,
+    new UnavailabilityError('ServerRegistrationModule', 'getRegistrationInfoAsync')
+  );
+}

package/src/NotificationCategoriesModule.kepler.ts

@@ -0,0 +1,10 @@
+/*
+ * Copyright (c) 2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * Use is subject to license terms.
+ */
+import { default as NotificationCategoriesModule  } from './NotificationCategoriesModule.web';
+
+export default NotificationCategoriesModule;

package/src/NotificationCategoriesModule.native.ts

@@ -0,0 +1,7 @@
+import { requireNativeModule } from 'expo-modules-core';
+
+import { NotificationCategoriesModule } from './NotificationCategoriesModule.types';
+
+export default requireNativeModule<NotificationCategoriesModule>(
+  'ExpoNotificationCategoriesModule'
+);

package/src/NotificationCategoriesModule.ts

@@ -0,0 +1,15 @@
+import { NotificationCategoriesModule } from './NotificationCategoriesModule.types';
+import { NotificationCategory } from './Notifications.types';
+
+export default {
+  addListener: () => {},
+  removeListeners: () => {},
+  getNotificationCategoriesAsync: async (): Promise<NotificationCategory[]> => [],
+  setNotificationCategoryAsync: async (): Promise<NotificationCategory> => {
+    return {
+      identifier: 'NOT_IMPLEMENTED',
+      actions: [{ identifier: 'NOT_IMPLEMENTED', buttonTitle: 'NOT_IMPLEMENTED' }],
+    };
+  },
+  deleteNotificationCategoryAsync: async () => false,
+} as NotificationCategoriesModule;

package/src/NotificationCategoriesModule.types.ts

@@ -0,0 +1,22 @@
+import { ProxyNativeModule } from 'expo-modules-core';
+
+import { NotificationCategory, NotificationAction } from './Notifications.types';
+
+export interface NotificationCategoriesModule extends ProxyNativeModule {
+  getNotificationCategoriesAsync: () => Promise<NotificationCategory[]>;
+  setNotificationCategoryAsync: (
+    identifier: string,
+    actions: NotificationAction[],
+    options?: {
+      previewPlaceholder?: string;
+      intentIdentifiers?: string[];
+      categorySummaryFormat?: string;
+      customDismissAction?: boolean;
+      allowInCarPlay?: boolean;
+      showTitle?: boolean;
+      showSubtitle?: boolean;
+      allowAnnouncement?: boolean;
+    }
+  ) => Promise<NotificationCategory>;
+  deleteNotificationCategoryAsync: (identifier: string) => Promise<boolean>;
+}

package/src/NotificationCategoriesModule.web.ts

@@ -0,0 +1,17 @@
+import { NotificationAction } from './Notifications.types';
+
+export default {
+  async getNotificationCategoriesAsync(): Promise<null> {
+    return null;
+  },
+  async setNotificationCategoryAsync(
+    identifier: string,
+    actions: NotificationAction[],
+    options?: object
+  ): Promise<null> {
+    return null;
+  },
+  async deleteNotificationCategoryAsync(identifier: string): Promise<null> {
+    return null;
+  },
+};

package/src/NotificationChannelGroupManager.kepler.ts

@@ -0,0 +1,8 @@
+/*
+ * Copyright (c) 2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * Use is subject to license terms.
+ */
+export default {};

package/src/NotificationChannelGroupManager.native.ts

@@ -0,0 +1,7 @@
+import { requireNativeModule } from 'expo-modules-core';
+
+import { NotificationChannelGroupManager } from './NotificationChannelGroupManager.types';
+
+export default requireNativeModule<NotificationChannelGroupManager>(
+  'ExpoNotificationChannelGroupManager'
+);

package/src/NotificationChannelGroupManager.ts

@@ -0,0 +1,6 @@
+import { NotificationChannelGroupManager } from './NotificationChannelGroupManager.types';
+
+export default {
+  addListener: () => {},
+  removeListeners: () => {},
+} as NotificationChannelGroupManager;

package/src/NotificationChannelGroupManager.types.ts

@@ -0,0 +1,34 @@
+import { ProxyNativeModule } from 'expo-modules-core';
+
+import { NotificationChannel } from './NotificationChannelManager.types';
+
+/**
+ * An object represents a notification channel group.
+ * @platform android
+ */
+export interface NotificationChannelGroup {
+  id: string;
+  name: string | null;
+  description?: string | null;
+  isBlocked?: boolean;
+  channels: NotificationChannel[];
+}
+
+/**
+ * An object represents a notification channel group to be set.
+ * @platform android
+ */
+export interface NotificationChannelGroupInput {
+  name: string | null;
+  description?: string | null;
+}
+
+export interface NotificationChannelGroupManager extends ProxyNativeModule {
+  getNotificationChannelGroupsAsync?: () => Promise<NotificationChannelGroup[]>;
+  getNotificationChannelGroupAsync?: (groupId: string) => Promise<NotificationChannelGroup | null>;
+  setNotificationChannelGroupAsync?: (
+    groupId: string,
+    group: NotificationChannelGroupInput
+  ) => Promise<NotificationChannelGroup | null>;
+  deleteNotificationChannelGroupAsync?: (groupId: string) => Promise<void>;
+}

package/src/NotificationChannelManager.kepler.ts

@@ -0,0 +1,8 @@
+/*
+ * Copyright (c) 2023 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * Use is subject to license terms.
+ */
+export default {};

package/src/NotificationChannelManager.native.ts

@@ -0,0 +1,5 @@
+import { requireNativeModule } from 'expo-modules-core';
+
+import { NotificationChannelManager } from './NotificationChannelManager.types';
+
+export default requireNativeModule<NotificationChannelManager>('ExpoNotificationChannelManager');

package/src/NotificationChannelManager.ts

@@ -0,0 +1,6 @@
+import { NotificationChannelManager } from './NotificationChannelManager.types';
+
+export default {
+  addListener: () => {},
+  removeListeners: () => {},
+} as NotificationChannelManager;

package/src/NotificationChannelManager.types.ts

@@ -0,0 +1,115 @@
+import { ProxyNativeModule } from 'expo-modules-core';
+
+// @docsMissing
+export enum AndroidNotificationVisibility {
+  UNKNOWN = 0,
+  PUBLIC = 1,
+  PRIVATE = 2,
+  SECRET = 3,
+}
+
+// @docsMissing
+export enum AndroidAudioContentType {
+  UNKNOWN = 0,
+  SPEECH = 1,
+  MUSIC = 2,
+  MOVIE = 3,
+  SONIFICATION = 4,
+}
+
+// @docsMissing
+export enum AndroidImportance {
+  UNKNOWN = 0,
+  UNSPECIFIED = 1,
+  NONE = 2,
+  MIN = 3,
+  LOW = 4,
+  DEFAULT = 5,
+  /**
+   * @deprecated Use `DEFAULT` instead.
+   */
+  DEEFAULT = 5,
+  HIGH = 6,
+  MAX = 7,
+}
+
+// @docsMissing
+export enum AndroidAudioUsage {
+  UNKNOWN = 0,
+  MEDIA = 1,
+  VOICE_COMMUNICATION = 2,
+  VOICE_COMMUNICATION_SIGNALLING = 3,
+  ALARM = 4,
+  NOTIFICATION = 5,
+  NOTIFICATION_RINGTONE = 6,
+  NOTIFICATION_COMMUNICATION_REQUEST = 7,
+  NOTIFICATION_COMMUNICATION_INSTANT = 8,
+  NOTIFICATION_COMMUNICATION_DELAYED = 9,
+  NOTIFICATION_EVENT = 10,
+  ASSISTANCE_ACCESSIBILITY = 11,
+  ASSISTANCE_NAVIGATION_GUIDANCE = 12,
+  ASSISTANCE_SONIFICATION = 13,
+  GAME = 14,
+}
+
+// @docsMissing
+export interface AudioAttributes {
+  usage: AndroidAudioUsage;
+  contentType: AndroidAudioContentType;
+  flags: {
+    enforceAudibility: boolean;
+    requestHardwareAudioVideoSynchronization: boolean;
+  };
+}
+
+// We're making inner flags required to set intentionally.
+// Not providing `true` for a flag makes it false, it doesn't make sense
+// to let it be left undefined.
+export type AudioAttributesInput = Partial<AudioAttributes>;
+
+/**
+ * An object represents a notification channel.
+ * @platform android
+ */
+export interface NotificationChannel {
+  id: string;
+  name: string | null;
+  importance: AndroidImportance;
+  bypassDnd: boolean;
+  description: string | null;
+  groupId?: string | null;
+  lightColor: string;
+  lockscreenVisibility: AndroidNotificationVisibility;
+  showBadge: boolean;
+  sound: 'default' | 'custom' | null;
+  audioAttributes: AudioAttributes;
+  vibrationPattern: number[] | null;
+  enableLights: boolean;
+  enableVibrate: boolean;
+}
+
+type RequiredBy<T, K extends keyof T> = Partial<Omit<T, K>> & Required<Pick<T, K>>;
+
+/**
+ * An object represents a notification channel to be set.
+ * @platform android
+ */
+export type NotificationChannelInput = RequiredBy<
+  Omit<
+    NotificationChannel,
+    | 'id' // id is handled separately as a function argument
+    | 'audioAttributes' // need to make it AudioAttributesInput
+    | 'sound'
+  > & { audioAttributes?: AudioAttributesInput; sound?: string | null },
+  'name' | 'importance'
+>;
+
+export interface NotificationChannelManager extends ProxyNativeModule {
+  getNotificationChannelsAsync?: () => Promise<NotificationChannel[] | null>;
+  getNotificationChannelAsync?: (channelId: string) => Promise<NotificationChannel | null>;
+  setNotificationChannelAsync?: (
+    channelId: string,
+    channelConfiguration: NotificationChannelInput
+  ) => Promise<NotificationChannel | null>;
+  deleteNotificationChannelAsync?: (channelId: string) => Promise<void>;
+}

package/src/NotificationPermissions.ts

@@ -0,0 +1,91 @@
+import { createPermissionHook, Platform, UnavailabilityError } from 'expo-modules-core';
+
+import {
+  NotificationPermissionsRequest,
+  NotificationPermissionsStatus,
+} from './NotificationPermissions.types';
+import NotificationPermissionsModule from './NotificationPermissionsModule';
+
+/**
+ * Calling this function checks current permissions settings related to notifications.
+ * It lets you verify whether the app is currently allowed to display alerts, play sounds, etc.
+ * There is no user-facing effect of calling this.
+ * @return It returns a `Promise` resolving to an object represents permission settings ([`NotificationPermissionsStatus`](#notificationpermissionsstatus)).
+ * On iOS, make sure you [properly interpret the permissions response](#interpret-the-ios-permissions-response).
+ * @example Check if the app is allowed to send any type of notifications (interrupting and non-interrupting–provisional on iOS).
+ * ```ts
+ * import * as Notifications from '@amazon-devices/expo-notifications';
+ *
+ * export async function allowsNotificationsAsync() {
+ *   const settings = await Notifications.getPermissionsAsync();
+ *   return (
+ *     settings.granted || settings.ios?.status === Notifications.IosAuthorizationStatus.PROVISIONAL
+ *   );
+ * }
+ * ```
+ * @header permissions
+ */
+export async function getPermissionsAsync() {
+  if (!NotificationPermissionsModule.getPermissionsAsync) {
+    throw new UnavailabilityError('Notifications', 'getPermissionsAsync');
+  }
+
+  return await NotificationPermissionsModule.getPermissionsAsync();
+}
+
+/**
+ * Prompts the user for notification permissions according to request. **Request defaults to asking the user to allow displaying alerts,
+ * setting badge count and playing sounds**.
+ * @param permissions An object representing configuration for the request scope.
+ * @return It returns a Promise resolving to an object represents permission settings ([`NotificationPermissionsStatus`](#notificationpermissionsstatus)).
+ * On iOS, make sure you [properly interpret the permissions response](#interpret-the-ios-permissions-response).
+ * @example Prompts the user to allow the app to show alerts, play sounds, set badge count and let Siri read out messages through AirPods.
+ * ```ts
+ * import * as Notifications from '@amazon-devices/expo-notifications';
+ *
+ * export function requestPermissionsAsync() {
+ *   return await Notifications.requestPermissionsAsync({
+ *     ios: {
+ *       allowAlert: true,
+ *       allowBadge: true,
+ *       allowSound: true,
+ *       allowAnnouncements: true,
+ *     },
+ *   });
+ * }
+ * ```
+ * @header permissions
+ */
+export async function requestPermissionsAsync(permissions?: NotificationPermissionsRequest) {
+  if (!NotificationPermissionsModule.requestPermissionsAsync) {
+    throw new UnavailabilityError('Notifications', 'requestPermissionsAsync');
+  }
+
+  const requestedPermissions = permissions ?? {
+    ios: {
+      allowAlert: true,
+      allowBadge: true,
+      allowSound: true,
+    },
+  };
+  const requestedPlatformPermissions = requestedPermissions[Platform.OS];
+  return await NotificationPermissionsModule.requestPermissionsAsync(requestedPlatformPermissions);
+}
+
+// @needsAudit
+/**
+ * Check or request permissions to send and receive push notifications.
+ * This uses both `requestPermissionsAsync` and `getPermissionsAsync` to interact with the permissions.
+ * @example
+ * ```ts
+ * const [permissionResponse, requestPermission] = Notifications.usePermissions();
+ * ```
+ * @header permission
+ */
+export const usePermissions = createPermissionHook<
+  NotificationPermissionsStatus,
+  NotificationPermissionsRequest
+>({
+  requestMethod: requestPermissionsAsync,
+  getMethod: getPermissionsAsync,
+});

package/src/NotificationPermissions.types.ts

@@ -0,0 +1,102 @@
+import { PermissionResponse, PermissionHookOptions } from 'expo-modules-core';
+
+export enum IosAlertStyle {
+  NONE = 0,
+  BANNER = 1,
+  ALERT = 2,
+}
+
+export enum IosAllowsPreviews {
+  NEVER = 0,
+  ALWAYS = 1,
+  WHEN_AUTHENTICATED = 2,
+}
+
+export enum IosAuthorizationStatus {
+  NOT_DETERMINED = 0,
+  DENIED = 1,
+  AUTHORIZED = 2,
+  PROVISIONAL = 3,
+  EPHEMERAL = 4,
+}
+
+export { PermissionHookOptions };
+
+// @docsMissing
+export interface NotificationPermissionsStatus extends PermissionResponse {
+  android?: {
+    importance: number;
+    interruptionFilter?: number;
+  };
+  ios?: {
+    status: IosAuthorizationStatus;
+    allowsDisplayInNotificationCenter: boolean | null;
+    allowsDisplayOnLockScreen: boolean | null;
+    allowsDisplayInCarPlay: boolean | null;
+    allowsAlert: boolean | null;
+    allowsBadge: boolean | null;
+    allowsSound: boolean | null;
+    allowsCriticalAlerts?: boolean | null;
+    alertStyle: IosAlertStyle;
+    allowsPreviews?: IosAllowsPreviews;
+    providesAppNotificationSettings?: boolean;
+    allowsAnnouncements?: boolean | null;
+  };
+}
+
+/**
+ * Available configuration for permission request on iOS platform.
+ * See Apple documentation for [`UNAuthorizationOptions`](https://developer.apple.com/documentation/usernotifications/unauthorizationoptions) to learn more.
+ */
+export interface IosNotificationPermissionsRequest {
+  /**
+   * The ability to display alerts.
+   */
+  allowAlert?: boolean;
+  /**
+   * The ability to update the app’s badge.
+   */
+  allowBadge?: boolean;
+  /**
+   * The ability to play sounds.
+   */
+  allowSound?: boolean;
+  /**
+   * The ability to display notifications in a CarPlay environment.
+   */
+  allowDisplayInCarPlay?: boolean;
+  /**
+   * The ability to play sounds for critical alerts.
+   */
+  allowCriticalAlerts?: boolean;
+  /**
+   * An option indicating the system should display a button for in-app notification settings.
+   */
+  provideAppNotificationSettings?: boolean;
+  /**
+   * The ability to post noninterrupting notifications provisionally to the Notification Center.
+   */
+  allowProvisional?: boolean;
+  /**
+   * The ability for Siri to automatically read out messages over AirPods.
+   * @deprecated
+   */
+  allowAnnouncements?: boolean;
+}
+
+export type NativeNotificationPermissionsRequest = IosNotificationPermissionsRequest | object;
+
+/**
+ * An interface representing the permissions request scope configuration.
+ * Each option corresponds to a different native platform authorization option.
+ */
+export interface NotificationPermissionsRequest {
+  /**
+   * Available configuration for permission request on iOS platform.
+   */
+  ios?: IosNotificationPermissionsRequest;
+  /**
+   * On Android, all available permissions are granted by default, and if a user declines any permission, an app cannot prompt the user to change.
+   */
+  android?: object;
+}

package/src/NotificationPermissionsModule.kepler.ts

@@ -0,0 +1,8 @@
+/*
+ * Copyright (c) 2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * Use is subject to license terms.
+ */
+export default {};