forked from dienianindya/gsi_ess_mobile
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1234 lines
48 KiB
1234 lines
48 KiB
import '@firebase/installations';
|
|
import { Component } from '@firebase/component';
|
|
import { openDB, deleteDB } from 'idb';
|
|
import { ErrorFactory, validateIndexedDBOpenable, isIndexedDBAvailable, areCookiesEnabled, getModularInstance } from '@firebase/util';
|
|
import { _registerComponent, registerVersion, _getProvider, getApp } from '@firebase/app';
|
|
|
|
/**
|
|
* @license
|
|
* Copyright 2019 Google LLC
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
const DEFAULT_SW_PATH = '/firebase-messaging-sw.js';
|
|
const DEFAULT_SW_SCOPE = '/firebase-cloud-messaging-push-scope';
|
|
const DEFAULT_VAPID_KEY = 'BDOU99-h67HcA6JeFXHbSNMu7e2yNNu3RzoMj8TM4W88jITfq7ZmPvIM1Iv-4_l2LxQcYwhqby2xGpWwzjfAnG4';
|
|
const ENDPOINT = 'https://fcmregistrations.googleapis.com/v1';
|
|
const CONSOLE_CAMPAIGN_ID = 'google.c.a.c_id';
|
|
const CONSOLE_CAMPAIGN_NAME = 'google.c.a.c_l';
|
|
const CONSOLE_CAMPAIGN_TIME = 'google.c.a.ts';
|
|
/** Set to '1' if Analytics is enabled for the campaign */
|
|
const CONSOLE_CAMPAIGN_ANALYTICS_ENABLED = 'google.c.a.e';
|
|
var MessageType$1;
|
|
(function (MessageType) {
|
|
MessageType[MessageType["DATA_MESSAGE"] = 1] = "DATA_MESSAGE";
|
|
MessageType[MessageType["DISPLAY_NOTIFICATION"] = 3] = "DISPLAY_NOTIFICATION";
|
|
})(MessageType$1 || (MessageType$1 = {}));
|
|
|
|
/**
|
|
* @license
|
|
* Copyright 2018 Google LLC
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
|
|
* in compliance with the License. You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software distributed under the License
|
|
* is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
|
|
* or implied. See the License for the specific language governing permissions and limitations under
|
|
* the License.
|
|
*/
|
|
var MessageType;
|
|
(function (MessageType) {
|
|
MessageType["PUSH_RECEIVED"] = "push-received";
|
|
MessageType["NOTIFICATION_CLICKED"] = "notification-clicked";
|
|
})(MessageType || (MessageType = {}));
|
|
|
|
/**
|
|
* @license
|
|
* Copyright 2017 Google LLC
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
function arrayToBase64(array) {
|
|
const uint8Array = new Uint8Array(array);
|
|
const base64String = btoa(String.fromCharCode(...uint8Array));
|
|
return base64String.replace(/=/g, '').replace(/\+/g, '-').replace(/\//g, '_');
|
|
}
|
|
function base64ToArray(base64String) {
|
|
const padding = '='.repeat((4 - (base64String.length % 4)) % 4);
|
|
const base64 = (base64String + padding)
|
|
.replace(/\-/g, '+')
|
|
.replace(/_/g, '/');
|
|
const rawData = atob(base64);
|
|
const outputArray = new Uint8Array(rawData.length);
|
|
for (let i = 0; i < rawData.length; ++i) {
|
|
outputArray[i] = rawData.charCodeAt(i);
|
|
}
|
|
return outputArray;
|
|
}
|
|
|
|
/**
|
|
* @license
|
|
* Copyright 2019 Google LLC
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
const OLD_DB_NAME = 'fcm_token_details_db';
|
|
/**
|
|
* The last DB version of 'fcm_token_details_db' was 4. This is one higher, so that the upgrade
|
|
* callback is called for all versions of the old DB.
|
|
*/
|
|
const OLD_DB_VERSION = 5;
|
|
const OLD_OBJECT_STORE_NAME = 'fcm_token_object_Store';
|
|
async function migrateOldDatabase(senderId) {
|
|
if ('databases' in indexedDB) {
|
|
// indexedDb.databases() is an IndexedDB v3 API and does not exist in all browsers. TODO: Remove
|
|
// typecast when it lands in TS types.
|
|
const databases = await indexedDB.databases();
|
|
const dbNames = databases.map(db => db.name);
|
|
if (!dbNames.includes(OLD_DB_NAME)) {
|
|
// old DB didn't exist, no need to open.
|
|
return null;
|
|
}
|
|
}
|
|
let tokenDetails = null;
|
|
const db = await openDB(OLD_DB_NAME, OLD_DB_VERSION, {
|
|
upgrade: async (db, oldVersion, newVersion, upgradeTransaction) => {
|
|
var _a;
|
|
if (oldVersion < 2) {
|
|
// Database too old, skip migration.
|
|
return;
|
|
}
|
|
if (!db.objectStoreNames.contains(OLD_OBJECT_STORE_NAME)) {
|
|
// Database did not exist. Nothing to do.
|
|
return;
|
|
}
|
|
const objectStore = upgradeTransaction.objectStore(OLD_OBJECT_STORE_NAME);
|
|
const value = await objectStore.index('fcmSenderId').get(senderId);
|
|
await objectStore.clear();
|
|
if (!value) {
|
|
// No entry in the database, nothing to migrate.
|
|
return;
|
|
}
|
|
if (oldVersion === 2) {
|
|
const oldDetails = value;
|
|
if (!oldDetails.auth || !oldDetails.p256dh || !oldDetails.endpoint) {
|
|
return;
|
|
}
|
|
tokenDetails = {
|
|
token: oldDetails.fcmToken,
|
|
createTime: (_a = oldDetails.createTime) !== null && _a !== void 0 ? _a : Date.now(),
|
|
subscriptionOptions: {
|
|
auth: oldDetails.auth,
|
|
p256dh: oldDetails.p256dh,
|
|
endpoint: oldDetails.endpoint,
|
|
swScope: oldDetails.swScope,
|
|
vapidKey: typeof oldDetails.vapidKey === 'string'
|
|
? oldDetails.vapidKey
|
|
: arrayToBase64(oldDetails.vapidKey)
|
|
}
|
|
};
|
|
}
|
|
else if (oldVersion === 3) {
|
|
const oldDetails = value;
|
|
tokenDetails = {
|
|
token: oldDetails.fcmToken,
|
|
createTime: oldDetails.createTime,
|
|
subscriptionOptions: {
|
|
auth: arrayToBase64(oldDetails.auth),
|
|
p256dh: arrayToBase64(oldDetails.p256dh),
|
|
endpoint: oldDetails.endpoint,
|
|
swScope: oldDetails.swScope,
|
|
vapidKey: arrayToBase64(oldDetails.vapidKey)
|
|
}
|
|
};
|
|
}
|
|
else if (oldVersion === 4) {
|
|
const oldDetails = value;
|
|
tokenDetails = {
|
|
token: oldDetails.fcmToken,
|
|
createTime: oldDetails.createTime,
|
|
subscriptionOptions: {
|
|
auth: arrayToBase64(oldDetails.auth),
|
|
p256dh: arrayToBase64(oldDetails.p256dh),
|
|
endpoint: oldDetails.endpoint,
|
|
swScope: oldDetails.swScope,
|
|
vapidKey: arrayToBase64(oldDetails.vapidKey)
|
|
}
|
|
};
|
|
}
|
|
}
|
|
});
|
|
db.close();
|
|
// Delete all old databases.
|
|
await deleteDB(OLD_DB_NAME);
|
|
await deleteDB('fcm_vapid_details_db');
|
|
await deleteDB('undefined');
|
|
return checkTokenDetails(tokenDetails) ? tokenDetails : null;
|
|
}
|
|
function checkTokenDetails(tokenDetails) {
|
|
if (!tokenDetails || !tokenDetails.subscriptionOptions) {
|
|
return false;
|
|
}
|
|
const { subscriptionOptions } = tokenDetails;
|
|
return (typeof tokenDetails.createTime === 'number' &&
|
|
tokenDetails.createTime > 0 &&
|
|
typeof tokenDetails.token === 'string' &&
|
|
tokenDetails.token.length > 0 &&
|
|
typeof subscriptionOptions.auth === 'string' &&
|
|
subscriptionOptions.auth.length > 0 &&
|
|
typeof subscriptionOptions.p256dh === 'string' &&
|
|
subscriptionOptions.p256dh.length > 0 &&
|
|
typeof subscriptionOptions.endpoint === 'string' &&
|
|
subscriptionOptions.endpoint.length > 0 &&
|
|
typeof subscriptionOptions.swScope === 'string' &&
|
|
subscriptionOptions.swScope.length > 0 &&
|
|
typeof subscriptionOptions.vapidKey === 'string' &&
|
|
subscriptionOptions.vapidKey.length > 0);
|
|
}
|
|
|
|
/**
|
|
* @license
|
|
* Copyright 2019 Google LLC
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
// Exported for tests.
|
|
const DATABASE_NAME = 'firebase-messaging-database';
|
|
const DATABASE_VERSION = 1;
|
|
const OBJECT_STORE_NAME = 'firebase-messaging-store';
|
|
let dbPromise = null;
|
|
function getDbPromise() {
|
|
if (!dbPromise) {
|
|
dbPromise = openDB(DATABASE_NAME, DATABASE_VERSION, {
|
|
upgrade: (upgradeDb, oldVersion) => {
|
|
// We don't use 'break' in this switch statement, the fall-through behavior is what we want,
|
|
// because if there are multiple versions between the old version and the current version, we
|
|
// want ALL the migrations that correspond to those versions to run, not only the last one.
|
|
// eslint-disable-next-line default-case
|
|
switch (oldVersion) {
|
|
case 0:
|
|
upgradeDb.createObjectStore(OBJECT_STORE_NAME);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
return dbPromise;
|
|
}
|
|
/** Gets record(s) from the objectStore that match the given key. */
|
|
async function dbGet(firebaseDependencies) {
|
|
const key = getKey(firebaseDependencies);
|
|
const db = await getDbPromise();
|
|
const tokenDetails = (await db
|
|
.transaction(OBJECT_STORE_NAME)
|
|
.objectStore(OBJECT_STORE_NAME)
|
|
.get(key));
|
|
if (tokenDetails) {
|
|
return tokenDetails;
|
|
}
|
|
else {
|
|
// Check if there is a tokenDetails object in the old DB.
|
|
const oldTokenDetails = await migrateOldDatabase(firebaseDependencies.appConfig.senderId);
|
|
if (oldTokenDetails) {
|
|
await dbSet(firebaseDependencies, oldTokenDetails);
|
|
return oldTokenDetails;
|
|
}
|
|
}
|
|
}
|
|
/** Assigns or overwrites the record for the given key with the given value. */
|
|
async function dbSet(firebaseDependencies, tokenDetails) {
|
|
const key = getKey(firebaseDependencies);
|
|
const db = await getDbPromise();
|
|
const tx = db.transaction(OBJECT_STORE_NAME, 'readwrite');
|
|
await tx.objectStore(OBJECT_STORE_NAME).put(tokenDetails, key);
|
|
await tx.done;
|
|
return tokenDetails;
|
|
}
|
|
/** Removes record(s) from the objectStore that match the given key. */
|
|
async function dbRemove(firebaseDependencies) {
|
|
const key = getKey(firebaseDependencies);
|
|
const db = await getDbPromise();
|
|
const tx = db.transaction(OBJECT_STORE_NAME, 'readwrite');
|
|
await tx.objectStore(OBJECT_STORE_NAME).delete(key);
|
|
await tx.done;
|
|
}
|
|
function getKey({ appConfig }) {
|
|
return appConfig.appId;
|
|
}
|
|
|
|
/**
|
|
* @license
|
|
* Copyright 2017 Google LLC
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
const ERROR_MAP = {
|
|
["missing-app-config-values" /* ErrorCode.MISSING_APP_CONFIG_VALUES */]: 'Missing App configuration value: "{$valueName}"',
|
|
["only-available-in-window" /* ErrorCode.AVAILABLE_IN_WINDOW */]: 'This method is available in a Window context.',
|
|
["only-available-in-sw" /* ErrorCode.AVAILABLE_IN_SW */]: 'This method is available in a service worker context.',
|
|
["permission-default" /* ErrorCode.PERMISSION_DEFAULT */]: 'The notification permission was not granted and dismissed instead.',
|
|
["permission-blocked" /* ErrorCode.PERMISSION_BLOCKED */]: 'The notification permission was not granted and blocked instead.',
|
|
["unsupported-browser" /* ErrorCode.UNSUPPORTED_BROWSER */]: "This browser doesn't support the API's required to use the Firebase SDK.",
|
|
["indexed-db-unsupported" /* ErrorCode.INDEXED_DB_UNSUPPORTED */]: "This browser doesn't support indexedDb.open() (ex. Safari iFrame, Firefox Private Browsing, etc)",
|
|
["failed-service-worker-registration" /* ErrorCode.FAILED_DEFAULT_REGISTRATION */]: 'We are unable to register the default service worker. {$browserErrorMessage}',
|
|
["token-subscribe-failed" /* ErrorCode.TOKEN_SUBSCRIBE_FAILED */]: 'A problem occurred while subscribing the user to FCM: {$errorInfo}',
|
|
["token-subscribe-no-token" /* ErrorCode.TOKEN_SUBSCRIBE_NO_TOKEN */]: 'FCM returned no token when subscribing the user to push.',
|
|
["token-unsubscribe-failed" /* ErrorCode.TOKEN_UNSUBSCRIBE_FAILED */]: 'A problem occurred while unsubscribing the ' +
|
|
'user from FCM: {$errorInfo}',
|
|
["token-update-failed" /* ErrorCode.TOKEN_UPDATE_FAILED */]: 'A problem occurred while updating the user from FCM: {$errorInfo}',
|
|
["token-update-no-token" /* ErrorCode.TOKEN_UPDATE_NO_TOKEN */]: 'FCM returned no token when updating the user to push.',
|
|
["use-sw-after-get-token" /* ErrorCode.USE_SW_AFTER_GET_TOKEN */]: 'The useServiceWorker() method may only be called once and must be ' +
|
|
'called before calling getToken() to ensure your service worker is used.',
|
|
["invalid-sw-registration" /* ErrorCode.INVALID_SW_REGISTRATION */]: 'The input to useServiceWorker() must be a ServiceWorkerRegistration.',
|
|
["invalid-bg-handler" /* ErrorCode.INVALID_BG_HANDLER */]: 'The input to setBackgroundMessageHandler() must be a function.',
|
|
["invalid-vapid-key" /* ErrorCode.INVALID_VAPID_KEY */]: 'The public VAPID key must be a string.',
|
|
["use-vapid-key-after-get-token" /* ErrorCode.USE_VAPID_KEY_AFTER_GET_TOKEN */]: 'The usePublicVapidKey() method may only be called once and must be ' +
|
|
'called before calling getToken() to ensure your VAPID key is used.'
|
|
};
|
|
const ERROR_FACTORY = new ErrorFactory('messaging', 'Messaging', ERROR_MAP);
|
|
|
|
/**
|
|
* @license
|
|
* Copyright 2019 Google LLC
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
async function requestGetToken(firebaseDependencies, subscriptionOptions) {
|
|
const headers = await getHeaders(firebaseDependencies);
|
|
const body = getBody(subscriptionOptions);
|
|
const subscribeOptions = {
|
|
method: 'POST',
|
|
headers,
|
|
body: JSON.stringify(body)
|
|
};
|
|
let responseData;
|
|
try {
|
|
const response = await fetch(getEndpoint(firebaseDependencies.appConfig), subscribeOptions);
|
|
responseData = await response.json();
|
|
}
|
|
catch (err) {
|
|
throw ERROR_FACTORY.create("token-subscribe-failed" /* ErrorCode.TOKEN_SUBSCRIBE_FAILED */, {
|
|
errorInfo: err === null || err === void 0 ? void 0 : err.toString()
|
|
});
|
|
}
|
|
if (responseData.error) {
|
|
const message = responseData.error.message;
|
|
throw ERROR_FACTORY.create("token-subscribe-failed" /* ErrorCode.TOKEN_SUBSCRIBE_FAILED */, {
|
|
errorInfo: message
|
|
});
|
|
}
|
|
if (!responseData.token) {
|
|
throw ERROR_FACTORY.create("token-subscribe-no-token" /* ErrorCode.TOKEN_SUBSCRIBE_NO_TOKEN */);
|
|
}
|
|
return responseData.token;
|
|
}
|
|
async function requestUpdateToken(firebaseDependencies, tokenDetails) {
|
|
const headers = await getHeaders(firebaseDependencies);
|
|
const body = getBody(tokenDetails.subscriptionOptions);
|
|
const updateOptions = {
|
|
method: 'PATCH',
|
|
headers,
|
|
body: JSON.stringify(body)
|
|
};
|
|
let responseData;
|
|
try {
|
|
const response = await fetch(`${getEndpoint(firebaseDependencies.appConfig)}/${tokenDetails.token}`, updateOptions);
|
|
responseData = await response.json();
|
|
}
|
|
catch (err) {
|
|
throw ERROR_FACTORY.create("token-update-failed" /* ErrorCode.TOKEN_UPDATE_FAILED */, {
|
|
errorInfo: err === null || err === void 0 ? void 0 : err.toString()
|
|
});
|
|
}
|
|
if (responseData.error) {
|
|
const message = responseData.error.message;
|
|
throw ERROR_FACTORY.create("token-update-failed" /* ErrorCode.TOKEN_UPDATE_FAILED */, {
|
|
errorInfo: message
|
|
});
|
|
}
|
|
if (!responseData.token) {
|
|
throw ERROR_FACTORY.create("token-update-no-token" /* ErrorCode.TOKEN_UPDATE_NO_TOKEN */);
|
|
}
|
|
return responseData.token;
|
|
}
|
|
async function requestDeleteToken(firebaseDependencies, token) {
|
|
const headers = await getHeaders(firebaseDependencies);
|
|
const unsubscribeOptions = {
|
|
method: 'DELETE',
|
|
headers
|
|
};
|
|
try {
|
|
const response = await fetch(`${getEndpoint(firebaseDependencies.appConfig)}/${token}`, unsubscribeOptions);
|
|
const responseData = await response.json();
|
|
if (responseData.error) {
|
|
const message = responseData.error.message;
|
|
throw ERROR_FACTORY.create("token-unsubscribe-failed" /* ErrorCode.TOKEN_UNSUBSCRIBE_FAILED */, {
|
|
errorInfo: message
|
|
});
|
|
}
|
|
}
|
|
catch (err) {
|
|
throw ERROR_FACTORY.create("token-unsubscribe-failed" /* ErrorCode.TOKEN_UNSUBSCRIBE_FAILED */, {
|
|
errorInfo: err === null || err === void 0 ? void 0 : err.toString()
|
|
});
|
|
}
|
|
}
|
|
function getEndpoint({ projectId }) {
|
|
return `${ENDPOINT}/projects/${projectId}/registrations`;
|
|
}
|
|
async function getHeaders({ appConfig, installations }) {
|
|
const authToken = await installations.getToken();
|
|
return new Headers({
|
|
'Content-Type': 'application/json',
|
|
Accept: 'application/json',
|
|
'x-goog-api-key': appConfig.apiKey,
|
|
'x-goog-firebase-installations-auth': `FIS ${authToken}`
|
|
});
|
|
}
|
|
function getBody({ p256dh, auth, endpoint, vapidKey }) {
|
|
const body = {
|
|
web: {
|
|
endpoint,
|
|
auth,
|
|
p256dh
|
|
}
|
|
};
|
|
if (vapidKey !== DEFAULT_VAPID_KEY) {
|
|
body.web.applicationPubKey = vapidKey;
|
|
}
|
|
return body;
|
|
}
|
|
|
|
/**
|
|
* @license
|
|
* Copyright 2019 Google LLC
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
// UpdateRegistration will be called once every week.
|
|
const TOKEN_EXPIRATION_MS = 7 * 24 * 60 * 60 * 1000; // 7 days
|
|
async function getTokenInternal(messaging) {
|
|
const pushSubscription = await getPushSubscription(messaging.swRegistration, messaging.vapidKey);
|
|
const subscriptionOptions = {
|
|
vapidKey: messaging.vapidKey,
|
|
swScope: messaging.swRegistration.scope,
|
|
endpoint: pushSubscription.endpoint,
|
|
auth: arrayToBase64(pushSubscription.getKey('auth')),
|
|
p256dh: arrayToBase64(pushSubscription.getKey('p256dh'))
|
|
};
|
|
const tokenDetails = await dbGet(messaging.firebaseDependencies);
|
|
if (!tokenDetails) {
|
|
// No token, get a new one.
|
|
return getNewToken(messaging.firebaseDependencies, subscriptionOptions);
|
|
}
|
|
else if (!isTokenValid(tokenDetails.subscriptionOptions, subscriptionOptions)) {
|
|
// Invalid token, get a new one.
|
|
try {
|
|
await requestDeleteToken(messaging.firebaseDependencies, tokenDetails.token);
|
|
}
|
|
catch (e) {
|
|
// Suppress errors because of #2364
|
|
console.warn(e);
|
|
}
|
|
return getNewToken(messaging.firebaseDependencies, subscriptionOptions);
|
|
}
|
|
else if (Date.now() >= tokenDetails.createTime + TOKEN_EXPIRATION_MS) {
|
|
// Weekly token refresh
|
|
return updateToken(messaging, {
|
|
token: tokenDetails.token,
|
|
createTime: Date.now(),
|
|
subscriptionOptions
|
|
});
|
|
}
|
|
else {
|
|
// Valid token, nothing to do.
|
|
return tokenDetails.token;
|
|
}
|
|
}
|
|
/**
|
|
* This method deletes the token from the database, unsubscribes the token from FCM, and unregisters
|
|
* the push subscription if it exists.
|
|
*/
|
|
async function deleteTokenInternal(messaging) {
|
|
const tokenDetails = await dbGet(messaging.firebaseDependencies);
|
|
if (tokenDetails) {
|
|
await requestDeleteToken(messaging.firebaseDependencies, tokenDetails.token);
|
|
await dbRemove(messaging.firebaseDependencies);
|
|
}
|
|
// Unsubscribe from the push subscription.
|
|
const pushSubscription = await messaging.swRegistration.pushManager.getSubscription();
|
|
if (pushSubscription) {
|
|
return pushSubscription.unsubscribe();
|
|
}
|
|
// If there's no SW, consider it a success.
|
|
return true;
|
|
}
|
|
async function updateToken(messaging, tokenDetails) {
|
|
try {
|
|
const updatedToken = await requestUpdateToken(messaging.firebaseDependencies, tokenDetails);
|
|
const updatedTokenDetails = Object.assign(Object.assign({}, tokenDetails), { token: updatedToken, createTime: Date.now() });
|
|
await dbSet(messaging.firebaseDependencies, updatedTokenDetails);
|
|
return updatedToken;
|
|
}
|
|
catch (e) {
|
|
await deleteTokenInternal(messaging);
|
|
throw e;
|
|
}
|
|
}
|
|
async function getNewToken(firebaseDependencies, subscriptionOptions) {
|
|
const token = await requestGetToken(firebaseDependencies, subscriptionOptions);
|
|
const tokenDetails = {
|
|
token,
|
|
createTime: Date.now(),
|
|
subscriptionOptions
|
|
};
|
|
await dbSet(firebaseDependencies, tokenDetails);
|
|
return tokenDetails.token;
|
|
}
|
|
/**
|
|
* Gets a PushSubscription for the current user.
|
|
*/
|
|
async function getPushSubscription(swRegistration, vapidKey) {
|
|
const subscription = await swRegistration.pushManager.getSubscription();
|
|
if (subscription) {
|
|
return subscription;
|
|
}
|
|
return swRegistration.pushManager.subscribe({
|
|
userVisibleOnly: true,
|
|
// Chrome <= 75 doesn't support base64-encoded VAPID key. For backward compatibility, VAPID key
|
|
// submitted to pushManager#subscribe must be of type Uint8Array.
|
|
applicationServerKey: base64ToArray(vapidKey)
|
|
});
|
|
}
|
|
/**
|
|
* Checks if the saved tokenDetails object matches the configuration provided.
|
|
*/
|
|
function isTokenValid(dbOptions, currentOptions) {
|
|
const isVapidKeyEqual = currentOptions.vapidKey === dbOptions.vapidKey;
|
|
const isEndpointEqual = currentOptions.endpoint === dbOptions.endpoint;
|
|
const isAuthEqual = currentOptions.auth === dbOptions.auth;
|
|
const isP256dhEqual = currentOptions.p256dh === dbOptions.p256dh;
|
|
return isVapidKeyEqual && isEndpointEqual && isAuthEqual && isP256dhEqual;
|
|
}
|
|
|
|
/**
|
|
* @license
|
|
* Copyright 2020 Google LLC
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
function externalizePayload(internalPayload) {
|
|
const payload = {
|
|
from: internalPayload.from,
|
|
// eslint-disable-next-line camelcase
|
|
collapseKey: internalPayload.collapse_key,
|
|
// eslint-disable-next-line camelcase
|
|
messageId: internalPayload.fcmMessageId
|
|
};
|
|
propagateNotificationPayload(payload, internalPayload);
|
|
propagateDataPayload(payload, internalPayload);
|
|
propagateFcmOptions(payload, internalPayload);
|
|
return payload;
|
|
}
|
|
function propagateNotificationPayload(payload, messagePayloadInternal) {
|
|
if (!messagePayloadInternal.notification) {
|
|
return;
|
|
}
|
|
payload.notification = {};
|
|
const title = messagePayloadInternal.notification.title;
|
|
if (!!title) {
|
|
payload.notification.title = title;
|
|
}
|
|
const body = messagePayloadInternal.notification.body;
|
|
if (!!body) {
|
|
payload.notification.body = body;
|
|
}
|
|
const image = messagePayloadInternal.notification.image;
|
|
if (!!image) {
|
|
payload.notification.image = image;
|
|
}
|
|
const icon = messagePayloadInternal.notification.icon;
|
|
if (!!icon) {
|
|
payload.notification.icon = icon;
|
|
}
|
|
}
|
|
function propagateDataPayload(payload, messagePayloadInternal) {
|
|
if (!messagePayloadInternal.data) {
|
|
return;
|
|
}
|
|
payload.data = messagePayloadInternal.data;
|
|
}
|
|
function propagateFcmOptions(payload, messagePayloadInternal) {
|
|
var _a, _b, _c, _d, _e;
|
|
// fcmOptions.link value is written into notification.click_action. see more in b/232072111
|
|
if (!messagePayloadInternal.fcmOptions &&
|
|
!((_a = messagePayloadInternal.notification) === null || _a === void 0 ? void 0 : _a.click_action)) {
|
|
return;
|
|
}
|
|
payload.fcmOptions = {};
|
|
const link = (_c = (_b = messagePayloadInternal.fcmOptions) === null || _b === void 0 ? void 0 : _b.link) !== null && _c !== void 0 ? _c : (_d = messagePayloadInternal.notification) === null || _d === void 0 ? void 0 : _d.click_action;
|
|
if (!!link) {
|
|
payload.fcmOptions.link = link;
|
|
}
|
|
// eslint-disable-next-line camelcase
|
|
const analyticsLabel = (_e = messagePayloadInternal.fcmOptions) === null || _e === void 0 ? void 0 : _e.analytics_label;
|
|
if (!!analyticsLabel) {
|
|
payload.fcmOptions.analyticsLabel = analyticsLabel;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @license
|
|
* Copyright 2019 Google LLC
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
function isConsoleMessage(data) {
|
|
// This message has a campaign ID, meaning it was sent using the Firebase Console.
|
|
return typeof data === 'object' && !!data && CONSOLE_CAMPAIGN_ID in data;
|
|
}
|
|
|
|
/**
|
|
* @license
|
|
* Copyright 2019 Google LLC
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
_mergeStrings('hts/frbslgigp.ogepscmv/ieo/eaylg', 'tp:/ieaeogn-agolai.o/1frlglgc/o');
|
|
_mergeStrings('AzSCbw63g1R0nCw85jG8', 'Iaya3yLKwmgvh7cF0q4');
|
|
function _mergeStrings(s1, s2) {
|
|
const resultArray = [];
|
|
for (let i = 0; i < s1.length; i++) {
|
|
resultArray.push(s1.charAt(i));
|
|
if (i < s2.length) {
|
|
resultArray.push(s2.charAt(i));
|
|
}
|
|
}
|
|
return resultArray.join('');
|
|
}
|
|
|
|
/**
|
|
* @license
|
|
* Copyright 2019 Google LLC
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
function extractAppConfig(app) {
|
|
if (!app || !app.options) {
|
|
throw getMissingValueError('App Configuration Object');
|
|
}
|
|
if (!app.name) {
|
|
throw getMissingValueError('App Name');
|
|
}
|
|
// Required app config keys
|
|
const configKeys = [
|
|
'projectId',
|
|
'apiKey',
|
|
'appId',
|
|
'messagingSenderId'
|
|
];
|
|
const { options } = app;
|
|
for (const keyName of configKeys) {
|
|
if (!options[keyName]) {
|
|
throw getMissingValueError(keyName);
|
|
}
|
|
}
|
|
return {
|
|
appName: app.name,
|
|
projectId: options.projectId,
|
|
apiKey: options.apiKey,
|
|
appId: options.appId,
|
|
senderId: options.messagingSenderId
|
|
};
|
|
}
|
|
function getMissingValueError(valueName) {
|
|
return ERROR_FACTORY.create("missing-app-config-values" /* ErrorCode.MISSING_APP_CONFIG_VALUES */, {
|
|
valueName
|
|
});
|
|
}
|
|
|
|
/**
|
|
* @license
|
|
* Copyright 2020 Google LLC
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
class MessagingService {
|
|
constructor(app, installations, analyticsProvider) {
|
|
// logging is only done with end user consent. Default to false.
|
|
this.deliveryMetricsExportedToBigQueryEnabled = false;
|
|
this.onBackgroundMessageHandler = null;
|
|
this.onMessageHandler = null;
|
|
this.logEvents = [];
|
|
this.isLogServiceStarted = false;
|
|
const appConfig = extractAppConfig(app);
|
|
this.firebaseDependencies = {
|
|
app,
|
|
appConfig,
|
|
installations,
|
|
analyticsProvider
|
|
};
|
|
}
|
|
_delete() {
|
|
return Promise.resolve();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @license
|
|
* Copyright 2020 Google LLC
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
async function registerDefaultSw(messaging) {
|
|
try {
|
|
messaging.swRegistration = await navigator.serviceWorker.register(DEFAULT_SW_PATH, {
|
|
scope: DEFAULT_SW_SCOPE
|
|
});
|
|
// The timing when browser updates sw when sw has an update is unreliable from experiment. It
|
|
// leads to version conflict when the SDK upgrades to a newer version in the main page, but sw
|
|
// is stuck with the old version. For example,
|
|
// https://github.com/firebase/firebase-js-sdk/issues/2590 The following line reliably updates
|
|
// sw if there was an update.
|
|
messaging.swRegistration.update().catch(() => {
|
|
/* it is non blocking and we don't care if it failed */
|
|
});
|
|
}
|
|
catch (e) {
|
|
throw ERROR_FACTORY.create("failed-service-worker-registration" /* ErrorCode.FAILED_DEFAULT_REGISTRATION */, {
|
|
browserErrorMessage: e === null || e === void 0 ? void 0 : e.message
|
|
});
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @license
|
|
* Copyright 2020 Google LLC
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
async function updateSwReg(messaging, swRegistration) {
|
|
if (!swRegistration && !messaging.swRegistration) {
|
|
await registerDefaultSw(messaging);
|
|
}
|
|
if (!swRegistration && !!messaging.swRegistration) {
|
|
return;
|
|
}
|
|
if (!(swRegistration instanceof ServiceWorkerRegistration)) {
|
|
throw ERROR_FACTORY.create("invalid-sw-registration" /* ErrorCode.INVALID_SW_REGISTRATION */);
|
|
}
|
|
messaging.swRegistration = swRegistration;
|
|
}
|
|
|
|
/**
|
|
* @license
|
|
* Copyright 2020 Google LLC
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
async function updateVapidKey(messaging, vapidKey) {
|
|
if (!!vapidKey) {
|
|
messaging.vapidKey = vapidKey;
|
|
}
|
|
else if (!messaging.vapidKey) {
|
|
messaging.vapidKey = DEFAULT_VAPID_KEY;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @license
|
|
* Copyright 2020 Google LLC
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
async function getToken$1(messaging, options) {
|
|
if (!navigator) {
|
|
throw ERROR_FACTORY.create("only-available-in-window" /* ErrorCode.AVAILABLE_IN_WINDOW */);
|
|
}
|
|
if (Notification.permission === 'default') {
|
|
await Notification.requestPermission();
|
|
}
|
|
if (Notification.permission !== 'granted') {
|
|
throw ERROR_FACTORY.create("permission-blocked" /* ErrorCode.PERMISSION_BLOCKED */);
|
|
}
|
|
await updateVapidKey(messaging, options === null || options === void 0 ? void 0 : options.vapidKey);
|
|
await updateSwReg(messaging, options === null || options === void 0 ? void 0 : options.serviceWorkerRegistration);
|
|
return getTokenInternal(messaging);
|
|
}
|
|
|
|
/**
|
|
* @license
|
|
* Copyright 2019 Google LLC
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
async function logToScion(messaging, messageType, data) {
|
|
const eventType = getEventType(messageType);
|
|
const analytics = await messaging.firebaseDependencies.analyticsProvider.get();
|
|
analytics.logEvent(eventType, {
|
|
/* eslint-disable camelcase */
|
|
message_id: data[CONSOLE_CAMPAIGN_ID],
|
|
message_name: data[CONSOLE_CAMPAIGN_NAME],
|
|
message_time: data[CONSOLE_CAMPAIGN_TIME],
|
|
message_device_time: Math.floor(Date.now() / 1000)
|
|
/* eslint-enable camelcase */
|
|
});
|
|
}
|
|
function getEventType(messageType) {
|
|
switch (messageType) {
|
|
case MessageType.NOTIFICATION_CLICKED:
|
|
return 'notification_open';
|
|
case MessageType.PUSH_RECEIVED:
|
|
return 'notification_foreground';
|
|
default:
|
|
throw new Error();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @license
|
|
* Copyright 2017 Google LLC
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
async function messageEventListener(messaging, event) {
|
|
const internalPayload = event.data;
|
|
if (!internalPayload.isFirebaseMessaging) {
|
|
return;
|
|
}
|
|
if (messaging.onMessageHandler &&
|
|
internalPayload.messageType === MessageType.PUSH_RECEIVED) {
|
|
if (typeof messaging.onMessageHandler === 'function') {
|
|
messaging.onMessageHandler(externalizePayload(internalPayload));
|
|
}
|
|
else {
|
|
messaging.onMessageHandler.next(externalizePayload(internalPayload));
|
|
}
|
|
}
|
|
// Log to Scion if applicable
|
|
const dataPayload = internalPayload.data;
|
|
if (isConsoleMessage(dataPayload) &&
|
|
dataPayload[CONSOLE_CAMPAIGN_ANALYTICS_ENABLED] === '1') {
|
|
await logToScion(messaging, internalPayload.messageType, dataPayload);
|
|
}
|
|
}
|
|
|
|
const name = "@firebase/messaging";
|
|
const version = "0.12.1";
|
|
|
|
/**
|
|
* @license
|
|
* Copyright 2020 Google LLC
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
const WindowMessagingFactory = (container) => {
|
|
const messaging = new MessagingService(container.getProvider('app').getImmediate(), container.getProvider('installations-internal').getImmediate(), container.getProvider('analytics-internal'));
|
|
navigator.serviceWorker.addEventListener('message', e => messageEventListener(messaging, e));
|
|
return messaging;
|
|
};
|
|
const WindowMessagingInternalFactory = (container) => {
|
|
const messaging = container
|
|
.getProvider('messaging')
|
|
.getImmediate();
|
|
const messagingInternal = {
|
|
getToken: (options) => getToken$1(messaging, options)
|
|
};
|
|
return messagingInternal;
|
|
};
|
|
function registerMessagingInWindow() {
|
|
_registerComponent(new Component('messaging', WindowMessagingFactory, "PUBLIC" /* ComponentType.PUBLIC */));
|
|
_registerComponent(new Component('messaging-internal', WindowMessagingInternalFactory, "PRIVATE" /* ComponentType.PRIVATE */));
|
|
registerVersion(name, version);
|
|
// BUILD_TARGET will be replaced by values like esm5, esm2017, cjs5, etc during the compilation
|
|
registerVersion(name, version, 'esm2017');
|
|
}
|
|
|
|
/**
|
|
* @license
|
|
* Copyright 2020 Google LLC
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
/**
|
|
* Checks if all required APIs exist in the browser.
|
|
* @returns a Promise that resolves to a boolean.
|
|
*
|
|
* @public
|
|
*/
|
|
async function isWindowSupported() {
|
|
try {
|
|
// This throws if open() is unsupported, so adding it to the conditional
|
|
// statement below can cause an uncaught error.
|
|
await validateIndexedDBOpenable();
|
|
}
|
|
catch (e) {
|
|
return false;
|
|
}
|
|
// firebase-js-sdk/issues/2393 reveals that idb#open in Safari iframe and Firefox private browsing
|
|
// might be prohibited to run. In these contexts, an error would be thrown during the messaging
|
|
// instantiating phase, informing the developers to import/call isSupported for special handling.
|
|
return (typeof window !== 'undefined' &&
|
|
isIndexedDBAvailable() &&
|
|
areCookiesEnabled() &&
|
|
'serviceWorker' in navigator &&
|
|
'PushManager' in window &&
|
|
'Notification' in window &&
|
|
'fetch' in window &&
|
|
ServiceWorkerRegistration.prototype.hasOwnProperty('showNotification') &&
|
|
PushSubscription.prototype.hasOwnProperty('getKey'));
|
|
}
|
|
|
|
/**
|
|
* @license
|
|
* Copyright 2020 Google LLC
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
async function deleteToken$1(messaging) {
|
|
if (!navigator) {
|
|
throw ERROR_FACTORY.create("only-available-in-window" /* ErrorCode.AVAILABLE_IN_WINDOW */);
|
|
}
|
|
if (!messaging.swRegistration) {
|
|
await registerDefaultSw(messaging);
|
|
}
|
|
return deleteTokenInternal(messaging);
|
|
}
|
|
|
|
/**
|
|
* @license
|
|
* Copyright 2020 Google LLC
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
function onMessage$1(messaging, nextOrObserver) {
|
|
if (!navigator) {
|
|
throw ERROR_FACTORY.create("only-available-in-window" /* ErrorCode.AVAILABLE_IN_WINDOW */);
|
|
}
|
|
messaging.onMessageHandler = nextOrObserver;
|
|
return () => {
|
|
messaging.onMessageHandler = null;
|
|
};
|
|
}
|
|
|
|
/**
|
|
* @license
|
|
* Copyright 2017 Google LLC
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
/**
|
|
* Retrieves a Firebase Cloud Messaging instance.
|
|
*
|
|
* @returns The Firebase Cloud Messaging instance associated with the provided firebase app.
|
|
*
|
|
* @public
|
|
*/
|
|
function getMessagingInWindow(app = getApp()) {
|
|
// Conscious decision to make this async check non-blocking during the messaging instance
|
|
// initialization phase for performance consideration. An error would be thrown latter for
|
|
// developer's information. Developers can then choose to import and call `isSupported` for
|
|
// special handling.
|
|
isWindowSupported().then(isSupported => {
|
|
// If `isWindowSupported()` resolved, but returned false.
|
|
if (!isSupported) {
|
|
throw ERROR_FACTORY.create("unsupported-browser" /* ErrorCode.UNSUPPORTED_BROWSER */);
|
|
}
|
|
}, _ => {
|
|
// If `isWindowSupported()` rejected.
|
|
throw ERROR_FACTORY.create("indexed-db-unsupported" /* ErrorCode.INDEXED_DB_UNSUPPORTED */);
|
|
});
|
|
return _getProvider(getModularInstance(app), 'messaging').getImmediate();
|
|
}
|
|
/**
|
|
* Subscribes the {@link Messaging} instance to push notifications. Returns an Firebase Cloud
|
|
* Messaging registration token that can be used to send push messages to that {@link Messaging}
|
|
* instance.
|
|
*
|
|
* If a notification permission isn't already granted, this method asks the user for permission. The
|
|
* returned promise rejects if the user does not allow the app to show notifications.
|
|
*
|
|
* @param messaging - The {@link Messaging} instance.
|
|
* @param options - Provides an optional vapid key and an optinoal service worker registration
|
|
*
|
|
* @returns The promise resolves with an FCM registration token.
|
|
*
|
|
* @public
|
|
*/
|
|
async function getToken(messaging, options) {
|
|
messaging = getModularInstance(messaging);
|
|
return getToken$1(messaging, options);
|
|
}
|
|
/**
|
|
* Deletes the registration token associated with this {@link Messaging} instance and unsubscribes
|
|
* the {@link Messaging} instance from the push subscription.
|
|
*
|
|
* @param messaging - The {@link Messaging} instance.
|
|
*
|
|
* @returns The promise resolves when the token has been successfully deleted.
|
|
*
|
|
* @public
|
|
*/
|
|
function deleteToken(messaging) {
|
|
messaging = getModularInstance(messaging);
|
|
return deleteToken$1(messaging);
|
|
}
|
|
/**
|
|
* When a push message is received and the user is currently on a page for your origin, the
|
|
* message is passed to the page and an `onMessage()` event is dispatched with the payload of
|
|
* the push message.
|
|
*
|
|
*
|
|
* @param messaging - The {@link Messaging} instance.
|
|
* @param nextOrObserver - This function, or observer object with `next` defined,
|
|
* is called when a message is received and the user is currently viewing your page.
|
|
* @returns To stop listening for messages execute this returned function.
|
|
*
|
|
* @public
|
|
*/
|
|
function onMessage(messaging, nextOrObserver) {
|
|
messaging = getModularInstance(messaging);
|
|
return onMessage$1(messaging, nextOrObserver);
|
|
}
|
|
|
|
/**
|
|
* Firebase Cloud Messaging
|
|
*
|
|
* @packageDocumentation
|
|
*/
|
|
registerMessagingInWindow();
|
|
|
|
export { deleteToken, getMessagingInWindow as getMessaging, getToken, isWindowSupported as isSupported, onMessage };
|
|
//# sourceMappingURL=index.esm2017.js.map
|