@aws-amplify/notifications 2.0.1-console-preview.8f82e46.0 → 2.0.1-console-preview.b278dcb.0

package/src/pushNotifications/providers/pinpoint/apis/identifyUser.native.ts

@@ -0,0 +1,36 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { PushNotificationAction } from '@aws-amplify/core/internals/utils';
+import { updateEndpoint } from '@aws-amplify/core/internals/providers/pinpoint';
+import { assertIsInitialized } from '../../../errors/errorHelpers';
+import { resolveConfig, resolveCredentials } from '../../../utils';
+import { getChannelType, getPushNotificationUserAgentString } from '../utils';
+import { IdentifyUser } from '../types';
+
+export const identifyUser: IdentifyUser = async ({
+	userId,
+	userProfile,
+	options,
+}) => {
+	assertIsInitialized();
+	const { credentials, identityId } = await resolveCredentials();
+	const { appId, region } = resolveConfig();
+	const { address, optOut, userAttributes } = options ?? {};
+	updateEndpoint({
+		address,
+		channelType: getChannelType(),
+		optOut,
+		appId,
+		category: 'PushNotification',
+		credentials,
+		identityId,
+		region,
+		userAttributes,
+		userId,
+		userProfile,
+		userAgentValue: getPushNotificationUserAgentString(
+			PushNotificationAction.IdentifyUser
+		),
+	});
+};

package/src/pushNotifications/providers/pinpoint/apis/identifyUser.ts

@@ -1,11 +1,62 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 
-import { UserInfo } from '../../../../types';
+import { UpdateEndpointException } from '@aws-amplify/core/internals/providers/pinpoint';
+import { PlatformNotSupportedError } from '@aws-amplify/core/internals/utils';
+import { PushNotificationValidationErrorCode } from '../../../errors';
+import { IdentifyUser, IdentifyUserInput } from '../types';
 
-export function identifyUser(
-	userId: string,
-	userInfo: UserInfo
-): Promise<void> {
-	throw new Error('WIP');
-}
+/**
+ * Sends information about a user to Pinpoint. Sending user information allows you to associate a user to their user
+ * profile and activities or actions in your application. Activity can be tracked across devices & platforms by using
+ * the same `userId`.
+ *
+ * @param {IdentifyUserInput} input The input object used to construct requests sent to Pinpoint's UpdateEndpoint
+ *  API.
+ * @throws service: {@link UpdateEndpointException} - Thrown when the underlying Pinpoint service returns an error.
+ * @throws validation: {@link PushNotificationValidationErrorCode} - Thrown when the provided parameters or library
+ *  configuration is incorrect.
+ * @throws platform: {@link PlatformNotSupportedError} - Thrown if called against an unsupported platform. Currently,
+ * only React Native is supported by this API.
+ * @returns A promise that will resolve when the operation is complete.
+ * @example
+ * ```ts
+ * // Identify a user with Pinpoint
+ * await identifyUser({
+ *     userId,
+ *     userProfile: {
+ *         email: 'userEmail@example.com'
+ *         customProperties: {
+ *             phoneNumber: ['555-555-5555'],
+ *         },
+ *     }
+ * });
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Identify a user with Pinpoint specific options
+ * await identifyUser({
+ *     userId,
+ *     userProfile: {
+ *         email: 'userEmail@example.com'
+ *         customProperties: {
+ *             phoneNumber: ['555-555-5555'],
+ *         },
+ *         demographic: {
+ *             platform: 'ios',
+ *             timezone: 'America/Los_Angeles'
+ *         }
+ *     },
+ *     options: {
+ *         address: 'device-address',
+ *         optOut: 'NONE',
+ *         userAttributes: {
+ *             interests: ['food']
+ *         },
+ *     },
+ * });
+ */
+export const identifyUser: IdentifyUser = () => {
+	throw new PlatformNotSupportedError();
+};

package/src/pushNotifications/providers/pinpoint/apis/index.ts

@@ -1,4 +1,14 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 
+export { getBadgeCount } from './getBadgeCount';
+export { getLaunchNotification } from './getLaunchNotification';
+export { getPermissionStatus } from './getPermissionStatus';
 export { identifyUser } from './identifyUser';
+export { initializePushNotifications } from './initializePushNotifications';
+export { onNotificationOpened } from './onNotificationOpened';
+export { onNotificationReceivedInBackground } from './onNotificationReceivedInBackground';
+export { onNotificationReceivedInForeground } from './onNotificationReceivedInForeground';
+export { onTokenReceived } from './onTokenReceived';
+export { requestPermissions } from './requestPermissions';
+export { setBadgeCount } from './setBadgeCount';

package/src/pushNotifications/providers/pinpoint/apis/initializePushNotifications.native.ts

@@ -0,0 +1,199 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { ConsoleLogger } from '@aws-amplify/core';
+import { PushNotificationAction } from '@aws-amplify/core/internals/utils';
+import { updateEndpoint } from '@aws-amplify/core/internals/providers/pinpoint';
+import { loadAmplifyPushNotification } from '@aws-amplify/react-native';
+import {
+	EventListenerRemover,
+	addEventListener,
+	notifyEventListeners,
+	notifyEventListenersAndAwaitHandlers,
+} from '../../../../eventListeners';
+import {
+	getToken,
+	initialize,
+	isInitialized,
+	resolveConfig,
+	resolveCredentials,
+	setToken,
+} from '../../../utils';
+import {
+	createMessageEventRecorder,
+	getChannelType,
+	getPushNotificationUserAgentString,
+} from '../utils';
+
+const {
+	addMessageEventListener,
+	addTokenEventListener,
+	completeNotification,
+	getConstants,
+	registerHeadlessTask,
+} = loadAmplifyPushNotification();
+
+const logger = new ConsoleLogger('Notifications.PushNotification');
+
+const BACKGROUND_TASK_TIMEOUT = 25; // seconds
+
+export const initializePushNotifications = (): Promise<void> => {
+	if (isInitialized()) {
+		logger.info('Push notifications have already been enabled');
+		return;
+	}
+	addNativeListeners();
+	addAnalyticsListeners();
+	initialize();
+};
+
+const addAnalyticsListeners = (): void => {
+	let launchNotificationOpenedListenerRemover: EventListenerRemover;
+
+	// wire up default Pinpoint message event handling
+	addEventListener(
+		'backgroundMessageReceived',
+		createMessageEventRecorder('backgroundMessageReceived')
+	);
+	addEventListener(
+		'foregroundMessageReceived',
+		createMessageEventRecorder('foregroundMessageReceived')
+	);
+	launchNotificationOpenedListenerRemover = addEventListener(
+		'launchNotificationsOpened',
+		createMessageEventRecorder(
+			'notificationOpened',
+			// once we are done with it we can remove the listener
+			launchNotificationOpenedListenerRemover?.remove
+		)
+	);
+	addEventListener(
+		'notificationOpened',
+		createMessageEventRecorder(
+			'notificationOpened',
+			// if we are in this state, we no longer need the listener as the app was launched via some other means
+			launchNotificationOpenedListenerRemover?.remove
+		)
+	);
+};
+
+const addNativeListeners = (): void => {
+	const { NativeEvent, NativeHeadlessTaskKey } = getConstants();
+	const {
+		BACKGROUND_MESSAGE_RECEIVED,
+		FOREGROUND_MESSAGE_RECEIVED,
+		LAUNCH_NOTIFICATION_OPENED,
+		NOTIFICATION_OPENED,
+		TOKEN_RECEIVED,
+	} = NativeEvent;
+	// on platforms that can handle headless tasks, register one to broadcast background message received to
+	// library listeners
+	if (NativeHeadlessTaskKey) {
+		registerHeadlessTask(async message => {
+			// keep headless task running until handlers have completed their work
+			await notifyEventListenersAndAwaitHandlers(
+				'backgroundMessageReceived',
+				message
+			);
+		});
+	} else if (BACKGROUND_MESSAGE_RECEIVED) {
+		// on platforms that can't handle headless tasks, listen for native background message received event and
+		// broadcast to library listeners
+		addMessageEventListener(
+			BACKGROUND_MESSAGE_RECEIVED,
+			async (message, completionHandlerId) => {
+				// keep background task running until handlers have completed their work
+				try {
+					await Promise.race([
+						notifyEventListenersAndAwaitHandlers(
+							'backgroundMessageReceived',
+							message
+						),
+						// background tasks will get suspended and all future tasks be deprioritized by the OS if they run for
+						// more than 30 seconds so we reject with a error in a shorter amount of time to prevent this from
+						// happening
+						new Promise((_, reject) => {
+							setTimeout(
+								() =>
+									reject(
+										`onNotificationReceivedInBackground handlers should complete their work within ${BACKGROUND_TASK_TIMEOUT} seconds, but they did not.`
+									),
+								BACKGROUND_TASK_TIMEOUT * 1000
+							);
+						}),
+					]);
+				} catch (err) {
+					logger.error(err);
+				} finally {
+					// notify native module that handlers have completed their work (or timed out)
+					completeNotification(completionHandlerId);
+				}
+			}
+		);
+	}
+
+	addMessageEventListener(
+		// listen for native foreground message received event and broadcast to library listeners
+		FOREGROUND_MESSAGE_RECEIVED,
+		message => {
+			notifyEventListeners('foregroundMessageReceived', message);
+		}
+	);
+
+	const launchNotificationOpenedListener = LAUNCH_NOTIFICATION_OPENED
+		? addMessageEventListener(
+				// listen for native notification opened app (user tapped on notification, opening the app from quit -
+				// not background - state) event. This is broadcasted to an internal listener only as it is not intended
+				// for use otherwise as it produces inconsistent results when used within React Native app context
+				LAUNCH_NOTIFICATION_OPENED,
+				message => {
+					notifyEventListeners('launchNotificationsOpened', message);
+					// once we are done with it we can remove the listener
+					launchNotificationOpenedListener?.remove();
+				}
+		  )
+		: null;
+
+	addMessageEventListener(
+		// listen for native notification opened (user tapped on notification, opening the app from background -
+		// not quit - state) event and broadcast to library listeners
+		NOTIFICATION_OPENED,
+		message => {
+			notifyEventListeners('notificationOpened', message);
+			// if we are in this state, we no longer need the listener as the app was launched via some other means
+			launchNotificationOpenedListener?.remove();
+		}
+	);
+
+	addTokenEventListener(
+		// listen for native new token event, automatically re-register device with provider using new token and
+		// broadcast to library listeners
+		TOKEN_RECEIVED,
+		token => {
+			// avoid a race condition where two endpoints are created with the same token on a fresh install
+			if (getToken() === token) {
+				return;
+			}
+			setToken(token);
+			registerDevice();
+			notifyEventListeners('tokenReceived', token);
+		}
+	);
+};
+
+const registerDevice = async (): Promise<void> => {
+	const { credentials, identityId } = await resolveCredentials();
+	const { appId, region } = resolveConfig();
+	return updateEndpoint({
+		address: getToken(),
+		appId,
+		category: 'PushNotification',
+		credentials,
+		region,
+		channelType: getChannelType(),
+		identityId,
+		userAgentValue: getPushNotificationUserAgentString(
+			PushNotificationAction.InitializePushNotifications
+		),
+	});
+};

package/src/pushNotifications/providers/pinpoint/apis/initializePushNotifications.ts

@@ -0,0 +1,24 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { PlatformNotSupportedError } from '@aws-amplify/core/internals/utils';
+import { InitializePushNotifications } from '../types';
+
+/**
+ * Initialize and set up the push notification category. The category must be first initialized before all other
+ * functionalities become available.
+ *
+ * @throws platform: {@link PlatformNotSupportedError} - Thrown if called against an unsupported platform. Currently,
+ * only React Native is supported by this API.
+ * @remarks
+ * It is recommended that this be called as early in your app as possible at the root of your application to allow
+ * background processing of notifications.
+ * @example
+ * ```ts
+ * Amplify.configure(config);
+ * initializePushNotifications();
+ * ```
+ */
+export const initializePushNotifications: InitializePushNotifications = () => {
+	throw new PlatformNotSupportedError();
+};

package/src/pushNotifications/providers/pinpoint/apis/onNotificationOpened.native.ts

@@ -0,0 +1,11 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { addEventListener } from '../../../../eventListeners';
+import { assertIsInitialized } from '../../../errors/errorHelpers';
+import { OnNotificationOpened } from '../types';
+
+export const onNotificationOpened: OnNotificationOpened = input => {
+	assertIsInitialized();
+	return addEventListener('notificationOpened', input);
+};

package/src/pushNotifications/providers/pinpoint/apis/onNotificationOpened.ts

@@ -0,0 +1,39 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { PlatformNotSupportedError } from '@aws-amplify/core/internals/utils';
+import { PushNotificationMessage } from '../../../types';
+import {
+	OnNotificationOpened,
+	OnNotificationOpenedInput,
+	OnNotificationOpenedOutput,
+} from '../types';
+
+/**
+ * Registers a listener that will be triggered when a notification is opened by user.
+ *
+ * @param {OnNotificationOpenedInput} input - A callback handler to be invoked with the opened
+ * {@link PushNotificationMessage}.
+ * @returns {OnNotificationOpenedOutput} - An object with a remove function to remove the listener.
+ * @example
+ * ```ts
+ * // Register a listener
+ * onNotificationOpened(message => {
+ *   doSomething(message);
+ * });
+ * ```
+ * @example
+ * ```ts
+ * // Register multiple listeners
+ * onNotificationOpened(message => {
+ *   doSomething(message);
+ * });
+ *
+ * onNotificationOpened(message => {
+ *   doSomethingElse(message);
+ * });
+ * ```
+ */
+export const onNotificationOpened: OnNotificationOpened = () => {
+	throw new PlatformNotSupportedError();
+};

package/src/pushNotifications/providers/pinpoint/apis/onNotificationReceivedInBackground.native.ts

@@ -0,0 +1,12 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { addEventListener } from '../../../../eventListeners';
+import { assertIsInitialized } from '../../../errors/errorHelpers';
+import { OnNotificationReceivedInBackground } from '../types';
+
+export const onNotificationReceivedInBackground: OnNotificationReceivedInBackground =
+	input => {
+		assertIsInitialized();
+		return addEventListener('backgroundMessageReceived', input);
+	};

package/src/pushNotifications/providers/pinpoint/apis/onNotificationReceivedInBackground.ts

@@ -0,0 +1,56 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { PlatformNotSupportedError } from '@aws-amplify/core/internals/utils';
+import { PushNotificationMessage } from '../../../types';
+import {
+	OnNotificationReceivedInBackground,
+	OnNotificationReceivedInBackgroundInput,
+	OnNotificationReceivedInBackgroundOutput,
+} from '../types';
+
+/**
+ * Registers a listener that will be triggered when a notification is received while app is in a background state.
+ *
+ * @throws platform: {@link PlatformNotSupportedError} - Thrown if called against an unsupported platform. Currently,
+ * only React Native is supported by this API.
+ * @param {OnNotificationReceivedInBackgroundInput} input - A callback handler to be invoked with the received
+ * {@link PushNotificationMessage}.
+ * @returns {OnNotificationReceivedInBackgroundOutput} - An object with a remove function to remove the listener.
+ * @remarks Notifications received while app is in a quit state will start the app (as a headless JS instance running
+ * on a background service on Android) in the background. Handlers registered via this function should return promises
+ * if it needs to be asynchronous (e.g. to perform some network requests). The app should run in the background as long
+ * as there are handlers still running (however, if they run for more than 30 seconds on iOS, subsequent tasks could
+ * get deprioritized!). If it is necessary for a handler to execute while the app is in quit state, it should be
+ * registered in the application entry point (e.g. index.js) since the application will not fully mount in that case.
+ * @example
+ * ```ts
+ * // Register a listener
+ * onNotificationReceivedInBackground(message => {
+ *   doSomething(message);
+ * });
+ * ```
+ * @example
+ * ```ts
+ * // Register multiple listeners
+ * onNotificationReceivedInBackground(message => {
+ *   doSomething(message);
+ * });
+ *
+ * onNotificationReceivedInBackground(message => {
+ *   doSomethingElse(message);
+ * });
+ * ```
+ * @example
+ * ```ts
+ * // Register async listener
+ * onNotificationReceivedInBackground(async message => {
+ *   await doSomething(message);
+ *   console.log(`did something with ${message}`);
+ * });
+ * ```
+ */
+export const onNotificationReceivedInBackground: OnNotificationReceivedInBackground =
+	() => {
+		throw new PlatformNotSupportedError();
+	};

package/src/pushNotifications/providers/pinpoint/apis/onNotificationReceivedInForeground.native.ts

@@ -0,0 +1,12 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { addEventListener } from '../../../../eventListeners';
+import { assertIsInitialized } from '../../../errors/errorHelpers';
+import { OnNotificationReceivedInForeground } from '../types';
+
+export const onNotificationReceivedInForeground: OnNotificationReceivedInForeground =
+	input => {
+		assertIsInitialized();
+		return addEventListener('foregroundMessageReceived', input);
+	};

package/src/pushNotifications/providers/pinpoint/apis/onNotificationReceivedInForeground.ts

@@ -0,0 +1,40 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { PlatformNotSupportedError } from '@aws-amplify/core/internals/utils';
+import { PushNotificationMessage } from '../../../types';
+import {
+	OnNotificationReceivedInForeground,
+	OnNotificationReceivedInForegroundInput,
+	OnNotificationReceivedInForegroundOutput,
+} from '../types';
+
+/**
+ * Registers a listener that will be triggered when a notification is received while app is in a foreground state.
+ *
+ * @param {OnNotificationReceivedInForegroundInput} input - A callback handler to be invoked with the received
+ * {@link PushNotificationMessage}.
+ * @returns {OnNotificationReceivedInForegroundOutput} - An object with a remove function to remove the listener.
+ * @example
+ * ```ts
+ * // Register a listener
+ * onNotificationReceivedInForeground(message => {
+ *   doSomething(message);
+ * });
+ * ```
+ * @example
+ * ```ts
+ * // Register multiple listeners
+ * onNotificationReceivedInForeground(message => {
+ *   doSomething(message);
+ * });
+ *
+ * onNotificationReceivedInForeground(message => {
+ *   doSomethingElse(message);
+ * });
+ * ```
+ */
+export const onNotificationReceivedInForeground: OnNotificationReceivedInForeground =
+	() => {
+		throw new PlatformNotSupportedError();
+	};

package/src/pushNotifications/providers/pinpoint/apis/onTokenReceived.native.ts

@@ -0,0 +1,11 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { addEventListener } from '../../../../eventListeners';
+import { assertIsInitialized } from '../../../errors/errorHelpers';
+import { OnTokenReceived } from '../types';
+
+export const onTokenReceived: OnTokenReceived = input => {
+	assertIsInitialized();
+	return addEventListener('tokenReceived', input);
+};

package/src/pushNotifications/providers/pinpoint/apis/onTokenReceived.ts

@@ -0,0 +1,39 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { PlatformNotSupportedError } from '@aws-amplify/core/internals/utils';
+import {
+	OnTokenReceived,
+	OnTokenReceivedInput,
+	OnTokenReceivedOutput,
+} from '../types';
+
+/**
+ * Registers a listener that will be triggered when a token is received. A token will be received:
+ *   1. On every app launch, including the first install
+ *   2. When a token changes (this may happen if the service invalidates the token for any reason)
+ *
+ * @param {OnTokenReceivedInput} input - A callback handler to be invoked with the token.
+ * @returns {OnTokenReceivedOutput} - An object with a remove function to remove the listener.
+ * @example
+ * ```ts
+ * // Register a listener
+ * onTokenReceived(message => {
+ *   doSomething(message);
+ * });
+ * ```
+ * @example
+ * ```ts
+ * // Register multiple listeners
+ * onTokenReceived(message => {
+ *   doSomething(message);
+ * });
+ *
+ * onTokenReceived(message => {
+ *   doSomethingElse(message);
+ * });
+ * ```
+ */
+export const onTokenReceived: OnTokenReceived = () => {
+	throw new PlatformNotSupportedError();
+};

package/src/pushNotifications/providers/pinpoint/apis/requestPermissions.native.ts

@@ -0,0 +1,14 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { loadAmplifyPushNotification } from '@aws-amplify/react-native';
+import { assertIsInitialized } from '../../../errors/errorHelpers';
+import { RequestPermissions } from '../types';
+
+const { requestPermissions: requestPermissionsNative } =
+	loadAmplifyPushNotification();
+
+export const requestPermissions: RequestPermissions = input => {
+	assertIsInitialized();
+	return requestPermissionsNative(input);
+};

package/src/pushNotifications/providers/pinpoint/apis/requestPermissions.ts

@@ -0,0 +1,39 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { PlatformNotSupportedError } from '@aws-amplify/core/internals/utils';
+import { RequestPermissions } from '../types';
+
+/**
+ * Requests notification permissions from your user. By default, Amplify requests all supported permissions but you can
+ * choose not to request specific permissions. The resulting promise will resolve to true if requested permissions are
+ * granted (or have previously been granted) or false otherwise. Not all specific permissions are supported by platforms
+ * your React Native app can run on but will be safely ignored even on those platforms. Currently supported permissions:
+ *
+ *   * `alert`: When set to true, requests the ability to display notifications to the user.
+ *
+ *   * `sound`: When set to true, requests the ability to play a sound in response to notifications.
+ *
+ *   * `badge`: When set to true, requests the ability to update the app's badge.
+ *
+ * @throws platform: {@link PlatformNotSupportedError} - Thrown if called against an unsupported platform. Currently,
+ * only React Native is supported by this API.
+ * @returns A promise that resolves to true if requested permissions are granted or have already previously been
+ * granted or false otherwise.
+ * @example
+ * ```ts
+ * // Request all permissions by default
+ * const arePermissionsGranted = await requestPermissions();
+ *
+ * @example
+ * ```ts
+ * // Prevent requesting specific permissions
+ * const arePermissionsGranted = await requestPermissions({
+ *   sound: false,
+ *   badge: false
+ * });
+ * ```
+ */
+export const requestPermissions: RequestPermissions = () => {
+	throw new PlatformNotSupportedError();
+};

package/src/pushNotifications/providers/pinpoint/apis/setBadgeCount.native.ts

@@ -0,0 +1,13 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { loadAmplifyPushNotification } from '@aws-amplify/react-native';
+import { assertIsInitialized } from '../../../errors/errorHelpers';
+import { SetBadgeCount } from '../types';
+
+const { setBadgeCount: setBadgeCountNative } = loadAmplifyPushNotification();
+
+export const setBadgeCount: SetBadgeCount = input => {
+	assertIsInitialized();
+	setBadgeCountNative(input);
+};

package/src/pushNotifications/providers/pinpoint/apis/setBadgeCount.ts

@@ -0,0 +1,21 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { PlatformNotSupportedError } from '@aws-amplify/core/internals/utils';
+import { SetBadgeCount } from '../types';
+
+/**
+ * Sets the current badge count (the number on the top right corner of your app's icon). Setting the badge count
+ * to 0 (zero) will remove the badge from your app's icon. This function is safe to call (but will be ignored) even
+ * when your React Native app is running on platforms where badges are not supported.
+ *
+ * @throws platform: {@link PlatformNotSupportedError} - Thrown if called against an unsupported platform. Currently,
+ * only React Native is supported by this API.
+ * @example
+ * ```ts
+ * setBadgeCount(42);
+ * ```
+ */
+export const setBadgeCount: SetBadgeCount = () => {
+	throw new PlatformNotSupportedError();
+};