1021 lines
36 KiB
TypeScript
1021 lines
36 KiB
TypeScript
// (C) Copyright 2015 Moodle Pty Ltd.
|
|
//
|
|
// 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.
|
|
|
|
import { Injectable } from '@angular/core';
|
|
import { ILocalNotification } from '@awesome-cordova-plugins/local-notifications';
|
|
import { NotificationEventResponse, PushOptions, RegistrationEventResponse } from '@awesome-cordova-plugins/push/ngx';
|
|
|
|
import { CoreApp } from '@services/app';
|
|
import { CoreSites } from '@services/sites';
|
|
import { CorePushNotificationsDelegate } from './push-delegate';
|
|
import { CoreLocalNotifications } from '@services/local-notifications';
|
|
import { CoreUtils } from '@services/utils/utils';
|
|
import { CoreTextUtils } from '@services/utils/text';
|
|
import { CoreConfig } from '@services/config';
|
|
import { CoreConstants } from '@/core/constants';
|
|
import { CoreSite } from '@classes/sites/site';
|
|
import { makeSingleton, Badge, Device, Translate, ApplicationInit, NgZone } from '@singletons';
|
|
import { CoreLogger } from '@singletons/logger';
|
|
import { CoreEvents } from '@singletons/events';
|
|
import {
|
|
APP_SCHEMA,
|
|
BADGE_TABLE_NAME,
|
|
PENDING_UNREGISTER_TABLE_NAME,
|
|
REGISTERED_DEVICES_TABLE_NAME,
|
|
CorePushNotificationsPendingUnregisterDBRecord,
|
|
CorePushNotificationsRegisteredDeviceDBRecord,
|
|
CorePushNotificationsBadgeDBRecord,
|
|
} from './database/pushnotifications';
|
|
import { CoreError } from '@classes/errors/error';
|
|
import { CoreWSExternalWarning } from '@services/ws';
|
|
import { CoreSitesFactory } from '@services/sites-factory';
|
|
import { CoreMainMenuProvider } from '@features/mainmenu/services/mainmenu';
|
|
import { AsyncInstance, asyncInstance } from '@/core/utils/async-instance';
|
|
import { CoreDatabaseTable } from '@classes/database/database-table';
|
|
import { CoreDatabaseCachingStrategy, CoreDatabaseTableProxy } from '@classes/database/database-table-proxy';
|
|
import { CoreObject } from '@singletons/object';
|
|
import { lazyMap, LazyMap } from '@/core/utils/lazy-map';
|
|
import { CorePlatform } from '@services/platform';
|
|
import { CoreAnalytics, CoreAnalyticsEventType } from '@services/analytics';
|
|
import { CoreSiteInfo } from '@classes/sites/unauthenticated-site';
|
|
import { Push } from '@features/native/plugins';
|
|
|
|
/**
|
|
* Service to handle push notifications.
|
|
*/
|
|
@Injectable({ providedIn: 'root' })
|
|
export class CorePushNotificationsProvider {
|
|
|
|
static readonly COMPONENT = 'CorePushNotificationsProvider';
|
|
|
|
protected logger: CoreLogger;
|
|
protected pushID?: string;
|
|
protected badgesTable = asyncInstance<CoreDatabaseTable<CorePushNotificationsBadgeDBRecord, 'siteid' | 'addon'>>();
|
|
protected pendingUnregistersTable =
|
|
asyncInstance<CoreDatabaseTable<CorePushNotificationsPendingUnregisterDBRecord, 'siteid'>>();
|
|
|
|
protected registeredDevicesTables:
|
|
LazyMap<AsyncInstance<CoreDatabaseTable<CorePushNotificationsRegisteredDeviceDBRecord, 'appid' | 'uuid'>>>;
|
|
|
|
constructor() {
|
|
this.logger = CoreLogger.getInstance('CorePushNotificationsProvider');
|
|
this.registeredDevicesTables = lazyMap(
|
|
siteId => asyncInstance(
|
|
() => CoreSites.getSiteTable(
|
|
REGISTERED_DEVICES_TABLE_NAME,
|
|
{
|
|
siteId,
|
|
config: { cachingStrategy: CoreDatabaseCachingStrategy.None },
|
|
primaryKeyColumns: ['appid', 'uuid'],
|
|
onDestroy: () => delete this.registeredDevicesTables[siteId],
|
|
},
|
|
),
|
|
),
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Initialize the service.
|
|
*
|
|
* @returns Promise resolved when done.
|
|
*/
|
|
async initialize(): Promise<void> {
|
|
await Promise.all([
|
|
this.initializeDatabase(),
|
|
this.initializeDefaultChannel(),
|
|
]);
|
|
|
|
// Now register the device to receive push notifications. Don't block for this.
|
|
this.registerDevice();
|
|
|
|
CoreEvents.on(CoreEvents.NOTIFICATION_SOUND_CHANGED, () => {
|
|
// Notification sound has changed, register the device again to update the sound setting.
|
|
this.registerDevice();
|
|
});
|
|
|
|
// Register device on Moodle site when login.
|
|
CoreEvents.on(CoreEvents.LOGIN, async () => {
|
|
if (!this.canRegisterOnMoodle()) {
|
|
return;
|
|
}
|
|
|
|
try {
|
|
await this.registerDeviceOnMoodle();
|
|
} catch (error) {
|
|
this.logger.error('Can\'t register device', error);
|
|
}
|
|
});
|
|
|
|
CoreEvents.on(CoreEvents.SITE_DELETED, async (site) => {
|
|
try {
|
|
await Promise.all([
|
|
this.unregisterDeviceOnMoodle(site),
|
|
this.cleanSiteCounters(site.getId()),
|
|
]);
|
|
} catch (error) {
|
|
this.logger.warn('Can\'t unregister device', error);
|
|
}
|
|
});
|
|
|
|
CoreEvents.on(CoreMainMenuProvider.MAIN_MENU_HANDLER_BADGE_UPDATED, (data) => {
|
|
this.updateAddonCounter(data.handler, data.value, data.siteId);
|
|
});
|
|
|
|
// Listen for local notification clicks (generated by the app).
|
|
CoreLocalNotifications.registerClick<CorePushNotificationsNotificationBasicData>(
|
|
CorePushNotificationsProvider.COMPONENT,
|
|
(notification) => {
|
|
CoreAnalytics.logEvent({
|
|
eventName: 'moodle_notification_open',
|
|
type: CoreAnalyticsEventType.PUSH_NOTIFICATION,
|
|
data: notification,
|
|
});
|
|
|
|
this.notificationClicked(notification);
|
|
},
|
|
);
|
|
|
|
// Listen for local notification dismissed events.
|
|
CoreLocalNotifications.registerObserver<CorePushNotificationsNotificationBasicData>(
|
|
'clear',
|
|
CorePushNotificationsProvider.COMPONENT,
|
|
(notification) => {
|
|
CoreAnalytics.logEvent({
|
|
eventName: 'moodle_notification_dismiss',
|
|
type: CoreAnalyticsEventType.PUSH_NOTIFICATION,
|
|
data: notification,
|
|
});
|
|
},
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Initialize the default channel for Android.
|
|
*
|
|
* @returns Promise resolved when done.
|
|
*/
|
|
protected async initializeDefaultChannel(): Promise<void> {
|
|
await CorePlatform.ready();
|
|
|
|
// Create the default channel.
|
|
this.createDefaultChannel();
|
|
|
|
Translate.onLangChange.subscribe(() => {
|
|
// Update the channel name.
|
|
this.createDefaultChannel();
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Initialize database.
|
|
*
|
|
* @returns Promise resolved when done.
|
|
*/
|
|
protected async initializeDatabase(): Promise<void> {
|
|
try {
|
|
await CoreApp.createTablesFromSchema(APP_SCHEMA);
|
|
} catch (e) {
|
|
// Ignore errors.
|
|
}
|
|
|
|
const database = CoreApp.getDB();
|
|
const badgesTable = new CoreDatabaseTableProxy<CorePushNotificationsBadgeDBRecord, 'siteid' | 'addon'>(
|
|
{ cachingStrategy: CoreDatabaseCachingStrategy.Eager },
|
|
database,
|
|
BADGE_TABLE_NAME,
|
|
['siteid', 'addon'],
|
|
);
|
|
const pendingUnregistersTable = new CoreDatabaseTableProxy<CorePushNotificationsPendingUnregisterDBRecord, 'siteid'>(
|
|
{ cachingStrategy: CoreDatabaseCachingStrategy.Eager },
|
|
database,
|
|
PENDING_UNREGISTER_TABLE_NAME,
|
|
['siteid'],
|
|
);
|
|
|
|
await Promise.all([
|
|
badgesTable.initialize(),
|
|
pendingUnregistersTable.initialize(),
|
|
]);
|
|
|
|
this.badgesTable.setInstance(badgesTable);
|
|
this.pendingUnregistersTable.setInstance(pendingUnregistersTable);
|
|
}
|
|
|
|
/**
|
|
* Check whether the device can be registered in Moodle to receive push notifications.
|
|
*
|
|
* @returns Whether the device can be registered in Moodle.
|
|
*/
|
|
canRegisterOnMoodle(): boolean {
|
|
return !!this.pushID && CorePlatform.isMobile();
|
|
}
|
|
|
|
/**
|
|
* Delete all badge records for a given site.
|
|
*
|
|
* @param siteId Site ID.
|
|
* @returns Resolved when done.
|
|
*/
|
|
async cleanSiteCounters(siteId: string): Promise<void> {
|
|
try {
|
|
await this.badgesTable.delete({ siteid: siteId });
|
|
} finally {
|
|
this.updateAppCounter();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Create the default push channel. It is used to change the name.
|
|
*
|
|
* @returns Promise resolved when done.
|
|
*/
|
|
protected async createDefaultChannel(): Promise<void> {
|
|
if (!CorePlatform.isAndroid()) {
|
|
return;
|
|
}
|
|
|
|
try {
|
|
await Push.createChannel({
|
|
id: 'PushPluginChannel',
|
|
description: Translate.instant('core.misc'),
|
|
importance: 4,
|
|
});
|
|
} catch (error) {
|
|
this.logger.error('Error changing push channel name', error);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Enable or disable analytics.
|
|
*
|
|
* @param enable Whether to enable or disable.
|
|
* @returns Promise resolved when done.
|
|
* @deprecated since 4.3. Use CoreAnalytics.enableAnalytics instead.
|
|
*/
|
|
async enableAnalytics(enable: boolean): Promise<void> {
|
|
return CoreAnalytics.enableAnalytics(enable);
|
|
}
|
|
|
|
/**
|
|
* Returns options for push notifications based on device.
|
|
*
|
|
* @returns Promise with the push options resolved when done.
|
|
*/
|
|
protected async getOptions(): Promise<PushOptions> {
|
|
let soundEnabled = true;
|
|
|
|
if (CoreLocalNotifications.canDisableSound()) {
|
|
soundEnabled = await CoreConfig.get<boolean>(CoreConstants.SETTINGS_NOTIFICATION_SOUND, true);
|
|
}
|
|
|
|
return {
|
|
android: {
|
|
sound: !!soundEnabled,
|
|
icon: 'smallicon',
|
|
iconColor: CoreConstants.CONFIG.notificoncolor,
|
|
},
|
|
ios: {
|
|
alert: 'true',
|
|
badge: true,
|
|
sound: !!soundEnabled,
|
|
},
|
|
windows: {
|
|
sound: !!soundEnabled,
|
|
},
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Get the pushID for this device.
|
|
*
|
|
* @returns Push ID.
|
|
*/
|
|
getPushId(): string | undefined {
|
|
return this.pushID;
|
|
}
|
|
|
|
/**
|
|
* Get required data to register the device in Moodle.
|
|
*
|
|
* @returns Data.
|
|
*/
|
|
protected getRequiredRegisterData(): CoreUserAddUserDeviceWSParams {
|
|
if (!this.pushID) {
|
|
throw new CoreError('Cannot get register data because pushID is not set.');
|
|
}
|
|
|
|
return {
|
|
appid: CoreConstants.CONFIG.app_id,
|
|
name: Device.manufacturer || '',
|
|
model: Device.model,
|
|
platform: Device.platform + '-fcm',
|
|
version: Device.version,
|
|
pushid: this.pushID,
|
|
uuid: Device.uuid,
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Get Sitebadge counter from the database.
|
|
*
|
|
* @param siteId Site ID.
|
|
* @returns Promise resolved with the stored badge counter for the site.
|
|
*/
|
|
getSiteCounter(siteId: string): Promise<number> {
|
|
return this.getAddonBadge(siteId);
|
|
}
|
|
|
|
/**
|
|
* Log an analytics event.
|
|
*
|
|
* @param eventName Name of the event.
|
|
* @param data Data of the event.
|
|
* @returns Promise resolved when done. This promise is never rejected.
|
|
* @deprecated since 4.3. Use CoreAnalytics.logEvent instead.
|
|
*/
|
|
async logEvent(eventName: string, data: Record<string, string | number | boolean | undefined>): Promise<void> {
|
|
if (eventName !== 'view_item' && eventName !== 'view_item_list') {
|
|
return CoreAnalytics.logEvent({
|
|
type: CoreAnalyticsEventType.PUSH_NOTIFICATION,
|
|
eventName,
|
|
data,
|
|
});
|
|
}
|
|
|
|
const name = data.name ? String(data.name) : '';
|
|
delete data.name;
|
|
|
|
return CoreAnalytics.logEvent({
|
|
type: eventName === 'view_item' ? CoreAnalyticsEventType.VIEW_ITEM : CoreAnalyticsEventType.VIEW_ITEM_LIST,
|
|
ws: <string> data.moodleaction ?? '',
|
|
name,
|
|
data,
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Log an analytics VIEW_ITEM_LIST event.
|
|
*
|
|
* @param itemId The item ID.
|
|
* @param itemName The item name.
|
|
* @param itemCategory The item category.
|
|
* @param wsName Name of the WS.
|
|
* @param data Other data to pass to the event.
|
|
* @returns Promise resolved when done. This promise is never rejected.
|
|
* @deprecated since 4.3. Use CoreAnalytics.logEvent instead.
|
|
*/
|
|
logViewEvent(
|
|
itemId: number | string | undefined,
|
|
itemName: string | undefined,
|
|
itemCategory: string | undefined,
|
|
wsName: string,
|
|
data?: Record<string, string | number | boolean | undefined>,
|
|
): Promise<void> {
|
|
data = data || {};
|
|
data.id = itemId;
|
|
data.name = itemName;
|
|
data.category = itemCategory;
|
|
data.moodleaction = wsName;
|
|
|
|
// eslint-disable-next-line deprecation/deprecation
|
|
return this.logEvent('view_item', data);
|
|
}
|
|
|
|
/**
|
|
* Log an analytics view item list event.
|
|
*
|
|
* @param itemCategory The item category.
|
|
* @param wsName Name of the WS.
|
|
* @param data Other data to pass to the event.
|
|
* @returns Promise resolved when done. This promise is never rejected.
|
|
* @deprecated since 4.3. Use CoreAnalytics.logEvent instead.
|
|
*/
|
|
logViewListEvent(
|
|
itemCategory: string,
|
|
wsName: string,
|
|
data?: Record<string, string | number | boolean | undefined>,
|
|
): Promise<void> {
|
|
data = data || {};
|
|
data.moodleaction = wsName;
|
|
data.category = itemCategory;
|
|
|
|
// eslint-disable-next-line deprecation/deprecation
|
|
return this.logEvent('view_item_list', data);
|
|
}
|
|
|
|
/**
|
|
* Function called when a push notification is clicked. Redirect the user to the right state.
|
|
*
|
|
* @param data Notification data.
|
|
* @returns Promise resolved when done.
|
|
*/
|
|
async notificationClicked(data: CorePushNotificationsNotificationBasicData): Promise<void> {
|
|
await ApplicationInit.donePromise;
|
|
|
|
CorePushNotificationsDelegate.clicked(data);
|
|
}
|
|
|
|
/**
|
|
* This function is called when we receive a Notification from APNS or a message notification from GCM.
|
|
* The app can be in foreground or background,
|
|
* if we are in background this code is executed when we open the app clicking in the notification bar.
|
|
*
|
|
* @param notification Notification received.
|
|
* @returns Promise resolved when done.
|
|
*/
|
|
async onMessageReceived(notification: NotificationEventResponse): Promise<void> {
|
|
const rawData: CorePushNotificationsNotificationBasicRawData = notification ? notification.additionalData : {};
|
|
|
|
// Parse some fields and add some extra data.
|
|
const data: CorePushNotificationsNotificationBasicData = Object.assign(rawData, {
|
|
title: notification.title,
|
|
message: notification.message,
|
|
customdata: typeof rawData.customdata == 'string' ?
|
|
CoreTextUtils.parseJSON<Record<string, string|number>>(rawData.customdata, {}) : rawData.customdata,
|
|
});
|
|
|
|
let site: CoreSite | undefined;
|
|
|
|
if (data.site) {
|
|
site = await CoreSites.getSite(data.site);
|
|
} else if (data.siteurl) {
|
|
site = await CoreSites.getSiteByUrl(data.siteurl);
|
|
}
|
|
|
|
data.site = site?.getId();
|
|
|
|
if (!CoreUtils.isTrueOrOne(data.foreground)) {
|
|
// The notification was clicked.
|
|
return this.notificationClicked(data);
|
|
}
|
|
|
|
const localNotif: ILocalNotification = {
|
|
id: Number(data.notId) || 1,
|
|
data: data,
|
|
title: notification.title,
|
|
text: notification.message,
|
|
channel: 'PushPluginChannel',
|
|
};
|
|
const isAndroid = CorePlatform.isAndroid();
|
|
const extraFeatures = CoreUtils.isTrueOrOne(data.extrafeatures);
|
|
|
|
if (extraFeatures && isAndroid && CoreUtils.isFalseOrZero(data.notif)) {
|
|
// It's a message, use messaging style. Ionic Native doesn't specify this option.
|
|
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
(<any> localNotif).text = [
|
|
{
|
|
message: notification.message,
|
|
person: data.sender ?? (data.conversationtype == '2' ? data.userfromfullname : ''),
|
|
personIcon: data.senderImage,
|
|
},
|
|
];
|
|
}
|
|
|
|
if (extraFeatures && isAndroid) {
|
|
// Use a different icon if needed.
|
|
localNotif.icon = notification.image;
|
|
// This feature isn't supported by the official plugin, we use a fork.
|
|
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
(<any> localNotif).iconType = data['image-type'];
|
|
|
|
localNotif.summary = data.summaryText;
|
|
|
|
if (data.picture) {
|
|
localNotif.attachments = [data.picture];
|
|
}
|
|
}
|
|
|
|
CoreLocalNotifications.schedule(localNotif, CorePushNotificationsProvider.COMPONENT, data.site || '', true);
|
|
|
|
await this.notifyReceived(notification, data);
|
|
|
|
}
|
|
|
|
/**
|
|
* Notify that a notification was received.
|
|
*
|
|
* @param notification Notification.
|
|
* @param data Notification data.
|
|
* @returns Promise resolved when done.
|
|
*/
|
|
protected async notifyReceived(
|
|
notification: NotificationEventResponse,
|
|
data: CorePushNotificationsNotificationBasicData,
|
|
): Promise<void> {
|
|
await ApplicationInit.donePromise;
|
|
|
|
CorePushNotificationsDelegate.received(data);
|
|
}
|
|
|
|
/**
|
|
* Unregisters a device from a certain Moodle site.
|
|
*
|
|
* @param site Site to unregister from.
|
|
* @returns Promise resolved when device is unregistered.
|
|
*/
|
|
async unregisterDeviceOnMoodle(site: CoreSite): Promise<void> {
|
|
if (!site || !CorePlatform.isMobile()) {
|
|
throw new CoreError('Cannot unregister device');
|
|
}
|
|
|
|
this.logger.debug(`Unregister device on Moodle: '${site.getId()}'`);
|
|
|
|
const data: CoreUserRemoveUserDeviceWSParams = {
|
|
appid: CoreConstants.CONFIG.app_id,
|
|
uuid: Device.uuid,
|
|
};
|
|
let response: CoreUserRemoveUserDeviceWSResponse;
|
|
|
|
try {
|
|
response = await site.write<CoreUserRemoveUserDeviceWSResponse>('core_user_remove_user_device', data);
|
|
} catch (error) {
|
|
if (CoreUtils.isWebServiceError(error) || CoreUtils.isExpiredTokenError(error)) {
|
|
// Cannot unregister. Don't try again.
|
|
await CoreUtils.ignoreErrors(this.pendingUnregistersTable.delete({
|
|
token: site.getToken(),
|
|
siteid: site.getId(),
|
|
}));
|
|
|
|
throw error;
|
|
}
|
|
|
|
// Store the pending unregister so it's retried again later.
|
|
await this.pendingUnregistersTable.insert({
|
|
siteid: site.getId(),
|
|
siteurl: site.getURL(),
|
|
token: site.getToken(),
|
|
info: JSON.stringify(site.getInfo()),
|
|
});
|
|
|
|
return;
|
|
}
|
|
|
|
if (!response.removed) {
|
|
throw new CoreError('Cannot unregister device');
|
|
}
|
|
|
|
await CoreUtils.ignoreErrors(Promise.all([
|
|
// Remove the device from the local DB.
|
|
this.registeredDevicesTables[site.getId()].delete(this.getRequiredRegisterData()),
|
|
// Remove pending unregisters for this site.
|
|
this.pendingUnregistersTable.deleteByPrimaryKey({ siteid: site.getId() }),
|
|
]));
|
|
}
|
|
|
|
/**
|
|
* Update Counter for an addon. It will update the refered siteId counter and the total badge.
|
|
* It will return the updated addon counter.
|
|
*
|
|
* @param addon Registered addon name to set the badge number.
|
|
* @param value The number to be stored.
|
|
* @param siteId Site ID. If not defined, use current site.
|
|
* @returns Promise resolved with the stored badge counter for the addon on the site.
|
|
*/
|
|
async updateAddonCounter(addon: string, value: number, siteId?: string): Promise<number> {
|
|
if (!CorePushNotificationsDelegate.isCounterHandlerRegistered(addon)) {
|
|
return 0;
|
|
}
|
|
|
|
siteId = siteId || CoreSites.getCurrentSiteId();
|
|
|
|
await this.saveAddonBadge(value, siteId, addon);
|
|
await this.updateSiteCounter(siteId);
|
|
|
|
return value;
|
|
}
|
|
|
|
/**
|
|
* Update total badge counter of the app.
|
|
*
|
|
* @returns Promise resolved with the stored badge counter for the site.
|
|
*/
|
|
async updateAppCounter(): Promise<number> {
|
|
const sitesIds = await CoreSites.getSitesIds();
|
|
|
|
const counters = await Promise.all(sitesIds.map((siteId) => this.getAddonBadge(siteId)));
|
|
|
|
const total = counters.reduce((previous, counter) => previous + counter, 0);
|
|
|
|
if (CorePlatform.isMobile()) {
|
|
// Set the app badge on mobile.
|
|
await Badge.set(total);
|
|
}
|
|
|
|
return total;
|
|
}
|
|
|
|
/**
|
|
* Update counter for a site using the stored addon data. It will update the total badge application number.
|
|
* It will return the updated site counter.
|
|
*
|
|
* @param siteId Site ID.
|
|
* @returns Promise resolved with the stored badge counter for the site.
|
|
*/
|
|
async updateSiteCounter(siteId: string): Promise<number> {
|
|
const addons = CorePushNotificationsDelegate.getCounterHandlers();
|
|
|
|
const counters = await Promise.all(Object.values(addons).map((addon) => this.getAddonBadge(siteId, addon)));
|
|
|
|
const total = counters.reduce((previous, counter) => previous + counter, 0);
|
|
|
|
// Save the counter on site.
|
|
await this.saveAddonBadge(total, siteId);
|
|
|
|
await this.updateAppCounter();
|
|
|
|
return total;
|
|
}
|
|
|
|
/**
|
|
* Register a device in Apple APNS or Google GCM.
|
|
*
|
|
* @returns Promise resolved when the device is registered.
|
|
*/
|
|
async registerDevice(): Promise<void> {
|
|
try {
|
|
// Check if sound is enabled for notifications.
|
|
const options = await this.getOptions();
|
|
|
|
const pushObject = Push.init(options);
|
|
|
|
pushObject.on('notification').subscribe((notification: NotificationEventResponse | {registrationType: string}) => {
|
|
// Execute the callback in the Angular zone, so change detection doesn't stop working.
|
|
NgZone.run(() => {
|
|
if ('registrationType' in notification) {
|
|
// Not a valid notification, ignore.
|
|
return;
|
|
}
|
|
|
|
this.logger.log('Received a notification', notification);
|
|
this.onMessageReceived(notification);
|
|
});
|
|
});
|
|
|
|
pushObject.on('registration').subscribe((data: RegistrationEventResponse) => {
|
|
// Execute the callback in the Angular zone, so change detection doesn't stop working.
|
|
NgZone.run(() => {
|
|
this.pushID = data.registrationId;
|
|
if (!CoreSites.isLoggedIn() || !this.canRegisterOnMoodle()) {
|
|
return;
|
|
}
|
|
|
|
this.registerDeviceOnMoodle().catch((error) => {
|
|
this.logger.error('Can\'t register device', error);
|
|
});
|
|
});
|
|
});
|
|
|
|
pushObject.on('error').subscribe((error: Error) => {
|
|
// Execute the callback in the Angular zone, so change detection doesn't stop working.
|
|
NgZone.run(() => {
|
|
this.logger.warn('Error with Push plugin', error);
|
|
});
|
|
});
|
|
} catch (error) {
|
|
this.logger.warn(error);
|
|
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Registers a device on a Moodle site if needed.
|
|
*
|
|
* @param siteId Site ID. If not defined, current site.
|
|
* @param forceUnregister Whether to force unregister and register.
|
|
* @returns Promise resolved when device is registered.
|
|
*/
|
|
async registerDeviceOnMoodle(siteId?: string, forceUnregister?: boolean): Promise<void> {
|
|
this.logger.debug('Register device on Moodle.');
|
|
|
|
if (!this.canRegisterOnMoodle()) {
|
|
return Promise.reject(null);
|
|
}
|
|
|
|
const site = await CoreSites.getSite(siteId);
|
|
|
|
try {
|
|
|
|
const data = this.getRequiredRegisterData();
|
|
data.publickey = await this.getPublicKeyForSite(site);
|
|
|
|
const neededActions = await this.getRegisterDeviceActions(data, site, forceUnregister);
|
|
|
|
if (neededActions.unregister) {
|
|
// Unregister the device first.
|
|
await CoreUtils.ignoreErrors(this.unregisterDeviceOnMoodle(site));
|
|
}
|
|
|
|
if (neededActions.register) {
|
|
// Now register the device.
|
|
const addDeviceResponse =
|
|
await site.write<CoreUserAddUserDeviceWSResponse>('core_user_add_user_device', CoreUtils.clone(data));
|
|
|
|
const deviceAlreadyRegistered =
|
|
addDeviceResponse[0] && addDeviceResponse[0].find(warning => warning.warningcode === 'existingkeyforthisuser');
|
|
if (deviceAlreadyRegistered && data.publickey) {
|
|
// Device already registered, make sure the public key is up to date.
|
|
await this.updatePublicKeyOnMoodle(site, data);
|
|
}
|
|
|
|
CoreEvents.trigger(CoreEvents.DEVICE_REGISTERED_IN_MOODLE, {}, site.getId());
|
|
|
|
// Insert the device in the local DB.
|
|
await CoreUtils.ignoreErrors(this.registeredDevicesTables[site.getId()].insert(data));
|
|
} else if (neededActions.updatePublicKey) {
|
|
// Device already registered, make sure the public key is up to date.
|
|
const response = await this.updatePublicKeyOnMoodle(site, data);
|
|
|
|
if (response?.warnings?.find(warning => warning.warningcode === 'devicedoesnotexist')) {
|
|
// The device doesn't exist in the server. Remove the device from the local DB and try again.
|
|
await this.registeredDevicesTables[site.getId()].delete({
|
|
appid: data.appid,
|
|
uuid: data.uuid,
|
|
name: data.name,
|
|
model: data.model,
|
|
platform: data.platform,
|
|
});
|
|
|
|
await this.registerDeviceOnMoodle(siteId, false);
|
|
}
|
|
}
|
|
} finally {
|
|
// Remove pending unregisters for this site.
|
|
await CoreUtils.ignoreErrors(this.pendingUnregistersTable.deleteByPrimaryKey({ siteid: site.getId() }));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get the public key to register in a site.
|
|
*
|
|
* @param site Site to register
|
|
* @returns Public key, undefined if the site or the device doesn't support encryption.
|
|
*/
|
|
protected async getPublicKeyForSite(site: CoreSite): Promise<string | undefined> {
|
|
if (!site.wsAvailable('core_user_update_user_device_public_key')) {
|
|
return;
|
|
}
|
|
|
|
return await this.getPublicKey();
|
|
}
|
|
|
|
/**
|
|
* Get the device public key.
|
|
*
|
|
* @returns Public key, undefined if the device doesn't support encryption.
|
|
*/
|
|
async getPublicKey(): Promise<string | undefined> {
|
|
if (!CorePlatform.isMobile()) {
|
|
return;
|
|
}
|
|
|
|
const publicKey = await Push.getPublicKey();
|
|
|
|
return publicKey ?? undefined;
|
|
}
|
|
|
|
/**
|
|
* Update a public key on a Moodle site.
|
|
*
|
|
* @param site Site.
|
|
* @param data Device data.
|
|
* @returns WS response, undefined if no public key.
|
|
*/
|
|
protected async updatePublicKeyOnMoodle(
|
|
site: CoreSite,
|
|
data: CoreUserAddUserDeviceWSParams,
|
|
): Promise<CoreUserUpdateUserDevicePublicKeyWSResponse | undefined> {
|
|
if (!data.publickey) {
|
|
return;
|
|
}
|
|
|
|
this.logger.debug('Update public key on Moodle.');
|
|
|
|
const params: CoreUserUpdateUserDevicePublicKeyWSParams = {
|
|
uuid: data.uuid,
|
|
appid: data.appid,
|
|
publickey: data.publickey,
|
|
};
|
|
|
|
return await site.write<CoreUserUpdateUserDevicePublicKeyWSResponse>('core_user_update_user_device_public_key', params);
|
|
}
|
|
|
|
/**
|
|
* Get the addon/site badge counter from the database.
|
|
*
|
|
* @param siteId Site ID.
|
|
* @param addon Registered addon name. If not defined it will store the site total.
|
|
* @returns Promise resolved with the stored badge counter for the addon or site or 0 if none.
|
|
*/
|
|
protected async getAddonBadge(siteId?: string, addon: string = 'site'): Promise<number> {
|
|
try {
|
|
const entry = await this.badgesTable.getOne({ siteid: siteId, addon });
|
|
|
|
return entry?.number || 0;
|
|
} catch (err) {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Retry pending unregisters.
|
|
*
|
|
* @param siteId If defined, retry only for that site if needed. Otherwise, retry all pending unregisters.
|
|
* @returns Promise resolved when done.
|
|
*/
|
|
async retryUnregisters(siteId?: string): Promise<void> {
|
|
const results = await this.pendingUnregistersTable.getMany(CoreObject.withoutEmpty({ siteid: siteId }));
|
|
|
|
await Promise.all(results.map(async (result) => {
|
|
// Create a temporary site to unregister.
|
|
const tmpSite = CoreSitesFactory.makeSite(
|
|
result.siteid,
|
|
result.siteurl,
|
|
result.token,
|
|
{ info: CoreTextUtils.parseJSON<CoreSiteInfo | null>(result.info, null) || undefined },
|
|
);
|
|
|
|
await this.unregisterDeviceOnMoodle(tmpSite);
|
|
}));
|
|
}
|
|
|
|
/**
|
|
* Save the addon/site badgecounter on the database.
|
|
*
|
|
* @param value The number to be stored.
|
|
* @param siteId Site ID. If not defined, use current site.
|
|
* @param addon Registered addon name. If not defined it will store the site total.
|
|
* @returns Promise resolved with the stored badge counter for the addon or site.
|
|
*/
|
|
protected async saveAddonBadge(value: number, siteId?: string, addon: string = 'site'): Promise<number> {
|
|
siteId = siteId || CoreSites.getCurrentSiteId();
|
|
|
|
await this.badgesTable.insert({
|
|
siteid: siteId,
|
|
addon,
|
|
number: value, // eslint-disable-line id-blacklist
|
|
});
|
|
|
|
return value;
|
|
}
|
|
|
|
/**
|
|
* Get the needed actions to perform to register a device.
|
|
*
|
|
* @param data Data of the device.
|
|
* @param site Site to use.
|
|
* @param forceUnregister Whether to force unregister and register.
|
|
* @returns Whether each action needs to be performed or not.
|
|
*/
|
|
protected async getRegisterDeviceActions(
|
|
data: CoreUserAddUserDeviceWSParams,
|
|
site: CoreSite,
|
|
forceUnregister?: boolean,
|
|
): Promise<RegisterDeviceActions> {
|
|
if (forceUnregister) {
|
|
// No need to check if device is stored, always unregister and register the device.
|
|
return {
|
|
unregister: true,
|
|
register: true,
|
|
updatePublicKey: false,
|
|
};
|
|
}
|
|
|
|
// Check if the device is already registered.
|
|
const records = await CoreUtils.ignoreErrors(
|
|
this.registeredDevicesTables[site.getId()].getMany({
|
|
appid: data.appid,
|
|
uuid: data.uuid,
|
|
name: data.name,
|
|
model: data.model,
|
|
platform: data.platform,
|
|
}),
|
|
);
|
|
|
|
let isStored = false;
|
|
let versionOrPushChanged = false;
|
|
let updatePublicKey = false;
|
|
|
|
(records || []).forEach((record) => {
|
|
if (record.version == data.version && record.pushid == data.pushid) {
|
|
// The device is already stored.
|
|
isStored = true;
|
|
updatePublicKey = !!data.publickey && record.publickey !== data.publickey;
|
|
} else {
|
|
// The version or pushid has changed.
|
|
versionOrPushChanged = true;
|
|
}
|
|
});
|
|
|
|
return {
|
|
register: !isStored, // No need to register if device is already stored.
|
|
unregister: !isStored && !versionOrPushChanged, // No need to unregister first if only version or push changed.
|
|
updatePublicKey,
|
|
};
|
|
}
|
|
|
|
}
|
|
|
|
export const CorePushNotifications = makeSingleton(CorePushNotificationsProvider);
|
|
|
|
/**
|
|
* Additional data sent in push notifications.
|
|
*/
|
|
export type CorePushNotificationsNotificationBasicRawData = {
|
|
customdata?: string; // Custom data.
|
|
extrafeatures?: string; // "1" if the notification uses extrafeatures, "0" otherwise.
|
|
foreground?: boolean; // Whether the app was in foreground.
|
|
'image-type'?: string; // How to display the notification image.
|
|
moodlecomponent?: string; // Moodle component that triggered the notification.
|
|
name?: string; // A name to identify the type of notification.
|
|
notId?: string; // Notification ID.
|
|
notif?: string; // "1" if it's a notification, "0" if it's a Moodle message.
|
|
site?: string; // ID of the site sending the notification.
|
|
siteurl?: string; // URL of the site the notification is related to.
|
|
usertoid?: string; // ID of user receiving the push.
|
|
conversationtype?: string; // Conversation type. Only if it's a push generated by a Moodle message.
|
|
userfromfullname?: string; // Fullname of user sending the push. Only if it's a push generated by a Moodle message.
|
|
userfromid?: string; // ID of user sending the push. Only if it's a push generated by a Moodle message.
|
|
picture?: string; // Notification big picture. "Extra" feature.
|
|
summaryText?: string; // Notification summary text. "Extra" feature.
|
|
sender?: string; // Name of the user who sent the message. "Extra" feature.
|
|
senderImage?: string; // Image of the user who sent the message. "Extra" feature.
|
|
};
|
|
|
|
/**
|
|
* Additional data sent in push notifications, with some calculated data.
|
|
*/
|
|
export type CorePushNotificationsNotificationBasicData = Omit<CorePushNotificationsNotificationBasicRawData, 'customdata'> & {
|
|
title?: string; // Notification title.
|
|
message?: string; // Notification message.
|
|
customdata?: Record<string, string|number>; // Parsed custom data.
|
|
};
|
|
|
|
/**
|
|
* Params of core_user_remove_user_device WS.
|
|
*/
|
|
export type CoreUserRemoveUserDeviceWSParams = {
|
|
uuid: string; // The device UUID.
|
|
appid?: string; // The app id, if empty devices matching the UUID for the user will be removed.
|
|
};
|
|
|
|
/**
|
|
* Data returned by core_user_remove_user_device WS.
|
|
*/
|
|
export type CoreUserRemoveUserDeviceWSResponse = {
|
|
removed: boolean; // True if removed, false if not removed because it doesn't exists.
|
|
warnings?: CoreWSExternalWarning[];
|
|
};
|
|
/**
|
|
* Params of core_user_add_user_device WS.
|
|
*/
|
|
export type CoreUserAddUserDeviceWSParams = {
|
|
appid: string; // The app id, usually something like com.moodle.moodlemobile.
|
|
name: string; // The device name, 'occam' or 'iPhone' etc.
|
|
model: string; // The device model 'Nexus4' or 'iPad1,1' etc.
|
|
platform: string; // The device platform 'iOS' or 'Android' etc.
|
|
version: string; // The device version '6.1.2' or '4.2.2' etc.
|
|
pushid: string; // The device PUSH token/key/identifier/registration id.
|
|
uuid: string; // The device UUID.
|
|
publickey?: string; // @since 4.2. The app generated public key.
|
|
};
|
|
|
|
/**
|
|
* Data returned by core_user_add_user_device WS.
|
|
*/
|
|
export type CoreUserAddUserDeviceWSResponse = CoreWSExternalWarning[][];
|
|
|
|
/**
|
|
* Params of core_user_update_user_device_public_key WS.
|
|
*/
|
|
export type CoreUserUpdateUserDevicePublicKeyWSParams = {
|
|
uuid: string;
|
|
appid: string;
|
|
publickey: string;
|
|
};
|
|
|
|
/**
|
|
* Data returned by core_user_update_user_device_public_key WS.
|
|
*/
|
|
export type CoreUserUpdateUserDevicePublicKeyWSResponse = {
|
|
status: boolean;
|
|
warnings?: CoreWSExternalWarning[];
|
|
};
|
|
|
|
type RegisterDeviceActions = {
|
|
register: boolean; // Whether device needs to be registered in LMS.
|
|
unregister: boolean; // Whether device needs to be unregistered before register in LMS to make sure data is up to date.
|
|
updatePublicKey: boolean; // Whether only public key needs to be updated.
|
|
};
|