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

package/src/NotificationPermissionsModule.native.ts

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

package/src/NotificationPermissionsModule.ts

@@ -0,0 +1,83 @@
+import { PermissionStatus, Platform } from 'expo-modules-core';
+
+import {
+  NativeNotificationPermissionsRequest,
+  NotificationPermissionsStatus,
+} from './NotificationPermissions.types';
+import { NotificationPermissionsModule } from './NotificationPermissionsModule.types';
+
+function convertPermissionStatus(
+  status?: NotificationPermission | 'prompt'
+): NotificationPermissionsStatus {
+  switch (status) {
+    case 'granted':
+      return {
+        status: PermissionStatus.GRANTED,
+        expires: 'never',
+        canAskAgain: false,
+        granted: true,
+      };
+    case 'denied':
+      return {
+        status: PermissionStatus.DENIED,
+        expires: 'never',
+        canAskAgain: false,
+        granted: false,
+      };
+    default:
+      return {
+        status: PermissionStatus.UNDETERMINED,
+        expires: 'never',
+        canAskAgain: true,
+        granted: false,
+      };
+  }
+}
+
+async function resolvePermissionAsync({
+  shouldAsk,
+}: {
+  shouldAsk: boolean;
+}): Promise<NotificationPermissionsStatus> {
+  if (!Platform.isDOMAvailable) {
+    return convertPermissionStatus('denied');
+  }
+
+  const { Notification = {} } = window as any;
+  if (typeof Notification.requestPermission !== 'undefined') {
+    let status = Notification.permission;
+    if (shouldAsk) {
+      status = await new Promise((resolve, reject) => {
+        let resolved = false;
+        function resolveOnce(status: string) {
+          if (!resolved) {
+            resolved = true;
+            resolve(status);
+          }
+        }
+        // Some browsers require a callback argument and some return a Promise
+        Notification.requestPermission(resolveOnce)?.then(resolveOnce)?.catch(reject);
+      });
+    }
+    return convertPermissionStatus(status);
+  } else if (typeof navigator !== 'undefined' && navigator?.permissions?.query) {
+    // TODO(Bacon): Support `push` in the future when it's stable.
+    const query = await navigator.permissions.query({ name: 'notifications' });
+    return convertPermissionStatus(query.state);
+  }
+  // Platforms like iOS Safari don't support Notifications so return denied.
+  return convertPermissionStatus('denied');
+}
+
+export default {
+  addListener: () => {},
+  removeListeners: () => {},
+  async getPermissionsAsync(): Promise<NotificationPermissionsStatus> {
+    return resolvePermissionAsync({ shouldAsk: false });
+  },
+  async requestPermissionsAsync(
+    request: NativeNotificationPermissionsRequest
+  ): Promise<NotificationPermissionsStatus> {
+    return resolvePermissionAsync({ shouldAsk: true });
+  },
+} as NotificationPermissionsModule;

package/src/NotificationPermissionsModule.types.ts

@@ -0,0 +1,13 @@
+import { ProxyNativeModule } from 'expo-modules-core';
+
+import {
+  NotificationPermissionsStatus,
+  NativeNotificationPermissionsRequest,
+} from './NotificationPermissions.types';
+
+export interface NotificationPermissionsModule extends ProxyNativeModule {
+  getPermissionsAsync?: () => Promise<NotificationPermissionsStatus>;
+  requestPermissionsAsync?: (
+    request: NativeNotificationPermissionsRequest
+  ) => Promise<NotificationPermissionsStatus>;
+}

package/src/NotificationPresenterModule.kepler.ts

@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * Use is subject to license terms.
+ */
+import { UnavailabilityError } from 'expo-modules-core';
+
+import { NotificationPresenterModule } from './NotificationPresenterModule.types';
+import {
+  NotificationContent,
+  NotificationContentInput,
+  UnknownNotificationTrigger,
+} from './Notifications.types';
+import NativeNotificationManager from './kepler/native-notification-manager';
+import { Notification } from './kepler/types/NotificationManagerTypes';
+import { parseNotificationUuid, stringifyNotificationUuid } from './utils/keplerUuidUtils';
+
+const notificationPresenterModule: NotificationPresenterModule = {
+  getPresentedNotificationsAsync: async () => {
+    const nativeNotifications: Notification[] = await NativeNotificationManager.getNotifications({});
+
+    // Type of the notification returned from the NM TM is different than the ones present in Typescript // (different key names)
+    // So just in case this changes, code below uses both:
+    const expoNotifications = nativeNotifications.map((n) => {
+      const content = n.notificationContent || n['content'];
+      const jsContent: NotificationContent = {
+        title: content['title'] || content['mTitle'],
+        subtitle: content['description'] || content['mDescription'],
+        body: content['footnote'] || content['mFootnote'] || '',
+        data: {},
+        sound: null,
+        iconUri: content['iconUri'] || content['mIconUri'],
+        smallIconUri: content['smallIconUri'] || content['mSmallIconUri'],
+        largeIconUri: content['largeIconUri'] || content['mLargeIconUri'],
+        channel: content['channel'] || content['mChannel'],
+      };
+
+      return {
+        date: 0, // No date information on kepler
+        request: {
+          identifier: stringifyNotificationUuid(n.id),
+          trigger: { type: 'unknown' } as UnknownNotificationTrigger,
+          content: jsContent,
+        },
+      };
+    });
+
+    return expoNotifications;
+  },
+  // Deprecated: https://github.com/expo/fyi/blob/main/presenting-notifications-deprecated.md
+  presentNotificationAsync: async (_identifier: string, _content: NotificationContentInput) => {
+    throw new UnavailabilityError('expo-notifications', 'presentNotificationAsync');
+  },
+  dismissNotificationAsync: async (identifier: string) => {
+    const bytes = parseNotificationUuid(identifier);
+    await NativeNotificationManager.remove(bytes);
+  },
+  dismissAllNotificationsAsync: async () => {
+    await NativeNotificationManager.readerRemove({});
+  },
+  addListener: () => {},
+  removeListeners: () => {},
+};
+
+export default notificationPresenterModule;

package/src/NotificationPresenterModule.native.ts

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

package/src/NotificationPresenterModule.ts

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

package/src/NotificationPresenterModule.types.ts

@@ -0,0 +1,13 @@
+import { ProxyNativeModule } from 'expo-modules-core';
+
+import { Notification, NotificationContentInput } from './Notifications.types';
+
+export interface NotificationPresenterModule extends ProxyNativeModule {
+  getPresentedNotificationsAsync?: () => Promise<Notification[]>;
+  presentNotificationAsync?: (
+    identifier: string,
+    content: NotificationContentInput
+  ) => Promise<string>;
+  dismissNotificationAsync?: (identifier: string) => Promise<void>;
+  dismissAllNotificationsAsync?: () => Promise<void>;
+}

package/src/NotificationScheduler.kepler.ts

@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 2024 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * Use is subject to license terms.
+ */
+import { Platform, UnavailabilityError } from 'expo-modules-core';
+
+import {
+  NotificationSchedulerModule,
+  NotificationTriggerInput,
+} from './NotificationScheduler.types';
+import { NotificationContentInput } from './Notifications.types';
+import NativeNotificationManager from './kepler/native-notification-manager';
+import * as NotificationManagerTypes from './kepler/types/NotificationManagerTypes';
+import { stringifyNotificationUuid } from './utils/keplerUuidUtils';
+
+let warningHasBeenShown = false;
+
+const module: NotificationSchedulerModule = {
+  scheduleNotificationAsync: async (
+    identifier: string,
+    content: NotificationContentInput,
+    trigger: NotificationTriggerInput
+  ) => {
+    if (!warningHasBeenShown && trigger !== null) {
+      console.warn(
+        `[expo-notifications] ${Platform.OS} does not support custom notification triggers yet. The scheduled notification will be displayed immediately.`
+      );
+      warningHasBeenShown = true;
+    }
+
+    if (!content.title) {
+      throw new Error('Missing title');
+    } else if (!content.iconUri) {
+      throw new Error('Missing iconUri');
+    } else if (!content.subtitle) {
+      throw new Error('Missing description');
+    } else if (!content.channel) {
+      throw new Error('Missing channel');
+    }
+
+    let builder = new NotificationManagerTypes.NotificationContentBuilder()
+      .title(content.title)
+      .description(content.subtitle)
+      .iconUri(content.iconUri)
+      .channel(content.channel);
+    if (content.body) {
+      builder = builder.footnote(content.body);
+    }
+    const keplerContent = builder.build();
+    const uuid = await NativeNotificationManager.post(keplerContent);
+    return stringifyNotificationUuid(uuid);
+  },
+  getNextTriggerDateAsync: async (trigger: NotificationTriggerInput) => {
+    throw new UnavailabilityError('expo-notifications', 'getNextTriggerDateAsync');
+  },
+  addListener: () => {},
+  removeListeners: () => {},
+};
+
+export default module;

package/src/NotificationScheduler.native.ts

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

package/src/NotificationScheduler.ts

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

package/src/NotificationScheduler.types.ts

@@ -0,0 +1,89 @@
+import { ProxyNativeModule } from 'expo-modules-core';
+
+import { NotificationRequest, NotificationContentInput } from './Notifications.types';
+
+export interface NotificationSchedulerModule extends ProxyNativeModule {
+  getAllScheduledNotificationsAsync?: () => Promise<NotificationRequest[]>;
+  scheduleNotificationAsync?: (
+    identifier: string,
+    notificationContent: NotificationContentInput,
+    trigger: NotificationTriggerInput
+  ) => Promise<string>;
+  cancelScheduledNotificationAsync?: (identifier: string) => Promise<void>;
+  cancelAllScheduledNotificationsAsync?: () => Promise<void>;
+  getNextTriggerDateAsync?: (trigger: NotificationTriggerInput) => Promise<number>;
+}
+
+export interface ChannelAwareTriggerInput {
+  type: 'channel';
+  channelId?: string;
+}
+
+// ISO8601 calendar pattern-matching
+export interface CalendarTriggerInput {
+  type: 'calendar';
+  channelId?: string;
+  repeats?: boolean;
+  value: {
+    timezone?: string;
+
+    year?: number;
+    month?: number;
+    weekday?: number;
+    weekOfMonth?: number;
+    weekOfYear?: number;
+    weekdayOrdinal?: number;
+    day?: number;
+
+    hour?: number;
+    minute?: number;
+    second?: number;
+  };
+}
+
+export interface TimeIntervalTriggerInput {
+  type: 'timeInterval';
+  channelId?: string;
+  repeats: boolean;
+  seconds: number;
+}
+
+export interface DailyTriggerInput {
+  type: 'daily';
+  channelId?: string;
+  hour: number;
+  minute: number;
+}
+
+export interface WeeklyTriggerInput {
+  type: 'weekly';
+  channelId?: string;
+  weekday: number;
+  hour: number;
+  minute: number;
+}
+
+export interface YearlyTriggerInput {
+  type: 'yearly';
+  channelId?: string;
+  day: number;
+  month: number;
+  hour: number;
+  minute: number;
+}
+
+export interface DateTriggerInput {
+  type: 'date';
+  channelId?: string;
+  timestamp: number; // seconds since 1970
+}
+
+export type NotificationTriggerInput =
+  | null
+  | ChannelAwareTriggerInput
+  | DateTriggerInput
+  | CalendarTriggerInput
+  | TimeIntervalTriggerInput
+  | DailyTriggerInput
+  | WeeklyTriggerInput
+  | YearlyTriggerInput;