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

package/lib-esm/pushNotifications/errors/errorHelpers.js

@@ -0,0 +1,32 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+var _a;
+import { createAssertionFunction, } from '@aws-amplify/core/internals/utils';
+import { isInitialized } from '../utils';
+import { PushNotificationError } from './PushNotificationError';
+export var PushNotificationValidationErrorCode;
+(function (PushNotificationValidationErrorCode) {
+    PushNotificationValidationErrorCode["NoAppId"] = "NoAppId";
+    PushNotificationValidationErrorCode["NoCredentials"] = "NoCredentials";
+    PushNotificationValidationErrorCode["NoRegion"] = "NoRegion";
+    PushNotificationValidationErrorCode["NotInitialized"] = "NotInitialized";
+})(PushNotificationValidationErrorCode || (PushNotificationValidationErrorCode = {}));
+var pushNotificationValidationErrorMap = (_a = {},
+    _a[PushNotificationValidationErrorCode.NoAppId] = {
+        message: 'Missing application id.',
+    },
+    _a[PushNotificationValidationErrorCode.NoCredentials] = {
+        message: 'Credentials should not be empty.',
+    },
+    _a[PushNotificationValidationErrorCode.NoRegion] = {
+        message: 'Missing region.',
+    },
+    _a[PushNotificationValidationErrorCode.NotInitialized] = {
+        message: 'Push notification has not been initialized.',
+        recoverySuggestion: 'Please make sure to first call `initializePushNotifications`.',
+    },
+    _a);
+export var assert = createAssertionFunction(pushNotificationValidationErrorMap, PushNotificationError);
+export var assertIsInitialized = function () {
+    assert(isInitialized(), PushNotificationValidationErrorCode.NotInitialized);
+};

package/lib-esm/pushNotifications/errors/index.d.ts

@@ -0,0 +1,2 @@
+export { PushNotificationError } from './PushNotificationError';
+export { assert, PushNotificationValidationErrorCode } from './errorHelpers';

package/lib-esm/pushNotifications/errors/index.js

@@ -0,0 +1,4 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+export { PushNotificationError } from './PushNotificationError';
+export { assert, PushNotificationValidationErrorCode } from './errorHelpers';

package/lib-esm/pushNotifications/index.d.ts

@@ -1,2 +1,3 @@
-export { identifyUser } from './providers/pinpoint';
-export { PushNotificationEvent, PushNotificationMessage, PushNotificationPermissionStatus, } from './types';
+export { getBadgeCount, getLaunchNotification, GetLaunchNotificationOutput, getPermissionStatus, GetPermissionStatusOutput, identifyUser, IdentifyUserInput, initializePushNotifications, onNotificationOpened, OnNotificationOpenedInput, OnNotificationOpenedOutput, onNotificationReceivedInBackground, OnNotificationReceivedInBackgroundInput, OnNotificationReceivedInBackgroundOutput, onNotificationReceivedInForeground, OnNotificationReceivedInForegroundInput, OnNotificationReceivedInForegroundOutput, onTokenReceived, OnTokenReceivedInput, OnTokenReceivedOutput, requestPermissions, RequestPermissionsInput, setBadgeCount, SetBadgeCountInput, } from './providers/pinpoint';
+export { PushNotificationMessage } from './types';
+export { PushNotificationError } from './errors';

package/lib-esm/pushNotifications/index.js

@@ -1,5 +1,4 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
-export { identifyUser } from './providers/pinpoint';
-export { PushNotificationPermissionStatus, } from './types';
-//# sourceMappingURL=index.js.map
+export { getBadgeCount, getLaunchNotification, getPermissionStatus, identifyUser, initializePushNotifications, onNotificationOpened, onNotificationReceivedInBackground, onNotificationReceivedInForeground, onTokenReceived, requestPermissions, setBadgeCount, } from './providers/pinpoint';
+export { PushNotificationError } from './errors';

package/lib-esm/pushNotifications/providers/pinpoint/apis/getBadgeCount.d.ts

@@ -0,0 +1,14 @@
+import { GetBadgeCount } from '../types';
+/**
+ * Returns the current badge count (the number next to 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.
+ * @returns A promise that resolves to a number representing the current count displayed on the app badge.
+ * @example
+ * ```ts
+ * const badgeCount = await getBadgeCount();
+ * ```
+ */
+export declare const getBadgeCount: GetBadgeCount;

package/lib-esm/pushNotifications/providers/pinpoint/apis/getBadgeCount.js

@@ -0,0 +1,18 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { PlatformNotSupportedError } from '@aws-amplify/core/internals/utils';
+/**
+ * Returns the current badge count (the number next to 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.
+ * @returns A promise that resolves to a number representing the current count displayed on the app badge.
+ * @example
+ * ```ts
+ * const badgeCount = await getBadgeCount();
+ * ```
+ */
+export var getBadgeCount = function () {
+    throw new PlatformNotSupportedError();
+};

package/lib-esm/pushNotifications/providers/pinpoint/apis/getBadgeCount.native.d.ts

@@ -0,0 +1,2 @@
+import { GetBadgeCount } from '../types';
+export declare const getBadgeCount: GetBadgeCount;

package/lib-esm/pushNotifications/providers/pinpoint/apis/getBadgeCount.native.js

@@ -0,0 +1,12 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { __awaiter, __generator } from "tslib";
+import { loadAmplifyPushNotification } from '@aws-amplify/react-native';
+import { assertIsInitialized } from '../../../errors/errorHelpers';
+var getBadgeCountNative = loadAmplifyPushNotification().getBadgeCount;
+export var getBadgeCount = function () { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        assertIsInitialized();
+        return [2 /*return*/, getBadgeCountNative()];
+    });
+}); };

package/lib-esm/pushNotifications/providers/pinpoint/apis/getLaunchNotification.d.ts

@@ -0,0 +1,18 @@
+import { GetLaunchNotification } from '../types';
+/**
+ * Returns the notification which launched your app from a terminated state. The launch notification is consumed by
+ * calls to this function and will yield a null result if:
+ *   1. It is more than once (i.e. subsequent calls will be null)
+ *   2. Another notification was opened while your app was running (either in foreground or background)
+ *   3. Your app was brought back to the foreground by some other means (e.g. user tapped the app icon)
+ *
+ * @throws platform: {@link PlatformNotSupportedError} - Thrown if called against an unsupported platform. Currently,
+ * only React Native is supported by this API.
+ * @returns {Promise<GetLaunchNotificationOutput>} - a promise resolving to {@link PushNotificationMessage} if there is
+ * a launch notification and `null` otherwise.
+ * @example
+ * ```ts
+ * const launchNotification = await getLaunchNotification();
+ * ```
+ */
+export declare const getLaunchNotification: GetLaunchNotification;

package/lib-esm/pushNotifications/providers/pinpoint/apis/getLaunchNotification.js

@@ -0,0 +1,22 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { PlatformNotSupportedError } from '@aws-amplify/core/internals/utils';
+/**
+ * Returns the notification which launched your app from a terminated state. The launch notification is consumed by
+ * calls to this function and will yield a null result if:
+ *   1. It is more than once (i.e. subsequent calls will be null)
+ *   2. Another notification was opened while your app was running (either in foreground or background)
+ *   3. Your app was brought back to the foreground by some other means (e.g. user tapped the app icon)
+ *
+ * @throws platform: {@link PlatformNotSupportedError} - Thrown if called against an unsupported platform. Currently,
+ * only React Native is supported by this API.
+ * @returns {Promise<GetLaunchNotificationOutput>} - a promise resolving to {@link PushNotificationMessage} if there is
+ * a launch notification and `null` otherwise.
+ * @example
+ * ```ts
+ * const launchNotification = await getLaunchNotification();
+ * ```
+ */
+export var getLaunchNotification = function () {
+    throw new PlatformNotSupportedError();
+};

package/lib-esm/pushNotifications/providers/pinpoint/apis/getLaunchNotification.native.d.ts

@@ -0,0 +1,2 @@
+import { GetLaunchNotification } from '../types';
+export declare const getLaunchNotification: GetLaunchNotification;

package/lib-esm/pushNotifications/providers/pinpoint/apis/getLaunchNotification.native.js

@@ -0,0 +1,9 @@
+// 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';
+var getLaunchNotificationNative = loadAmplifyPushNotification().getLaunchNotification;
+export var getLaunchNotification = function () {
+    assertIsInitialized();
+    return getLaunchNotificationNative();
+};

package/lib-esm/pushNotifications/providers/pinpoint/apis/getPermissionStatus.d.ts

@@ -0,0 +1,27 @@
+import { GetPermissionStatus } from '../types';
+/**
+ * Returns a string representing the current status of user permissions to display push notifications. The possible
+ * statuses are as follows:
+ *
+ *   * `'shouldRequest'` - No permissions have been requested yet. It is idiomatic at this time to simply request for
+ *   permissions from the user.
+ *
+ *   * `'shouldExplainThenRequest'` - It is recommended at this time to provide some context or rationale to the user
+ *   explaining why you want to send them push notifications before requesting for permissions.
+ *
+ *   * `'granted'` - Permissions have been granted by the user. No further actions are needed and their app is ready to
+ *   display notifications.
+ *
+ *   * `'denied'` - Permissions have been denied by the user. Further attempts to request permissions will no longer
+ *   trigger a permission dialog. Your app should now either degrade gracefully or prompt your user to grant the
+ *   permissions needed in their device settings.
+ *
+ * @throws platform: {@link PlatformNotSupportedError} - Thrown if called against an unsupported platform. Currently,
+ * only React Native is supported by this API.
+ * @return {Promise<GetPermissionStatusOutput>} a promise resolving to a string representing the current status of user
+ * selected notification permissions.
+ * @example
+ * ```ts
+ * const permissionStatus = await getPermissionStatus();
+ */
+export declare const getPermissionStatus: GetPermissionStatus;

package/lib-esm/pushNotifications/providers/pinpoint/apis/getPermissionStatus.js

@@ -0,0 +1,31 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { PlatformNotSupportedError } from '@aws-amplify/core/internals/utils';
+/**
+ * Returns a string representing the current status of user permissions to display push notifications. The possible
+ * statuses are as follows:
+ *
+ *   * `'shouldRequest'` - No permissions have been requested yet. It is idiomatic at this time to simply request for
+ *   permissions from the user.
+ *
+ *   * `'shouldExplainThenRequest'` - It is recommended at this time to provide some context or rationale to the user
+ *   explaining why you want to send them push notifications before requesting for permissions.
+ *
+ *   * `'granted'` - Permissions have been granted by the user. No further actions are needed and their app is ready to
+ *   display notifications.
+ *
+ *   * `'denied'` - Permissions have been denied by the user. Further attempts to request permissions will no longer
+ *   trigger a permission dialog. Your app should now either degrade gracefully or prompt your user to grant the
+ *   permissions needed in their device settings.
+ *
+ * @throws platform: {@link PlatformNotSupportedError} - Thrown if called against an unsupported platform. Currently,
+ * only React Native is supported by this API.
+ * @return {Promise<GetPermissionStatusOutput>} a promise resolving to a string representing the current status of user
+ * selected notification permissions.
+ * @example
+ * ```ts
+ * const permissionStatus = await getPermissionStatus();
+ */
+export var getPermissionStatus = function () {
+    throw new PlatformNotSupportedError();
+};

package/lib-esm/pushNotifications/providers/pinpoint/apis/getPermissionStatus.native.d.ts

@@ -0,0 +1,2 @@
+import { GetPermissionStatus } from '../types';
+export declare const getPermissionStatus: GetPermissionStatus;

package/lib-esm/pushNotifications/providers/pinpoint/apis/getPermissionStatus.native.js

@@ -0,0 +1,9 @@
+// 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';
+var getPermissionStatusNative = loadAmplifyPushNotification().getPermissionStatus;
+export var getPermissionStatus = function () {
+    assertIsInitialized();
+    return getPermissionStatusNative();
+};

package/lib-esm/pushNotifications/providers/pinpoint/apis/identifyUser.d.ts

@@ -1,2 +1,53 @@
-import { UserInfo } from '../../../../types';
-export declare function identifyUser(userId: string, userInfo: UserInfo): Promise<void>;
+import { IdentifyUser } from '../types';
+/**
+ * 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 declare const identifyUser: IdentifyUser;

package/lib-esm/pushNotifications/providers/pinpoint/apis/identifyUser.js

@@ -1,6 +1,57 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
-export function identifyUser(userId, userInfo) {
-    throw new Error('WIP');
-}
-//# sourceMappingURL=identifyUser.js.map
+import { PlatformNotSupportedError } from '@aws-amplify/core/internals/utils';
+/**
+ * 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 var identifyUser = function () {
+    throw new PlatformNotSupportedError();
+};

package/lib-esm/pushNotifications/providers/pinpoint/apis/identifyUser.native.d.ts

@@ -0,0 +1,2 @@
+import { IdentifyUser } from '../types';
+export declare const identifyUser: IdentifyUser;

package/lib-esm/pushNotifications/providers/pinpoint/apis/identifyUser.native.js

@@ -0,0 +1,40 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { __awaiter, __generator } from "tslib";
+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';
+export var identifyUser = function (_a) {
+    var userId = _a.userId, userProfile = _a.userProfile, options = _a.options;
+    return __awaiter(void 0, void 0, void 0, function () {
+        var _b, credentials, identityId, _c, appId, region, _d, address, optOut, userAttributes;
+        return __generator(this, function (_e) {
+            switch (_e.label) {
+                case 0:
+                    assertIsInitialized();
+                    return [4 /*yield*/, resolveCredentials()];
+                case 1:
+                    _b = _e.sent(), credentials = _b.credentials, identityId = _b.identityId;
+                    _c = resolveConfig(), appId = _c.appId, region = _c.region;
+                    _d = options !== null && options !== void 0 ? options : {}, address = _d.address, optOut = _d.optOut, userAttributes = _d.userAttributes;
+                    updateEndpoint({
+                        address: address,
+                        channelType: getChannelType(),
+                        optOut: optOut,
+                        appId: appId,
+                        category: 'PushNotification',
+                        credentials: credentials,
+                        identityId: identityId,
+                        region: region,
+                        userAttributes: userAttributes,
+                        userId: userId,
+                        userProfile: userProfile,
+                        userAgentValue: getPushNotificationUserAgentString(PushNotificationAction.IdentifyUser),
+                    });
+                    return [2 /*return*/];
+            }
+        });
+    });
+};

package/lib-esm/pushNotifications/providers/pinpoint/apis/index.d.ts

@@ -1 +1,11 @@
+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/lib-esm/pushNotifications/providers/pinpoint/apis/index.js

@@ -1,4 +1,13 @@
 // 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';
-//# sourceMappingURL=index.js.map
+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/lib-esm/pushNotifications/providers/pinpoint/apis/initializePushNotifications.d.ts

@@ -0,0 +1,17 @@
+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 declare const initializePushNotifications: InitializePushNotifications;

package/lib-esm/pushNotifications/providers/pinpoint/apis/initializePushNotifications.js

@@ -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';
+/**
+ * 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 var initializePushNotifications = function () {
+    throw new PlatformNotSupportedError();
+};

package/lib-esm/pushNotifications/providers/pinpoint/apis/initializePushNotifications.native.d.ts

@@ -0,0 +1 @@
+export declare const initializePushNotifications: () => Promise<void>;

package/lib-esm/pushNotifications/providers/pinpoint/apis/initializePushNotifications.native.js

@@ -0,0 +1,156 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { __awaiter, __generator } from "tslib";
+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 { addEventListener, notifyEventListeners, notifyEventListenersAndAwaitHandlers, } from '../../../../eventListeners';
+import { getToken, initialize, isInitialized, resolveConfig, resolveCredentials, setToken, } from '../../../utils';
+import { createMessageEventRecorder, getChannelType, getPushNotificationUserAgentString, } from '../utils';
+var _a = loadAmplifyPushNotification(), addMessageEventListener = _a.addMessageEventListener, addTokenEventListener = _a.addTokenEventListener, completeNotification = _a.completeNotification, getConstants = _a.getConstants, registerHeadlessTask = _a.registerHeadlessTask;
+var logger = new ConsoleLogger('Notifications.PushNotification');
+var BACKGROUND_TASK_TIMEOUT = 25; // seconds
+export var initializePushNotifications = function () {
+    if (isInitialized()) {
+        logger.info('Push notifications have already been enabled');
+        return;
+    }
+    addNativeListeners();
+    addAnalyticsListeners();
+    initialize();
+};
+var addAnalyticsListeners = function () {
+    var launchNotificationOpenedListenerRemover;
+    // 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 === null || 
+    // once we are done with it we can remove the listener
+    launchNotificationOpenedListenerRemover === void 0 ? void 0 : 
+    // 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 === null || 
+    // if we are in this state, we no longer need the listener as the app was launched via some other means
+    launchNotificationOpenedListenerRemover === void 0 ? void 0 : 
+    // if we are in this state, we no longer need the listener as the app was launched via some other means
+    launchNotificationOpenedListenerRemover.remove));
+};
+var addNativeListeners = function () {
+    var _a = getConstants(), NativeEvent = _a.NativeEvent, NativeHeadlessTaskKey = _a.NativeHeadlessTaskKey;
+    var BACKGROUND_MESSAGE_RECEIVED = NativeEvent.BACKGROUND_MESSAGE_RECEIVED, FOREGROUND_MESSAGE_RECEIVED = NativeEvent.FOREGROUND_MESSAGE_RECEIVED, LAUNCH_NOTIFICATION_OPENED = NativeEvent.LAUNCH_NOTIFICATION_OPENED, NOTIFICATION_OPENED = NativeEvent.NOTIFICATION_OPENED, TOKEN_RECEIVED = NativeEvent.TOKEN_RECEIVED;
+    // on platforms that can handle headless tasks, register one to broadcast background message received to
+    // library listeners
+    if (NativeHeadlessTaskKey) {
+        registerHeadlessTask(function (message) { return __awaiter(void 0, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: 
+                    // keep headless task running until handlers have completed their work
+                    return [4 /*yield*/, notifyEventListenersAndAwaitHandlers('backgroundMessageReceived', message)];
+                    case 1:
+                        // keep headless task running until handlers have completed their work
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    }
+    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, function (message, completionHandlerId) { return __awaiter(void 0, void 0, void 0, function () {
+            var err_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, 3, 4]);
+                        return [4 /*yield*/, 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(function (_, reject) {
+                                    setTimeout(function () {
+                                        return reject("onNotificationReceivedInBackground handlers should complete their work within " + BACKGROUND_TASK_TIMEOUT + " seconds, but they did not.");
+                                    }, BACKGROUND_TASK_TIMEOUT * 1000);
+                                }),
+                            ])];
+                    case 1:
+                        _a.sent();
+                        return [3 /*break*/, 4];
+                    case 2:
+                        err_1 = _a.sent();
+                        logger.error(err_1);
+                        return [3 /*break*/, 4];
+                    case 3:
+                        // notify native module that handlers have completed their work (or timed out)
+                        completeNotification(completionHandlerId);
+                        return [7 /*endfinally*/];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        }); });
+    }
+    addMessageEventListener(
+    // listen for native foreground message received event and broadcast to library listeners
+    FOREGROUND_MESSAGE_RECEIVED, function (message) {
+        notifyEventListeners('foregroundMessageReceived', message);
+    });
+    var 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, function (message) {
+            notifyEventListeners('launchNotificationsOpened', message);
+            // once we are done with it we can remove the listener
+            launchNotificationOpenedListener === null || launchNotificationOpenedListener === void 0 ? void 0 : 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, function (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 === null || launchNotificationOpenedListener === void 0 ? void 0 : 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, function (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);
+    });
+};
+var registerDevice = function () { return __awaiter(void 0, void 0, void 0, function () {
+    var _a, credentials, identityId, _b, appId, region;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0: return [4 /*yield*/, resolveCredentials()];
+            case 1:
+                _a = _c.sent(), credentials = _a.credentials, identityId = _a.identityId;
+                _b = resolveConfig(), appId = _b.appId, region = _b.region;
+                return [2 /*return*/, updateEndpoint({
+                        address: getToken(),
+                        appId: appId,
+                        category: 'PushNotification',
+                        credentials: credentials,
+                        region: region,
+                        channelType: getChannelType(),
+                        identityId: identityId,
+                        userAgentValue: getPushNotificationUserAgentString(PushNotificationAction.InitializePushNotifications),
+                    })];
+        }
+    });
+}); };