Merge pull request #1839 from dpalou/MOBILE-2927

Mobile 2927

src/addon/messages/messages.module.ts

@@ -121,8 +121,8 @@ export class AddonMessagesModule {
                             // Check if we have enough information to open the conversation.
                             if (notification.convid && enabled) {
                                 pageParams.conversationId = Number(notification.convid);
-                            } else if (notification.userfromid) {
+                            } else if (notification.userfromid || notification.useridfrom) {
-                                pageParams.discussionUserId = Number(notification.userfromid);
+                                pageParams.discussionUserId = Number(notification.userfromid || notification.useridfrom);
                             }
 
                             linkHelper.goInSite(undefined, pageName, pageParams, notification.site);

src/addon/messages/providers/mainmenu-handler.ts

@@ -229,10 +229,61 @@ export class AddonMessagesMainMenuHandler implements CoreMainMenuHandler, CoreCr
      * @return {Promise<any>}    Promise resolved with the notifications.
      */
     protected fetchMessages(siteId?: string): Promise<any> {
+        return this.sitesProvider.getSite(siteId).then((site) => {
+            if (site.isVersionGreaterEqualThan('3.7')) {
+
+                // Use get conversations WS to be able to get group conversations messages.
+                return this.messagesProvider.getConversations(undefined, undefined, 0, site.id, undefined, false, true)
+                        .then((result) => {
+
+                    // Find the first unmuted conversation.
+                    const conv = result.conversations.find((conversation) => {
+                        return !conversation.ismuted;
+                    });
+
+                    if (conv.isread) {
+                        // The conversation is read, no unread messages.
+                        return [];
+                    }
+
+                    const currentUserId = site.getUserId(),
+                        message = conv.messages[0]; // Treat only the last message, is the one we're interested.
+
+                    if (!message || message.useridfrom == currentUserId) {
+                        // No last message or not from current user. Return empty list.
+                        return [];
+                    }
+
+                    // Add some calculated data.
+                    message.contexturl = '';
+                    message.contexturlname = '';
+                    message.convid = conv.id;
+                    message.fullmessage = message.text;
+                    message.fullmessageformat = 0;
+                    message.fullmessagehtml = '';
+                    message.notification = 0;
+                    message.read = 0;
+                    message.smallmessage = message.smallmessage || message.text;
+                    message.subject = conv.name;
+                    message.timecreated = message.timecreated * 1000;
+                    message.timeread = 0;
+                    message.useridto = currentUserId;
+                    message.usertofullname = site.getInfo().fullname;
+
+                    const userFrom = conv.members.find((member) => {
+                        return member.id == message.useridfrom;
+                    });
+                    message.userfromfullname = userFrom && userFrom.fullname;
+
+                    return [message];
+                });
+            } else {
                 return this.messagesProvider.getUnreadReceivedMessages(true, false, true, siteId).then((response) => {
                     return response.messages;
                 });
             }
+        });
+    }
 
     /**
      * Given a message, return the title and the text for the message.
@@ -242,7 +293,7 @@ export class AddonMessagesMainMenuHandler implements CoreMainMenuHandler, CoreCr
      */
     protected getTitleAndText(message: any): Promise<any> {
         const data = {
-            title: message.userfromfullname,
+            title: message.name || message.userfromfullname,
         };
 
         return this.textUtils.formatText(message.text, true, true).catch(() => {

src/addon/messages/providers/messages.ts

@@ -882,14 +882,20 @@ export class AddonMessagesProvider {
                     result.messages = result.messages.slice(0, limitTo);
                 }
 
+                let lastReceived;
+
                 result.messages.forEach((message) => {
                     // Convert time to milliseconds.
                     message.timecreated = message.timecreated ? message.timecreated * 1000 : 0;
+
+                    if (!lastReceived && message.useridfrom != userId) {
+                        lastReceived = message;
+                    }
                 });
 
-                if (this.appProvider.isDesktop() && params.useridto == userId && limitFrom === 0) {
+                if (this.appProvider.isDesktop() && limitFrom === 0 && lastReceived) {
                     // Store the last received message (we cannot know if it's unread or not). Don't block the user for this.
-                    this.storeLastReceivedMessageIfNeeded(conversationId, result.messages[0], site.getId());
+                    this.storeLastReceivedMessageIfNeeded(conversationId, lastReceived, site.getId());
                 }
 
                 if (excludePending) {
@@ -923,11 +929,13 @@ export class AddonMessagesProvider {
      * @param {number} [limitFrom=0] The offset to start at.
      * @param {string} [siteId] Site ID. If not defined, use current site.
      * @param {number} [userId] User ID. If not defined, current user in the site.
+     * @param {boolean} [forceCache] True if it should return cached data. Has priority over ignoreCache.
+     * @param {boolean} [ignoreCache] True if it should ignore cached data (it will always fail in offline or server down).
      * @return {Promise<any>} Promise resolved with the conversations.
      * @since 3.6
      */
-    getConversations(type?: number, favourites?: boolean, limitFrom: number = 0, siteId?: string, userId?: number)
+    getConversations(type?: number, favourites?: boolean, limitFrom: number = 0, siteId?: string, userId?: number,
-            : Promise<{conversations: any[], canLoadMore: boolean}> {
+            forceCache?: boolean, ignoreCache?: boolean): Promise<{conversations: any[], canLoadMore: boolean}> {
 
         return this.sitesProvider.getSite(siteId).then((site) => {
             userId = userId || site.getUserId();
@@ -941,6 +949,13 @@ export class AddonMessagesProvider {
                     limitnum: this.LIMIT_MESSAGES + 1,
                 };
 
+            if (forceCache) {
+                preSets['omitExpires'] = true;
+            } else if (ignoreCache) {
+                preSets['getFromCache'] = false;
+                preSets['emergencyCache'] = false;
+            }
+
             if (typeof type != 'undefined' && type != null) {
                 params.type = type;
             }
@@ -952,7 +967,14 @@ export class AddonMessagesProvider {
                 // Format the conversations, adding some calculated fields.
                 const conversations = response.conversations.slice(0, this.LIMIT_MESSAGES).map((conversation) => {
                         return this.formatConversation(conversation, userId);
-                });
+                    }),
+                    conv = conversations[0],
+                    lastMessage = conv && conv.messages[0];
+
+                if (this.appProvider.isDesktop() && limitFrom === 0 && lastMessage && !conv.sentfromcurrentuser) {
+                    // Store the last received message (we cannot know if it's unread or not). Don't block the user for this.
+                    this.storeLastReceivedMessageIfNeeded(conv.id, lastMessage, site.getId());
+                }
 
                 return {
                     conversations: conversations,

src/addon/notifications/notifications.module.ts

@@ -14,23 +14,23 @@
 
 import { NgModule, NgZone } from '@angular/core';
 import { AddonNotificationsProvider } from './providers/notifications';
+import { AddonNotificationsHelperProvider } from './providers/helper';
 import { AddonNotificationsMainMenuHandler } from './providers/mainmenu-handler';
 import { AddonNotificationsSettingsHandler } from './providers/settings-handler';
 import { AddonNotificationsCronHandler } from './providers/cron-handler';
 import { AddonNotificationsPushClickHandler } from './providers/push-click-handler';
 import { CoreAppProvider } from '@providers/app';
-import { CoreContentLinksHelperProvider } from '@core/contentlinks/providers/helper';
+import { CoreInitDelegate } from '@providers/init';
 import { CoreMainMenuDelegate } from '@core/mainmenu/providers/delegate';
 import { CoreSettingsDelegate } from '@core/settings/providers/delegate';
 import { CoreCronDelegate } from '@providers/cron';
 import { CoreLocalNotificationsProvider } from '@providers/local-notifications';
-import { CoreSitesProvider } from '@providers/sites';
-import { CoreUtilsProvider } from '@providers/utils/utils';
 import { CorePushNotificationsDelegate } from '@core/pushnotifications/providers/delegate';
 
 // List of providers (without handlers).
 export const ADDON_NOTIFICATIONS_PROVIDERS: any[] = [
-    AddonNotificationsProvider
+    AddonNotificationsProvider,
+    AddonNotificationsHelperProvider
 ];
 
 @NgModule({
@@ -40,6 +40,7 @@ export const ADDON_NOTIFICATIONS_PROVIDERS: any[] = [
     ],
     providers: [
         AddonNotificationsProvider,
+        AddonNotificationsHelperProvider,
         AddonNotificationsMainMenuHandler,
         AddonNotificationsSettingsHandler,
         AddonNotificationsCronHandler,
@@ -50,9 +51,8 @@ export class AddonNotificationsModule {
     constructor(mainMenuDelegate: CoreMainMenuDelegate, mainMenuHandler: AddonNotificationsMainMenuHandler,
             settingsDelegate: CoreSettingsDelegate, settingsHandler: AddonNotificationsSettingsHandler,
             cronDelegate: CoreCronDelegate, cronHandler: AddonNotificationsCronHandler, zone: NgZone,
-            appProvider: CoreAppProvider, utils: CoreUtilsProvider, sitesProvider: CoreSitesProvider,
+            appProvider: CoreAppProvider, localNotifications: CoreLocalNotificationsProvider,
-            notificationsProvider: AddonNotificationsProvider, localNotifications: CoreLocalNotificationsProvider,
+            initDelegate: CoreInitDelegate, pushNotificationsDelegate: CorePushNotificationsDelegate,
-            linkHelper: CoreContentLinksHelperProvider, pushNotificationsDelegate: CorePushNotificationsDelegate,
             pushClickHandler: AddonNotificationsPushClickHandler) {
 
         mainMenuDelegate.registerHandler(mainMenuHandler);
@@ -60,22 +60,13 @@ export class AddonNotificationsModule {
         cronDelegate.register(cronHandler);
         pushNotificationsDelegate.registerClickHandler(pushClickHandler);
 
-        const notificationClicked = (notification: any): void => {
-            sitesProvider.isFeatureDisabled('CoreMainMenuDelegate_AddonNotifications', notification.site).then((disabled) => {
-                if (disabled) {
-                    // Notifications are disabled, stop.
-                    return;
-                }
-
-                notificationsProvider.invalidateNotificationsList().finally(() => {
-                    linkHelper.goInSite(undefined, 'AddonNotificationsListPage', undefined, notification.site);
-                });
-            });
-        };
-
         if (appProvider.isDesktop()) {
             // Listen for clicks in simulated push notifications.
-            localNotifications.registerClick(AddonNotificationsProvider.PUSH_SIMULATION_COMPONENT, notificationClicked);
+            localNotifications.registerClick(AddonNotificationsProvider.PUSH_SIMULATION_COMPONENT, (notification) => {
+                initDelegate.ready().then(() => {
+                    pushNotificationsDelegate.clicked(notification);
+                });
+            });
         }
     }
 }

src/addon/notifications/pages/list/list.ts

@@ -21,6 +21,7 @@ import { CoreEventsProvider, CoreEventObserver } from '@providers/events';
 import { CoreSitesProvider } from '@providers/sites';
 import { CoreUtilsProvider } from '@providers/utils/utils';
 import { AddonNotificationsProvider } from '../../providers/notifications';
+import { AddonNotificationsHelperProvider } from '../../providers/helper';
 import { CorePushNotificationsDelegate } from '@core/pushnotifications/providers/delegate';
 
 /**
@@ -40,15 +41,14 @@ export class AddonNotificationsListPage {
     canMarkAllNotificationsAsRead = false;
     loadingMarkAllNotificationsAsRead = false;
 
-    protected readCount = 0;
-    protected unreadCount = 0;
     protected cronObserver: CoreEventObserver;
     protected pushObserver: Subscription;
 
     constructor(navParams: NavParams, private domUtils: CoreDomUtilsProvider, private eventsProvider: CoreEventsProvider,
             private sitesProvider: CoreSitesProvider, private textUtils: CoreTextUtilsProvider,
             private utils: CoreUtilsProvider, private notificationsProvider: AddonNotificationsProvider,
-            private pushNotificationsDelegate: CorePushNotificationsDelegate) {
+            private pushNotificationsDelegate: CorePushNotificationsDelegate,
+            private notificationsHelper: AddonNotificationsHelperProvider) {
     }
 
     /**
@@ -79,53 +79,17 @@ export class AddonNotificationsListPage {
     protected fetchNotifications(refresh?: boolean): Promise<any> {
         this.loadMoreError = false;
 
+        return this.notificationsHelper.getNotifications(refresh ? [] : this.notifications).then((result) => {
+            result.notifications.forEach(this.formatText.bind(this));
+
             if (refresh) {
-            this.readCount = 0;
+                this.notifications = result.notifications;
-            this.unreadCount = 0;
-        }
-
-        const limit = AddonNotificationsProvider.LIST_LIMIT;
-
-        return this.notificationsProvider.getUnreadNotifications(this.unreadCount, limit).then((unread) => {
-            const promises = [];
-
-            unread.forEach(this.formatText.bind(this));
-
-            /* Don't add the unread notifications to this.notifications yet. If there are no unread notifications
-               that causes that the "There are no notifications" message is shown in pull to refresh. */
-            this.unreadCount += unread.length;
-
-            if (unread.length < limit) {
-                // Limit not reached. Get read notifications until reach the limit.
-                const readLimit = limit - unread.length;
-                promises.push(this.notificationsProvider.getReadNotifications(this.readCount, readLimit).then((read) => {
-                    read.forEach(this.formatText.bind(this));
-                    this.readCount += read.length;
-                    if (refresh) {
-                        this.notifications = unread.concat(read);
             } else {
-                        this.notifications = this.notifications.concat(unread, read);
+                this.notifications = this.notifications.concat(result.notifications);
-                    }
-                    this.canLoadMore = read.length >= readLimit;
-                }).catch((error) => {
-                    if (unread.length == 0) {
-                        this.domUtils.showErrorModalDefault(error, 'addon.notifications.errorgetnotifications', true);
-                        this.loadMoreError = true; // Set to prevent infinite calls with infinite-loading.
-                    }
-                }));
-            } else {
-                if (refresh) {
-                    this.notifications = unread;
-                } else {
-                    this.notifications = this.notifications.concat(unread);
-                }
-                this.canLoadMore = true;
             }
+            this.canLoadMore = result.canLoadMore;
 
-            return Promise.all(promises).then(() => {
+            this.markNotificationsAsRead(result.notifications);
-                // Mark retrieved notifications as read if they are not.
-                this.markNotificationsAsRead(unread);
-            });
         }).catch((error) => {
             this.domUtils.showErrorModalDefault(error, 'addon.notifications.errorgetnotifications', true);
             this.loadMoreError = true; // Set to prevent infinite calls with infinite-loading.
@@ -162,6 +126,11 @@ export class AddonNotificationsListPage {
 
         if (notifications.length > 0) {
             const promises = notifications.map((notification) => {
+                if (notification.read) {
+                    // Already read, don't mark it.
+                    return Promise.resolve();
+                }
+
                 return this.notificationsProvider.markNotificationRead(notification.id);
             });
 

src/addon/notifications/providers/cron-handler.ts

@@ -21,6 +21,7 @@ import { CoreSitesProvider } from '@providers/sites';
 import { CoreTextUtilsProvider } from '@providers/utils/text';
 import { CoreEmulatorHelperProvider } from '@core/emulator/providers/helper';
 import { AddonNotificationsProvider } from './notifications';
+import { AddonNotificationsHelperProvider } from './helper';
 
 /**
  * Notifications cron handler.
@@ -32,7 +33,7 @@ export class AddonNotificationsCronHandler implements CoreCronHandler {
     constructor(private appProvider: CoreAppProvider, private eventsProvider: CoreEventsProvider,
             private sitesProvider: CoreSitesProvider, private localNotifications: CoreLocalNotificationsProvider,
             private notificationsProvider: AddonNotificationsProvider, private textUtils: CoreTextUtilsProvider,
-            private emulatorHelper: CoreEmulatorHelperProvider) {}
+            private emulatorHelper: CoreEmulatorHelperProvider, private notificationsHelper: AddonNotificationsHelperProvider) {}
 
     /**
      * Get the time between consecutive executions.
@@ -91,7 +92,9 @@ export class AddonNotificationsCronHandler implements CoreCronHandler {
      * @return {Promise<any[]>} Promise resolved with the notifications.
      */
     protected fetchNotifications(siteId: string): Promise<any[]> {
-        return this.notificationsProvider.getUnreadNotifications(0, undefined, true, false, true, siteId);
+        return this.notificationsHelper.getNotifications([], undefined, true, false, true, siteId).then((result) => {
+            return result.notifications;
+        });
     }
 
     /**
@@ -102,7 +105,7 @@ export class AddonNotificationsCronHandler implements CoreCronHandler {
      */
     protected getTitleAndText(notification: any): Promise<any> {
         const data = {
-            title: notification.userfromfullname,
+            title: notification.subject || notification.userfromfullname,
             text: notification.mobiletext.replace(/-{4,}/ig, '')
         };
         data.text = this.textUtils.replaceNewLines(data.text, '<br>');

src/addon/notifications/providers/helper.ts

@@ -0,0 +1,93 @@
+// (C) Copyright 2015 Martin Dougiamas
+//
+// 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 { CoreSitesProvider } from '@providers/sites';
+import { AddonNotificationsProvider } from './notifications';
+
+/**
+ * Service that provides some helper functions for notifications.
+ */
+@Injectable()
+export class AddonNotificationsHelperProvider {
+
+    constructor(private notificationsProvider: AddonNotificationsProvider, private sitesProvider: CoreSitesProvider) {
+    }
+
+    /**
+     * Get some notifications. It will try to use the new WS if available.
+     *
+     * @param {any[]} notifications Current list of loaded notifications. It's used to calculate the offset.
+     * @param {number} [limit] Number of notifications to get. Defaults to LIST_LIMIT.
+     * @param {boolean} [toDisplay=true] True if notifications will be displayed to the user, either in view or in a notification.
+     * @param {boolean} [forceCache] True if it should return cached data. Has priority over ignoreCache.
+     * @param {boolean} [ignoreCache] True if it should ignore cached data (it will always fail in offline or server down).
+     * @param {string} [siteId] Site ID. If not defined, use current site.
+     * @return {Promise<{notifications: any[], canLoadMore: boolean}>} Promise resolved with notifications and if can load more.
+     */
+    getNotifications(notifications: any[], limit?: number, toDisplay: boolean = true, forceCache?: boolean, ignoreCache?: boolean,
+            siteId?: string): Promise<{notifications: any[], canLoadMore: boolean}> {
+
+        notifications = notifications || [];
+        limit = limit || AddonNotificationsProvider.LIST_LIMIT;
+        siteId = siteId || this.sitesProvider.getCurrentSiteId();
+
+        return this.notificationsProvider.isPopupAvailable(siteId).then((available) => {
+
+            if (available) {
+                return this.notificationsProvider.getPopupNotifications(notifications.length, limit, toDisplay, forceCache,
+                        ignoreCache, siteId);
+
+            } else {
+                // Fallback to get_messages. We need 2 calls, one for read and the other one for unread.
+                const unreadFrom = notifications.reduce((total, current) => {
+                    return total + (current.read ? 0 : 1);
+                }, 0);
+
+                return this.notificationsProvider.getUnreadNotifications(unreadFrom, limit, toDisplay, forceCache, ignoreCache,
+                        siteId).then((unread) => {
+
+                    let promise;
+
+                    if (unread.length < limit) {
+                        // Limit not reached. Get read notifications until reach the limit.
+                        const readLimit = limit - unread.length,
+                            readFrom = notifications.length - unreadFrom;
+
+                        promise = this.notificationsProvider.getReadNotifications(readFrom, readLimit, toDisplay, forceCache,
+                                ignoreCache, siteId).then((read) => {
+                            return unread.concat(read);
+                        }).catch((error): any => {
+                            if (unread.length > 0) {
+                                // We were able to get some unread, return only the unread ones.
+                                return unread;
+                            }
+
+                            return Promise.reject(error);
+                        });
+                    } else {
+                        promise = Promise.resolve(unread);
+                    }
+
+                    return promise.then((notifications) => {
+                        return {
+                            notifications: notifications,
+                            canLoadMore: notifications.length >= limit
+                        };
+                    });
+                });
+            }
+        });
+    }
+}

src/addon/notifications/providers/notifications.ts

@@ -45,9 +45,10 @@ export class AddonNotificationsProvider {
      * Function to format notification data.
      *
      * @param {any[]} notifications List of notifications.
+     * @param {boolean} [read] Whether the notifications are read or unread.
      * @return {Promise<any[]>} Promise resolved with notifications.
      */
-    protected formatNotificationsData(notifications: any[]): Promise<any> {
+    protected formatNotificationsData(notifications: any[], read?: boolean): Promise<any> {
         const promises = notifications.map((notification) => {
             // Set message to show.
             if (notification.contexturl && notification.contexturl.indexOf('/mod/forum/') >= 0) {
@@ -55,6 +56,7 @@ export class AddonNotificationsProvider {
             } else {
                 notification.mobiletext = notification.fullmessage;
             }
+
             // Try to set courseid the notification belongs to.
             const cid = notification.fullmessagehtml.match(/course\/view\.php\?id=([^"]*)/);
             if (cid && cid[1]) {
@@ -71,6 +73,13 @@ export class AddonNotificationsProvider {
                 });
             }
 
+            notification.moodlecomponent = notification.component;
+            notification.notification = 1;
+            notification.notif = 1;
+            if (typeof read != 'undefined') {
+                notification.read = read;
+            }
+
             return Promise.resolve(notification);
         });
 
@@ -154,7 +163,7 @@ export class AddonNotificationsProvider {
                 if (response.messages) {
                     const notifications = response.messages;
 
-                    return this.formatNotificationsData(notifications).then(() => {
+                    return this.formatNotificationsData(notifications, read).then(() => {
                         if (this.appProvider.isDesktop() && toDisplay && !read && limitFrom === 0) {
                             // Store the last received notification. Don't block the user for this.
                             this.emulatorHelper.storeLastReceivedNotification(
@@ -170,6 +179,67 @@ export class AddonNotificationsProvider {
         });
     }
 
+    /**
+     * Get notifications from site using the new WebService.
+     *
+     * @param {number} offset Position of the first notification to get.
+     * @param {number} [limit] Number of notifications to get. Defaults to LIST_LIMIT.
+     * @param {boolean} [toDisplay=true] True if notifications will be displayed to the user, either in view or in a notification.
+     * @param {boolean} [forceCache] True if it should return cached data. Has priority over ignoreCache.
+     * @param {boolean} [ignoreCache] True if it should ignore cached data (it will always fail in offline or server down).
+     * @param {string} [siteId] Site ID. If not defined, use current site.
+     * @return {Promise<{notifications: any[], canLoadMore: boolean}>} Promise resolved with notifications and if can load more.
+     * @since 3.2
+     */
+    getPopupNotifications(offset: number, limit?: number, toDisplay: boolean = true, forceCache?: boolean, ignoreCache?: boolean,
+            siteId?: string): Promise<{notifications: any[], canLoadMore: boolean}> {
+
+        limit = limit || AddonNotificationsProvider.LIST_LIMIT;
+
+        this.logger.debug('Get popup notifications from ' + offset + '. Limit: ' + limit);
+
+        return this.sitesProvider.getSite(siteId).then((site) => {
+            const data = {
+                    useridto: site.getUserId(),
+                    newestfirst: 1,
+                    offset: offset,
+                    limit: limit + 1 // Get one more to calculate canLoadMore.
+                },
+                preSets = {
+                    cacheKey: this.getNotificationsCacheKey(),
+                    omitExpires: forceCache,
+                    getFromCache: forceCache || !ignoreCache,
+                    emergencyCache: forceCache || !ignoreCache,
+                };
+
+            // Get notifications.
+            return site.read('message_popup_get_popup_notifications', data, preSets).then((response) => {
+                if (response.notifications) {
+                    const result: any = {
+                            canLoadMore: response.notifications.length > limit
+                        },
+                        notifications = response.notifications.slice(0, limit);
+
+                    result.notifications = notifications;
+
+                    return this.formatNotificationsData(notifications).then(() => {
+                        const first = notifications[0];
+
+                        if (this.appProvider.isDesktop() && toDisplay && offset === 0 && first && !first.read) {
+                            // Store the last received notification. Don't block the user for this.
+                            this.emulatorHelper.storeLastReceivedNotification(
+                                AddonNotificationsProvider.PUSH_SIMULATION_COMPONENT, first, siteId);
+                        }
+
+                        return result;
+                    });
+                } else {
+                    return Promise.reject(null);
+                }
+            });
+        });
+    }
+
     /**
      * Get read notifications from site.
      *
@@ -244,6 +314,18 @@ export class AddonNotificationsProvider {
         });
     }
 
+    /**
+     * Returns whether or not popup WS is available for a certain site.
+     *
+     * @param {string} [siteId] Site ID. If not defined, current site.
+     * @return {Promise<boolean>} Promise resolved with true if available, resolved with false or rejected otherwise.
+     */
+    isPopupAvailable(siteId?: string): Promise<boolean> {
+        return this.sitesProvider.getSite(siteId).then((site) => {
+            return site.wsAvailable('message_popup_get_popup_notifications');
+        });
+    }
+
     /**
      * Mark all message notification as read.
      *

src/addon/notifications/providers/push-click-handler.ts

@@ -40,7 +40,9 @@ export class AddonNotificationsPushClickHandler implements CorePushNotifications
     handles(notification: any): boolean | Promise<boolean> {
         if (this.utils.isTrueOrOne(notification.notif)) {
             // Notification clicked, mark as read. Don't block for this.
-            this.notificationsProvider.markNotificationRead(notification.savedmessageid, notification.site).then(() => {
+            const notifId = notification.savedmessageid || notification.id;
+
+            this.notificationsProvider.markNotificationRead(notifId, notification.site).then(() => {
                 this.eventsProvider.trigger(AddonNotificationsProvider.READ_CHANGED_EVENT, null, notification.site);
             }).catch(() => {
                 // Ignore errors.

src/core/emulator/providers/helper.ts

@@ -161,17 +161,15 @@ export class CoreEmulatorHelperProvider implements CoreInitHandler {
 
                 // There is a new notification, show it.
                 return getDataFn(notification).then((titleAndText) => {
+                    // Set some calculated data.
+                    notification.site = siteId;
+                    notification.name = notification.name || notification.eventtype;
+
                     const localNotif: ILocalNotification = {
                         id: 1,
-                        trigger: {
-                            at: new Date()
-                        },
                         title: titleAndText.title,
                         text: titleAndText.text,
-                        data: {
+                        data: notification
-                            notif: notification,
-                            site: siteId
-                        }
                     };
 
                     return this.localNotifProvider.schedule(localNotif, component, siteId);

src/core/emulator/providers/local-notifications.ts

@@ -630,7 +630,7 @@ export class LocalNotificationsMock extends LocalNotifications {
      * @return {number} Trigger time.
      */
     protected getNotificationTriggerAt(notification: ILocalNotification): number {
-        const triggerAt = (notification.trigger && notification.trigger.at) || 0;
+        const triggerAt = (notification.trigger && notification.trigger.at) || new Date();
 
         if (typeof triggerAt != 'number') {
             return triggerAt.getTime();