@aws-amplify/notifications 1.0.25 → 1.0.26-unstable.1116fef.4

package/lib/PushNotification/Providers/AWSPinpointProvider/types.d.ts

@@ -0,0 +1,9 @@
+export declare enum AWSPinpointMessageEventSource {
+    CAMPAIGN = "_campaign",
+    JOURNEY = "_journey"
+}
+export declare enum AWSPinpointMessageEvent {
+    NOTIFICATION_OPENED = "opened_notification",
+    BACKGROUND_MESSAGE_RECEIVED = "received_background",
+    FOREGROUND_MESSAGE_RECEIVED = "received_foreground"
+}

package/lib/PushNotification/Providers/AWSPinpointProvider/types.js

@@ -0,0 +1,16 @@
+"use strict";
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+var AWSPinpointMessageEventSource;
+(function (AWSPinpointMessageEventSource) {
+    AWSPinpointMessageEventSource["CAMPAIGN"] = "_campaign";
+    AWSPinpointMessageEventSource["JOURNEY"] = "_journey";
+})(AWSPinpointMessageEventSource = exports.AWSPinpointMessageEventSource || (exports.AWSPinpointMessageEventSource = {}));
+var AWSPinpointMessageEvent;
+(function (AWSPinpointMessageEvent) {
+    AWSPinpointMessageEvent["NOTIFICATION_OPENED"] = "opened_notification";
+    AWSPinpointMessageEvent["BACKGROUND_MESSAGE_RECEIVED"] = "received_background";
+    AWSPinpointMessageEvent["FOREGROUND_MESSAGE_RECEIVED"] = "received_foreground";
+})(AWSPinpointMessageEvent = exports.AWSPinpointMessageEvent || (exports.AWSPinpointMessageEvent = {}));
+//# sourceMappingURL=types.js.map

package/lib/PushNotification/Providers/AWSPinpointProvider/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../src/PushNotification/Providers/AWSPinpointProvider/types.ts"],"names":[],"mappings":";AAAA,qEAAqE;AACrE,sCAAsC;;AAEtC,IAAY,6BAGX;AAHD,WAAY,6BAA6B;IACxC,uDAAsB,CAAA;IACtB,qDAAoB,CAAA;AACrB,CAAC,EAHW,6BAA6B,GAA7B,qCAA6B,KAA7B,qCAA6B,QAGxC;AAED,IAAY,uBAIX;AAJD,WAAY,uBAAuB;IAClC,sEAA2C,CAAA;IAC3C,8EAAmD,CAAA;IACnD,8EAAmD,CAAA;AACpD,CAAC,EAJW,uBAAuB,GAAvB,+BAAuB,KAAvB,+BAAuB,QAIlC"}

package/lib/PushNotification/Providers/AWSPinpointProvider/utils.d.ts

@@ -0,0 +1,7 @@
+import { Event as AWSPinpointAnalyticsEvent } from '@aws-sdk/client-pinpoint';
+import { ConsoleLogger } from '@aws-amplify/core';
+import { PushNotificationMessage } from '../../types';
+import { AWSPinpointMessageEvent } from './types';
+export declare const logger: ConsoleLogger;
+export declare const dispatchPushNotificationEvent: (event: string, data: any, message?: string) => void;
+export declare const getAnalyticsEvent: ({ data }: PushNotificationMessage, event: AWSPinpointMessageEvent) => AWSPinpointAnalyticsEvent;

package/lib/PushNotification/Providers/AWSPinpointProvider/utils.js

@@ -0,0 +1,58 @@
+"use strict";
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+var core_1 = require("@aws-amplify/core");
+var common_1 = require("../../../common");
+var types_1 = require("./types");
+var ANDROID_CAMPAIGN_ACTIVITY_ID_KEY = 'pinpoint.campaign.campaign_activity_id';
+var ANDROID_CAMPAIGN_ID_KEY = 'pinpoint.campaign.campaign_id';
+var ANDROID_CAMPAIGN_TREATMENT_ID_KEY = 'pinpoint.campaign.treatment_id';
+exports.logger = new core_1.ConsoleLogger('PushNotification.AWSPinpointProvider');
+exports.dispatchPushNotificationEvent = function (event, data, message) {
+    core_1.Hub.dispatch('pushNotification', { event: event, data: data, message: message }, 'PushNotification', common_1.AMPLIFY_SYMBOL);
+};
+exports.getAnalyticsEvent = function (_a, event) {
+    var data = _a.data;
+    if (!data) {
+        return null;
+    }
+    var eventAttributes = getAnalyticsEventAttributes(data);
+    if (!eventAttributes) {
+        return null;
+    }
+    var source = eventAttributes.source, attributes = eventAttributes.attributes;
+    return {
+        Attributes: attributes,
+        EventType: source + "." + event,
+        Timestamp: new Date().toISOString(),
+    };
+};
+var getAnalyticsEventAttributes = function (data) {
+    if (data.hasOwnProperty(ANDROID_CAMPAIGN_ID_KEY)) {
+        return {
+            source: types_1.AWSPinpointMessageEventSource.CAMPAIGN,
+            attributes: {
+                campaign_activity_id: data[ANDROID_CAMPAIGN_ACTIVITY_ID_KEY],
+                campaign_id: data[ANDROID_CAMPAIGN_ID_KEY],
+                treatment_id: data[ANDROID_CAMPAIGN_TREATMENT_ID_KEY],
+            },
+        };
+    }
+    var pinpoint = typeof data.pinpoint === 'string'
+        ? JSON.parse(data.pinpoint)
+        : data.pinpoint;
+    if (pinpoint === null || pinpoint === void 0 ? void 0 : pinpoint.campaign) {
+        return {
+            source: types_1.AWSPinpointMessageEventSource.CAMPAIGN,
+            attributes: pinpoint.campaign,
+        };
+    }
+    if (pinpoint === null || pinpoint === void 0 ? void 0 : pinpoint.journey) {
+        return {
+            source: types_1.AWSPinpointMessageEventSource.JOURNEY,
+            attributes: pinpoint.journey,
+        };
+    }
+};
+//# sourceMappingURL=utils.js.map

package/lib/PushNotification/Providers/AWSPinpointProvider/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../src/PushNotification/Providers/AWSPinpointProvider/utils.ts"],"names":[],"mappings":";AAAA,qEAAqE;AACrE,sCAAsC;;AAGtC,0CAAuD;AACvD,0CAAiD;AAEjD,iCAGiB;AAEjB,IAAM,gCAAgC,GACrC,wCAAwC,CAAC;AAC1C,IAAM,uBAAuB,GAAG,+BAA+B,CAAC;AAChE,IAAM,iCAAiC,GAAG,gCAAgC,CAAC;AAE9D,QAAA,MAAM,GAAG,IAAI,oBAAa,CAAC,sCAAsC,CAAC,CAAC;AAEnE,QAAA,6BAA6B,GAAG,UAC5C,KAAa,EACb,IAAS,EACT,OAAgB;IAEhB,UAAG,CAAC,QAAQ,CACX,kBAAkB,EAClB,EAAE,KAAK,OAAA,EAAE,IAAI,MAAA,EAAE,OAAO,SAAA,EAAE,EACxB,kBAAkB,EAClB,uBAAc,CACd,CAAC;AACH,CAAC,CAAC;AAEW,QAAA,iBAAiB,GAAG,UAChC,EAAiC,EACjC,KAA8B;QAD5B,cAAI;IAGN,IAAI,CAAC,IAAI,EAAE;QACV,OAAO,IAAI,CAAC;KACZ;IACD,IAAM,eAAe,GAAG,2BAA2B,CAAC,IAAI,CAAC,CAAC;IAC1D,IAAI,CAAC,eAAe,EAAE;QACrB,OAAO,IAAI,CAAC;KACZ;IACO,IAAA,+BAAM,EAAE,uCAAU,CAAqB;IAC/C,OAAO;QACN,UAAU,EAAE,UAAU;QACtB,SAAS,EAAK,MAAM,SAAI,KAAO;QAC/B,SAAS,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;KACnC,CAAC;AACH,CAAC,CAAC;AAEF,IAAM,2BAA2B,GAAG,UAAC,IAAqC;IACzE,IAAI,IAAI,CAAC,cAAc,CAAC,uBAAuB,CAAC,EAAE;QACjD,OAAO;YACN,MAAM,EAAE,qCAA6B,CAAC,QAAQ;YAC9C,UAAU,EAAE;gBACX,oBAAoB,EAAE,IAAI,CAAC,gCAAgC,CAAC;gBAC5D,WAAW,EAAE,IAAI,CAAC,uBAAuB,CAAC;gBAC1C,YAAY,EAAE,IAAI,CAAC,iCAAiC,CAAC;aACrD;SACD,CAAC;KACF;IACD,IAAM,QAAQ,GACb,OAAO,IAAI,CAAC,QAAQ,KAAK,QAAQ;QAChC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC;QAC3B,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC;IAClB,IAAI,QAAQ,aAAR,QAAQ,uBAAR,QAAQ,CAAE,QAAQ,EAAE;QACvB,OAAO;YACN,MAAM,EAAE,qCAA6B,CAAC,QAAQ;YAC9C,UAAU,EAAE,QAAQ,CAAC,QAAQ;SAC7B,CAAC;KACF;IACD,IAAI,QAAQ,aAAR,QAAQ,uBAAR,QAAQ,CAAE,OAAO,EAAE;QACtB,OAAO;YACN,MAAM,EAAE,qCAA6B,CAAC,OAAO;YAC7C,UAAU,EAAE,QAAQ,CAAC,OAAO;SAC5B,CAAC;KACF;AACF,CAAC,CAAC"}

package/lib/PushNotification/Providers/index.d.ts

@@ -0,0 +1 @@
+export { default as AWSPinpointProvider } from './AWSPinpointProvider';

package/lib/PushNotification/Providers/index.js

@@ -0,0 +1,7 @@
+"use strict";
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+var AWSPinpointProvider_1 = require("./AWSPinpointProvider");
+exports.AWSPinpointProvider = AWSPinpointProvider_1.default;
+//# sourceMappingURL=index.js.map

package/lib/PushNotification/Providers/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/PushNotification/Providers/index.ts"],"names":[],"mappings":";AAAA,qEAAqE;AACrE,sCAAsC;;AAEtC,6DAAuE;AAA9D,oDAAA,OAAO,CAAuB"}

package/lib/PushNotification/PushNotification.d.ts

@@ -0,0 +1,39 @@
+import { NotificationsSubCategory, OnPushNotificationMessageHandler, OnTokenReceivedHandler, PushNotificationConfig, PushNotificationInterface, PushNotificationMessage, PushNotificationPermissions, PushNotificationPermissionStatus, PushNotificationProvider } from './types';
+export default class PushNotification implements PushNotificationInterface {
+    /**
+     * Configure PushNotification
+     * @param {Object} config - PushNotification configuration object
+     */
+    configure: (_?: PushNotificationConfig) => PushNotificationConfig;
+    /**
+     * Get the name of this module
+     * @returns {string} name of this module
+     */
+    getModuleName(): NotificationsSubCategory;
+    /**
+     * Get a plugin from added plugins
+     * @param {string} providerName - the name of the plugin to get
+     */
+    getPluggable: (_: string) => never;
+    /**
+     * Add plugin into PushNotification
+     * @param {PushNotificationProvider} pluggable - an instance of the plugin
+     */
+    addPluggable: (_: PushNotificationProvider) => void;
+    /**
+     * Remove a plugin from added plugins
+     * @param {string} providerName - the name of the plugin to remove
+     */
+    removePluggable: () => void;
+    enable: () => void;
+    identifyUser: () => Promise<void[]>;
+    getLaunchNotification: () => Promise<PushNotificationMessage>;
+    getBadgeCount: () => Promise<number>;
+    setBadgeCount: (_: number) => void;
+    getPermissionStatus: () => Promise<PushNotificationPermissionStatus>;
+    requestPermissions: (_?: PushNotificationPermissions) => Promise<boolean>;
+    onNotificationReceivedInBackground: (_: OnPushNotificationMessageHandler) => any;
+    onNotificationReceivedInForeground: (_: OnPushNotificationMessageHandler) => any;
+    onTokenReceived: (_: OnTokenReceivedHandler) => any;
+    onNotificationOpened: (_: OnPushNotificationMessageHandler) => any;
+}

package/lib/PushNotification/PushNotification.js

@@ -0,0 +1,91 @@
+"use strict";
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var PlatformNotSupportedError_1 = tslib_1.__importDefault(require("./PlatformNotSupportedError"));
+var PushNotification = /** @class */ (function () {
+    function PushNotification() {
+        var _this = this;
+        /**
+         * Configure PushNotification
+         * @param {Object} config - PushNotification configuration object
+         */
+        this.configure = function (_) {
+            if (_ === void 0) { _ = {}; }
+            throw new PlatformNotSupportedError_1.default();
+        };
+        /**
+         * Get a plugin from added plugins
+         * @param {string} providerName - the name of the plugin to get
+         */
+        this.getPluggable = function (_) {
+            throw new PlatformNotSupportedError_1.default();
+        };
+        /**
+         * Add plugin into PushNotification
+         * @param {PushNotificationProvider} pluggable - an instance of the plugin
+         */
+        this.addPluggable = function (_) {
+            throw new PlatformNotSupportedError_1.default();
+        };
+        /**
+         * Remove a plugin from added plugins
+         * @param {string} providerName - the name of the plugin to remove
+         */
+        this.removePluggable = function () {
+            throw new PlatformNotSupportedError_1.default();
+        };
+        this.enable = function () {
+            throw new PlatformNotSupportedError_1.default();
+        };
+        this.identifyUser = function () {
+            throw new PlatformNotSupportedError_1.default();
+        };
+        this.getLaunchNotification = function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                throw new PlatformNotSupportedError_1.default();
+            });
+        }); };
+        this.getBadgeCount = function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                throw new PlatformNotSupportedError_1.default();
+            });
+        }); };
+        this.setBadgeCount = function (_) {
+            throw new PlatformNotSupportedError_1.default();
+        };
+        this.getPermissionStatus = function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                throw new PlatformNotSupportedError_1.default();
+            });
+        }); };
+        this.requestPermissions = function (_) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                throw new PlatformNotSupportedError_1.default();
+            });
+        }); };
+        this.onNotificationReceivedInBackground = function (_) {
+            throw new PlatformNotSupportedError_1.default();
+        };
+        this.onNotificationReceivedInForeground = function (_) {
+            throw new PlatformNotSupportedError_1.default();
+        };
+        this.onTokenReceived = function (_) {
+            throw new PlatformNotSupportedError_1.default();
+        };
+        this.onNotificationOpened = function (_) {
+            throw new PlatformNotSupportedError_1.default();
+        };
+    }
+    /**
+     * Get the name of this module
+     * @returns {string} name of this module
+     */
+    PushNotification.prototype.getModuleName = function () {
+        throw new PlatformNotSupportedError_1.default();
+    };
+    return PushNotification;
+}());
+exports.default = PushNotification;
+//# sourceMappingURL=PushNotification.js.map

package/lib/PushNotification/PushNotification.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PushNotification.js","sourceRoot":"","sources":["../../src/PushNotification/PushNotification.ts"],"names":[],"mappings":";AAAA,qEAAqE;AACrE,sCAAsC;;;AAEtC,kGAAoE;AAapE;IAAA;QAAA,iBA0FC;QAzFA;;;WAGG;QACH,cAAS,GAAG,UAAC,CAA8B;YAA9B,kBAAA,EAAA,MAA8B;YAC1C,MAAM,IAAI,mCAAyB,EAAE,CAAC;QACvC,CAAC,CAAC;QAUF;;;WAGG;QACH,iBAAY,GAAG,UAAC,CAAS;YACxB,MAAM,IAAI,mCAAyB,EAAE,CAAC;QACvC,CAAC,CAAC;QAEF;;;WAGG;QACH,iBAAY,GAAG,UAAC,CAA2B;YAC1C,MAAM,IAAI,mCAAyB,EAAE,CAAC;QACvC,CAAC,CAAC;QAEF;;;WAGG;QACH,oBAAe,GAAG;YACjB,MAAM,IAAI,mCAAyB,EAAE,CAAC;QACvC,CAAC,CAAC;QAEF,WAAM,GAAG;YACR,MAAM,IAAI,mCAAyB,EAAE,CAAC;QACvC,CAAC,CAAC;QAEF,iBAAY,GAAG;YACd,MAAM,IAAI,mCAAyB,EAAE,CAAC;QACvC,CAAC,CAAC;QAEF,0BAAqB,GAAG;;gBACvB,MAAM,IAAI,mCAAyB,EAAE,CAAC;;aACtC,CAAC;QAEF,kBAAa,GAAG;;gBACf,MAAM,IAAI,mCAAyB,EAAE,CAAC;;aACtC,CAAC;QAEF,kBAAa,GAAG,UAAC,CAAS;YACzB,MAAM,IAAI,mCAAyB,EAAE,CAAC;QACvC,CAAC,CAAC;QAEF,wBAAmB,GAAG;;gBACrB,MAAM,IAAI,mCAAyB,EAAE,CAAC;;aACtC,CAAC;QAEF,uBAAkB,GAAG,UACpB,CAA+B;;gBAE/B,MAAM,IAAI,mCAAyB,EAAE,CAAC;;aACtC,CAAC;QAEF,uCAAkC,GAAG,UACpC,CAAmC;YAEnC,MAAM,IAAI,mCAAyB,EAAE,CAAC;QACvC,CAAC,CAAC;QAEF,uCAAkC,GAAG,UACpC,CAAmC;YAEnC,MAAM,IAAI,mCAAyB,EAAE,CAAC;QACvC,CAAC,CAAC;QAEF,oBAAe,GAAG,UAAC,CAAyB;YAC3C,MAAM,IAAI,mCAAyB,EAAE,CAAC;QACvC,CAAC,CAAC;QAEF,yBAAoB,GAAG,UAAC,CAAmC;YAC1D,MAAM,IAAI,mCAAyB,EAAE,CAAC;QACvC,CAAC,CAAC;IACH,CAAC;IAjFA;;;OAGG;IACH,wCAAa,GAAb;QACC,MAAM,IAAI,mCAAyB,EAAE,CAAC;IACvC,CAAC;IA2EF,uBAAC;AAAD,CAAC,AA1FD,IA0FC"}

package/lib/PushNotification/PushNotification.native.d.ts

@@ -0,0 +1,63 @@
+import { EventListener } from '../common';
+import { UserInfo } from '../types';
+import { NotificationsSubCategory, OnPushNotificationMessageHandler, OnTokenReceivedHandler, PushNotificationConfig, PushNotificationInterface, PushNotificationMessage, PushNotificationPermissions, PushNotificationPermissionStatus, PushNotificationProvider } from './types';
+export default class PushNotification implements PushNotificationInterface {
+    private isEnabled;
+    private config;
+    private nativeEvent;
+    private nativeEventEmitter;
+    private nativeHeadlessTaskKey;
+    private nativeModule;
+    private pluggables;
+    private token;
+    constructor();
+    /**
+     * Configure PushNotification
+     * @param {Object} config - PushNotification configuration object
+     */
+    configure: (config?: PushNotificationConfig) => PushNotificationConfig;
+    /**
+     * Get the name of this module
+     * @returns {string} name of this module
+     */
+    getModuleName(): NotificationsSubCategory;
+    /**
+     * Get a plugin from added plugins
+     * @param {string} providerName - the name of the plugin to get
+     */
+    getPluggable: (providerName: string) => PushNotificationProvider;
+    /**
+     * Add plugin into PushNotification
+     * @param {PushNotificationProvider} pluggable - an instance of the plugin
+     */
+    addPluggable: (pluggable: PushNotificationProvider) => void;
+    /**
+     * Remove a plugin from added plugins
+     * @param {string} providerName - the name of the plugin to remove
+     */
+    removePluggable: (providerName: string) => void;
+    enable: () => void;
+    identifyUser: (userId: string, userInfo: UserInfo) => Promise<void[]>;
+    getLaunchNotification: () => Promise<PushNotificationMessage>;
+    getBadgeCount: () => Promise<number>;
+    setBadgeCount: (count: number) => void;
+    getPermissionStatus: () => Promise<PushNotificationPermissionStatus>;
+    requestPermissions: (permissions?: PushNotificationPermissions) => Promise<boolean>;
+    /**
+     * Background notifications on will start the app (as a headless JS instance running on a background service on
+     * Android) in the background. Handlers registered via `onNotificationReceivedInBackground` 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.
+     *
+     * @param handler a function to be run when a BACKGROUND_MESSAGE_RECEIVED event is received
+     * @returns an event listener which should be removed when no longer needed
+     */
+    onNotificationReceivedInBackground: (handler: OnPushNotificationMessageHandler) => EventListener<OnPushNotificationMessageHandler>;
+    onNotificationReceivedInForeground: (handler: OnPushNotificationMessageHandler) => EventListener<OnPushNotificationMessageHandler>;
+    onNotificationOpened: (handler: OnPushNotificationMessageHandler) => EventListener<OnPushNotificationMessageHandler>;
+    onTokenReceived: (handler: OnTokenReceivedHandler) => EventListener<OnTokenReceivedHandler>;
+    private registerDevice;
+    private assertIsEnabled;
+}

package/lib/PushNotification/PushNotification.native.js

@@ -0,0 +1,327 @@
+"use strict";
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var react_native_1 = require("react-native");
+var core_1 = require("@aws-amplify/core");
+var rtn_push_notification_1 = require("@aws-amplify/rtn-push-notification");
+var common_1 = require("../common");
+var NotEnabledError_1 = tslib_1.__importDefault(require("./NotEnabledError"));
+var Providers_1 = require("./Providers");
+var utils_1 = require("./utils");
+var logger = new core_1.ConsoleLogger('Notifications.PushNotification');
+var RTN_MODULE = '@aws-amplify/rtn-push-notification';
+var BACKGROUND_TASK_TIMEOUT = 25; // seconds
+var PushNotification = /** @class */ (function () {
+    function PushNotification() {
+        var _this = this;
+        this.isEnabled = false;
+        this.config = {};
+        this.pluggables = [];
+        /**
+         * Configure PushNotification
+         * @param {Object} config - PushNotification configuration object
+         */
+        this.configure = function (config) {
+            if (config === void 0) { config = {}; }
+            _this.config = tslib_1.__assign(tslib_1.__assign({}, _this.config), config);
+            logger.debug('configure PushNotification', _this.config);
+            _this.pluggables.forEach(function (pluggable) {
+                pluggable.configure(_this.config[pluggable.getProviderName()]);
+            });
+            if (_this.pluggables.length === 0) {
+                _this.addPluggable(new Providers_1.AWSPinpointProvider());
+            }
+            return _this.config;
+        };
+        /**
+         * Get a plugin from added plugins
+         * @param {string} providerName - the name of the plugin to get
+         */
+        this.getPluggable = function (providerName) {
+            var _a;
+            var pluggable = (_a = _this.pluggables.find(function (pluggable) { return pluggable.getProviderName() === providerName; })) !== null && _a !== void 0 ? _a : null;
+            if (!pluggable) {
+                logger.debug("No plugin found with name " + providerName);
+            }
+            return pluggable;
+        };
+        /**
+         * Add plugin into PushNotification
+         * @param {PushNotificationProvider} pluggable - an instance of the plugin
+         */
+        this.addPluggable = function (pluggable) {
+            if (pluggable &&
+                pluggable.getCategory() === 'Notifications' &&
+                pluggable.getSubCategory() === 'PushNotification') {
+                if (_this.getPluggable(pluggable.getProviderName())) {
+                    throw new Error("Pluggable " + pluggable.getProviderName() + " has already been added.");
+                }
+                _this.pluggables.push(pluggable);
+                pluggable.configure(_this.config[pluggable.getProviderName()]);
+            }
+        };
+        /**
+         * Remove a plugin from added plugins
+         * @param {string} providerName - the name of the plugin to remove
+         */
+        this.removePluggable = function (providerName) {
+            var index = _this.pluggables.findIndex(function (pluggable) { return pluggable.getProviderName() === providerName; });
+            if (index === -1) {
+                logger.debug("No plugin found with name " + providerName);
+            }
+            else {
+                _this.pluggables.splice(index, 1);
+            }
+        };
+        this.enable = function () {
+            if (_this.isEnabled) {
+                logger.info('Notification listeners have already been enabled');
+                return;
+            }
+            var _a = _this.nativeEvent, BACKGROUND_MESSAGE_RECEIVED = _a.BACKGROUND_MESSAGE_RECEIVED, FOREGROUND_MESSAGE_RECEIVED = _a.FOREGROUND_MESSAGE_RECEIVED, LAUNCH_NOTIFICATION_OPENED = _a.LAUNCH_NOTIFICATION_OPENED, NOTIFICATION_OPENED = _a.NOTIFICATION_OPENED, TOKEN_RECEIVED = _a.TOKEN_RECEIVED;
+            if (_this.nativeHeadlessTaskKey) {
+                // on platforms that can handle headless tasks, register one to broadcast background message received to
+                // library listeners
+                react_native_1.AppRegistry.registerHeadlessTask(_this.nativeHeadlessTaskKey, function () { return function (message) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                    return tslib_1.__generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0: 
+                            // keep headless task running until handlers have completed their work
+                            return [4 /*yield*/, common_1.notifyEventListenersAndAwaitHandlers(0 /* BACKGROUND_MESSAGE_RECEIVED */, utils_1.normalizeNativeMessage(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
+                _this.nativeEventEmitter.addListener(BACKGROUND_MESSAGE_RECEIVED, function (message) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                    var err_1;
+                    var _a, _b;
+                    return tslib_1.__generator(this, function (_c) {
+                        switch (_c.label) {
+                            case 0:
+                                _c.trys.push([0, 2, 3, 4]);
+                                return [4 /*yield*/, Promise.race([
+                                        common_1.notifyEventListenersAndAwaitHandlers(0 /* BACKGROUND_MESSAGE_RECEIVED */, utils_1.normalizeNativeMessage(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:
+                                _c.sent();
+                                return [3 /*break*/, 4];
+                            case 2:
+                                err_1 = _c.sent();
+                                logger.error(err_1);
+                                return [3 /*break*/, 4];
+                            case 3:
+                                // notify native module that handlers have completed their work (or timed out)
+                                (_b = (_a = this.nativeModule).completeNotification) === null || _b === void 0 ? void 0 : _b.call(_a, message.completionHandlerId);
+                                return [7 /*endfinally*/];
+                            case 4: return [2 /*return*/];
+                        }
+                    });
+                }); });
+            }
+            _this.nativeEventEmitter.addListener(
+            // listen for native foreground message received event and broadcast to library listeners
+            FOREGROUND_MESSAGE_RECEIVED, function (message) {
+                common_1.notifyEventListeners(1 /* FOREGROUND_MESSAGE_RECEIVED */, utils_1.normalizeNativeMessage(message));
+            });
+            var launchNotificationOpenedListener = LAUNCH_NOTIFICATION_OPENED
+                ? _this.nativeEventEmitter.addListener(
+                // 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) {
+                    common_1.notifyEventListeners(2 /* LAUNCH_NOTIFICATION_OPENED */, utils_1.normalizeNativeMessage(message));
+                    // once we are done with it we can remove the listener
+                    launchNotificationOpenedListener === null || launchNotificationOpenedListener === void 0 ? void 0 : launchNotificationOpenedListener.remove();
+                })
+                : null;
+            _this.nativeEventEmitter.addListener(
+            // 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) {
+                common_1.notifyEventListeners(3 /* NOTIFICATION_OPENED */, utils_1.normalizeNativeMessage(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();
+            });
+            _this.nativeEventEmitter.addListener(
+            // listen for native new token event, automatically re-register device with provider using new token and
+            // broadcast to library listeners
+            TOKEN_RECEIVED, function (_a) {
+                var token = _a.token;
+                // avoid a race condition where two endpoints are created with the same token on a fresh install
+                if (_this.token === token) {
+                    return;
+                }
+                _this.token = token;
+                _this.registerDevice();
+                common_1.notifyEventListeners(4 /* TOKEN_RECEIVED */, token);
+            });
+            _this.isEnabled = true;
+        };
+        this.identifyUser = function (userId, userInfo) {
+            _this.assertIsEnabled();
+            return Promise.all(_this.pluggables.map(function (pluggable) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                var err_2;
+                return tslib_1.__generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            _a.trys.push([0, 2, , 3]);
+                            return [4 /*yield*/, pluggable.identifyUser(userId, userInfo)];
+                        case 1:
+                            _a.sent();
+                            return [3 /*break*/, 3];
+                        case 2:
+                            err_2 = _a.sent();
+                            logger.error('Failed to identify user', err_2);
+                            throw err_2;
+                        case 3: return [2 /*return*/];
+                    }
+                });
+            }); }));
+        };
+        this.getLaunchNotification = function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+            var _a;
+            var _b, _c;
+            return tslib_1.__generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        this.assertIsEnabled();
+                        _a = utils_1.normalizeNativeMessage;
+                        return [4 /*yield*/, ((_c = (_b = this.nativeModule).getLaunchNotification) === null || _c === void 0 ? void 0 : _c.call(_b))];
+                    case 1: return [2 /*return*/, _a.apply(void 0, [_d.sent()])];
+                }
+            });
+        }); };
+        this.getBadgeCount = function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+            var _a, _b;
+            return tslib_1.__generator(this, function (_c) {
+                this.assertIsEnabled();
+                return [2 /*return*/, (_b = (_a = this.nativeModule).getBadgeCount) === null || _b === void 0 ? void 0 : _b.call(_a)];
+            });
+        }); };
+        this.setBadgeCount = function (count) {
+            var _a, _b;
+            _this.assertIsEnabled();
+            return (_b = (_a = _this.nativeModule).setBadgeCount) === null || _b === void 0 ? void 0 : _b.call(_a, count);
+        };
+        this.getPermissionStatus = function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+            var _a;
+            var _b, _c;
+            return tslib_1.__generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        this.assertIsEnabled();
+                        _a = utils_1.normalizeNativePermissionStatus;
+                        return [4 /*yield*/, ((_c = (_b = this.nativeModule).getPermissionStatus) === null || _c === void 0 ? void 0 : _c.call(_b))];
+                    case 1: return [2 /*return*/, _a.apply(void 0, [_d.sent()])];
+                }
+            });
+        }); };
+        this.requestPermissions = function (permissions) {
+            if (permissions === void 0) { permissions = {
+                alert: true,
+                badge: true,
+                sound: true,
+            }; }
+            return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                var _a, _b;
+                return tslib_1.__generator(this, function (_c) {
+                    this.assertIsEnabled();
+                    return [2 /*return*/, (_b = (_a = this.nativeModule).requestPermissions) === null || _b === void 0 ? void 0 : _b.call(_a, permissions)];
+                });
+            });
+        };
+        /**
+         * Background notifications on will start the app (as a headless JS instance running on a background service on
+         * Android) in the background. Handlers registered via `onNotificationReceivedInBackground` 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.
+         *
+         * @param handler a function to be run when a BACKGROUND_MESSAGE_RECEIVED event is received
+         * @returns an event listener which should be removed when no longer needed
+         */
+        this.onNotificationReceivedInBackground = function (handler) {
+            _this.assertIsEnabled();
+            return common_1.addEventListener(0 /* BACKGROUND_MESSAGE_RECEIVED */, handler);
+        };
+        this.onNotificationReceivedInForeground = function (handler) {
+            _this.assertIsEnabled();
+            return common_1.addEventListener(1 /* FOREGROUND_MESSAGE_RECEIVED */, handler);
+        };
+        this.onNotificationOpened = function (handler) {
+            _this.assertIsEnabled();
+            return common_1.addEventListener(3 /* NOTIFICATION_OPENED */, handler);
+        };
+        this.onTokenReceived = function (handler) {
+            _this.assertIsEnabled();
+            return common_1.addEventListener(4 /* TOKEN_RECEIVED */, handler);
+        };
+        this.registerDevice = function () { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+            var _this = this;
+            return tslib_1.__generator(this, function (_a) {
+                return [2 /*return*/, Promise.all(this.pluggables.map(function (pluggable) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                        var err_3;
+                        return tslib_1.__generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0:
+                                    _a.trys.push([0, 2, , 3]);
+                                    return [4 /*yield*/, pluggable.registerDevice(this.token)];
+                                case 1:
+                                    _a.sent();
+                                    return [3 /*break*/, 3];
+                                case 2:
+                                    err_3 = _a.sent();
+                                    logger.error('Failed to register device for push notifications', err_3);
+                                    throw err_3;
+                                case 3: return [2 /*return*/];
+                            }
+                        });
+                    }); }))];
+            });
+        }); };
+        this.assertIsEnabled = function () {
+            if (!_this.isEnabled) {
+                throw new NotEnabledError_1.default();
+            }
+        };
+        try {
+            this.nativeModule = rtn_push_notification_1.AmplifyRTNPushNotification;
+            var _a = this.nativeModule.getConstants(), NativeEvent = _a.NativeEvent, NativeHeadlessTaskKey = _a.NativeHeadlessTaskKey;
+            this.nativeEvent = NativeEvent;
+            this.nativeHeadlessTaskKey = NativeHeadlessTaskKey;
+            this.nativeEventEmitter = new react_native_1.NativeEventEmitter(rtn_push_notification_1.AmplifyRTNPushNotification);
+        }
+        catch (err) {
+            err.message = "Unable to find " + RTN_MODULE + ". " + err.message;
+            throw err;
+        }
+    }
+    /**
+     * Get the name of this module
+     * @returns {string} name of this module
+     */
+    PushNotification.prototype.getModuleName = function () {
+        return 'PushNotification';
+    };
+    return PushNotification;
+}());
+exports.default = PushNotification;
+//# sourceMappingURL=PushNotification.native.js.map